Generate DDL for objects (just for fun)

Question

I'm been putting together queries that generate DDL. Considering exp/imp ROWS=0 can be used, or DBMS_METADATA there is little point. Though, with restricted access those may not be possible options, but then an external tool like TOAD could do it. Therefore, my justification for this is "just for fun".
Here is one for TABLEs. It does not generate the CONSTRAINTs (which i try to get in the next query), and no storage clauses. This query is also formatted for fixed width font with tabs equivalent to eight characters:
SELECT
     SUBSTR
      REPLACE
      CASE
       WHEN Columns.Column_Id = 1 THEN
        'CREATE TABLE ' || Columns.Table_Name
        || CHR(10) || '('
        || CHR(10)
      END
      || ' ' || Columns.Column_Name
      || RPAD(CHR(09), Tabs - FLOOR((LENGTH(Column_Name) +1) / 8), CHR(09))
      || Data_Type
      || CASE
          WHEN Data_Type IN ('CHAR', 'VARCHAR2') THEN '(' || Char_Length || ')'
          WHEN Data_Type = 'FLOAT' THEN '(' || Data_Precision ||')'
          WHEN Data_Type = 'NUMBER' THEN
          CASE WHEN Data_Precision IS NOT NULL THEN '(' || Data_Precision
             || CASE WHEN Data_Scale IS NOT NULL THEN ', ' || Data_Scale END
           ||')'
          END
         END
      || CASE
          WHEN Data_Default IS NOT NULL
          THEN
            RPAD
             CHR(09),
             CASE Data_Type
              WHEN 'CHAR' THEN CASE Char_Length WHEN 1 THEN 2 ELSE 1 END
              WHEN 'DATE' THEN 2
              ELSE 1
             END,
             CHR(09)
           || 'DEFAULT '
           || (
            SELECT
               ExtractValue
                DBMS_XMLGEN.GetXMLType
                    SELECT
                         Data_Default
                    FROM
                         All_Tab_Columns
                    WHERE
                         Owner          = ''' || Columns.Owner || '''
                      AND     Table_Name     = ''' || Columns.Table_Name || '''
                      AND     Column_Name     = ''' || Columns.Column_Name ||'''
                'ROWSET/ROW/DATA_DEFAULT'
            FROM
               Dual
         END
      || CASE
          WHEN Columns.Column_Id = Info.Total_Columns
           THEN CHR(10) || ');' || CHR(10) || CHR(10)
          ELSE ','
         END,
         ',' || CHR(10) || CHR(10),
      ',' || CHR(10)
      1,
      181
     ) Statement
FROM
     All_Tab_Columns     Columns,
      SELECT
          Owner,
          Table_Name,
          MAX(Column_Id)                         Total_Columns,
          MAX(FLOOR((LENGTH(Column_Name) + 1) / 8)) + 1     Tabs
      FROM
          All_Tab_Columns
      WHERE
          Owner          = 'SYS'
      GROUP BY
          Owner,
          Table_Name
     )          Info
WHERE
     Columns.Owner          = Info.Owner
  AND     Columns.Table_Name     = Info.Table_Name
ORDER BY
     Columns.Owner,
     Columns.Table_Name,
     Columns.Column_Id;This next query get CONSTRAINTs. No formatting is used, because it becomes quite unweildy (though, if it used multiple lines, that would change). Another interesting thing is whether the CONSTRAINT names were generated or not. If they were generated, this still uses the old name and does not generate a new one:
WITH
     Cons_Columns
AS
      SELECT
          Owner,
          Constraint_Name,
          SUBSTR
           REPLACE
            REPLACE
             XMLAgg(XMLElement("A", Column_Name)
            '<A>',
            '</A>'
           4
          ) || '"' List
      FROM
           SELECT
               Owner,
               Constraint_Name,
               Column_Name
           FROM
               All_Cons_Columns
           ORDER BY
               Position
      GROUP BY
          Owner,
          Constraint_Name
SELECT
     'ALTER TABLE ' || Table_Name
     || ' ADD CONSTRAINT ' || Constraint_Name
     || ' '
     || CASE Constraint_Type
         WHEN 'C' THEN 'CHECK'
         WHEN 'U' THEN 'UNIQUE'
         WHEN 'P' THEN 'PRIMARY KEY'
         WHEN 'R' THEN 'FOREIGN KEY'
        END
     || '('
     || CASE
         WHEN Constraint_Type = 'C' THEN
           SELECT
               ExtractValue
                DBMS_XMLGEN.GetXMLType
                    SELECT
                         Search_Condition
                    FROM
                         All_Constraints
                    WHERE
                         Owner          = ''' || Cons.Owner || '''
                      AND     Constraint_Name     = ''' || Cons.Constraint_Name || '''
                'ROWSET/ROW/SEARCH_CONDITION'
           FROM
               Dual
        WHEN Constraint_Type IN ('P', 'R', 'U') THEN
           SELECT
               List
           FROM
               Cons_Columns
           WHERE
               Cons_Columns.Owner          = Cons.Owner
             AND     Cons_Columns.Constraint_Name     = Cons.Constraint_Name
        END     
     || ')'
     || CASE Constraint_Type
         WHEN 'R' THEN
           SELECT
               ' REFERENCES (' || List || ')'
           FROM
               Cons_Columns
           WHERE
               Cons_Columns.Owner          = Cons.R_Owner
             AND     Cons_Columns.Constraint_Name     = Cons.R_Constraint_Name
          || ' ON DELETE ' || Delete_Rule
         ELSE ''
        END
     || ' ' || DEFERRABLE || ' ' || DEFERRED
     || ' ' || VALIDATED || ' ' || STATUS || RTRIM(' ' || RELY)
     || ';'
FROM
     All_Constraints Cons
WHERE
     Owner = 'SYS'
ORDER BY
     1,
     Constraint_Name;

Answer 1

Shoblock, thanx!
For NUMBER is was using a wrong COLUMN, and also in the wrong order. Serves me right for not following the documentation. And, i just ignored FLOAT. But not it mostly matches DESC (except this query shows the ", 0" where DESC drop it instead).
I fixed the query above.
The XML part that gets the long has a failure. If the Data_Default contains an XML special char it will get encoded. The way to not encode it, it looks, requires PL/SQL. Which means it would not be done in one query (without a FUNCTION).
I am curious if anyone else is interested in such queries, whether for "fun" or otherwise.