Schema register ORA-01792 1000 column limit

I am trying to load and register the XFORMS schema (from the W3C). It loads fine, but fails to register
ERROR at line 1:
ORA-31084: error while creating table "MM"."XT_SELECTMANY" for element
"selectMany"
ORA-01792: maximum number of columns in a table or view is 1000
ORA-02310: exceeded maximum number of allowable columns in table
ORA-06512: at "XDB.DBMS_XMLSCHEMA_INT", line 17
ORA-06512: at "XDB.DBMS_XMLSCHEMA", line 26
ORA-06512: at line 2
What approach should I take to get this schema loaded into ORACLE XDB?
Thanks,
Mike

Hi,
i needed some help in registering the XSD in Oracle 9i. My query is how to register the XSD's which are described in different xsd files ??
i am able to register the XSD in which the Complex types are defined in a single file but the problem comes when i try registering another XSD that references another XSD already registered. Can anyone send a sample code please my id is [email protected]
TIA,
Ash.

Similar Messages

  • Register XSD - ORA-01792: maximum number of columns in a table or view is 1000

    Hi All,
    I am trying to register 3 schemas  HTNG_ChargePostingRS.xsd,HTNG_ServiceIssueCreateRQ.xsd,HTNG_ServiceIssueNotifRQ.xsd. When I do I get the above error. I tried again but this time I set the genTables => FALSE. I was able to register all but ChargePosting as it gave the same error.
    My questions are:
    1. What do the tables do? The only thing I will be using these schema's for is to validate incoming requests and validating my response.
    2. Why if I do not generate the table do I still get the error?

    You probably don't need object relational storage (register the schema's for binary XML usage).
    That said given that you only want to use it for validation, use odie_63's advice, and register the schema with gentypes=false and gentables=false. That should suffice.
    If you need object relational storage and/or gentables=true, than the only way to circumvent the "1000 column" limit is to break up sections of the XML Schema. For example, store a complextype or a section of the XML Schema "out of line".
    To see where a good place and/or what the culprit section is, you could use the following "analysis" script (thanks to mdrake-Oracle) for this kind of problem.
    1.       Register Types with GENTABLES false;
    2.       Use the attached script to  analyze the type model
    3.       Select * from TYPE_SUMMARY where COLUMN_COUNT > 1000 --- identifies the problem
    4.       SELECT * from expanded_type_summary where type_name = 'Some type withmore than 1000 columns'
              gives you an idea where the columns are coming from
    5.       Annotate the schema to move a chunck out of line
    6.       Try again.
    set echo on
    spool typeAnalysis.log
    DROP TABLE TYPE_SUMMARY
    create global temporary table TYPE_SUMMARY
      TYPE_NAME           VARCHAR2(128),
      OWNER          VARCHAR2(32),
      COLUMN_COUNT             NUMBER
    ON COMMIT PRESERVE ROWS
    grant all on TYPE_SUMMARY to public
    set serveroutput on
    create table TYPE_SUMMARY
      TYPE_NAME           VARCHAR2(128),
      OWNER               VARCHAR2(32),
      COLUMN_COUNT        NUMBER
    create or replace view MISSING_TYPES
    as
    select level TYPE_LEVEL, ata.TYPE_NAME, ata.OWNER, ATTR_NAME, ATTR_TYPE_NAME, ATTR_TYPE_OWNER
      from ALL_TYPES at, ALL_TYPE_ATTRS ata
    where at.TYPE_NAME = ata.TYPE_NAME
       and INHERITED = 'NO'
       and at.OWNER     = ata.OWNER
       and not exists
              select 1
                from TYPE_SUMMARY ts
               where nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
                 and ts.TYPE_NAME = ata.ATTR_TYPE_NAME
           connect by SUPERTYPE_NAME = prior at.TYPE_NAME
                  and SUPERTYPE_OWNER = prior at.OWNER
    create or replace view EXPANDED_TYPE_SUMMARY
    as
    select ata.TYPE_NAME, ata.OWNER, ata.ATTR_NAME, ata.ATTR_TYPE_NAME, ata.ATTR_TYPE_OWNER, ts.COLUMN_COUNT
      from ALL_TYPE_ATTRS ata, TYPE_SUMMARY ts
    where ata.ATTR_TYPE_NAME = ts.TYPE_NAME
       and ata.ATTR_TYPE_OWNER = ts.OWNER
    union all
    select at.SUPERTYPE_NAME TYPE_NAME, at.SUPERTYPE_OWNER OWNER, 'SYS$EXTENSION' ATTR_TYPE_NAME, at.TYPE_NAME ATTR_TYPE_NAME, at.OWNER ATTR_TYPE_OWNER, ts.COLUMN_COUNT
      from ALL_TYPES at, TYPE_SUMMARY ts
    where at.TYPE_NAME = ts.TYPE_NAME
       and at.OWNER = ts.OWNER
    declare
      V_OLD_TYPE_COUNT NUMBER := 0;
      V_NEW_TYPE_COUNT NUMBER := 0;
      cursor getTypeSummary
      is
      select ata.TYPE_NAME, ata.OWNER, sum(COLUMN_COUNT) + 2 as TOTAL_COLUMN_COUNT
       from ALL_TYPE_ATTRS ata, TYPE_SUMMARY ts,
              select distinct TYPE_NAME, OWNER
                from ALL_TYPES at1
               where not exists
                        -- Ensure all my attributes are known
                           select 1
                             from ALL_TYPE_ATTRS ata
                            where not exists
                                        select 1
                                          from TYPE_SUMMARY ts
                                         where ts.TYPE_NAME = ata.ATTR_TYPE_NAME
                                           and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
                              and ata.TYPE_NAME = at1.TYPE_NAME
                              and ata.OWNER = at1.OWNER
                 and not exists
                       select 1
                         from TYPE_SUMMARY ts
                        where at1.TYPE_NAME = ts.TYPE_NAME
                          and at1.OWNER = ts.OWNER
            ) tl
      where ata.TYPE_NAME = tl.TYPE_NAME
        and ata.OWNER = tl.OWNER
        and ts.TYPE_NAME = ata.ATTR_TYPE_NAME
        and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
       group by ata.TYPE_NAME, ata.OWNER;
       cursor getSubTypes(C_TYPE_NAME VARCHAR2, C_OWNER VARCHAR2)
       is
       select TYPE_NAME, OWNER
         from ALL_TYPES at1
        where SUPERTYPE_NAME = C_TYPE_NAME
          and SUPERTYPE_OWNER = C_OWNER;
       cursor getSubTypes(C_TYPE_NAME VARCHAR2, C_OWNER VARCHAR2)
       is
       select ts.TYPE_NAME, ts.OWNER,
         from TYPE_SUMMARY ts,
                select distinct TYPE_NAME, OWNER
                  from ALL_TYPES at1
                 where at1.SUPERTYPE_NAME = C_TYPE_NAME
                   and at1.SUPERTYPE_OWNER = C_OWNER
                   and not exists
                          -- Ensure all my subtypes are known
                                          select 1
                                            from TYPE_SUMMARY ts
                                           where ts.TYPE_NAME = at1.TYPE_NAME
                                             and ts.OWNER = at1.OWNER
                ) tl
          where ts.TYPE_NAME = tl.TYPE_NAME
           and ts.OWNER = tl.OWNER;
      V_COLUMN_COUNT NUMBER;
      V_SUBTYPES_RESOLVED BOOLEAN;           
    begin
      execute immediate 'TRUNCATE TABLE TYPE_SUMMARY';
      insert into TYPE_SUMMARY
      select DISTINCT attr_type_name, ATTR_TYPE_OWNER, 1
        from ALL_TYPE_ATTRS ata
       where not exists
               select TYPE_NAME, OWNER
                      from ALL_TYPES at
                where ata.ATTR_TYPE_NAME = at.TYPE_NAME
                  and ata.ATTR_TYPE_OWNER = at.OWNER
          and not exists
               select syn.SYNONYM_NAME, syn.OWNER
                 from ALL_SYNONYMS syn, ALL_TYPES at
                where syn.TABLE_NAME  = at.TYPE_NAME
                  and syn.TABLE_OWNER = at.OWNER
                  and syn.SYNONYM_NAME = ata.ATTR_TYPE_NAME
                  and syn.OWNER        = ata.ATTR_TYPE_OWNER
      commit;
      insert into TYPE_SUMMARY
      select DISTINCT type_name, owner, 1
        from ALL_TYPES at
       where not exists
               select TYPE_NAME, OWNER
                      from ALL_TYPE_ATTRS ata
                where ata.TYPE_NAME = at.TYPE_NAME
                  and ata.OWNER = at.OWNER
         and not exists
              select COLL_TYPE, OWNER
                from ALL_COLL_TYPES act
               where act.TYPE_NAME = at.TYPE_NAME
                 and nvl(act.OWNER,'SYS') = nvl(at.OWNER,'SYS')
      -- All collection types cost 2 COLUMN_COUNT except for the PD, XMLEXTRA and XMLNAMESPACES
      insert into TYPE_SUMMARY values ('XDB$RAW_LIST_T','XDB',1);
      insert into TYPE_SUMMARY values ('XDB$ENUM_T','XDB',1);
      insert into TYPE_SUMMARY
      select TYPE_NAME, OWNER, 2
        from ALL_COLL_TYPES
       where not (OWNER = 'XDB' and TYPE_NAME = 'XDB$RAW_LIST_T');
      commit;
      select count(*)
        into V_NEW_TYPE_COUNT
        from TYPE_SUMMARY;
      WHILE (V_OLD_TYPE_COUNT <> V_NEW_TYPE_COUNT) loop
        V_OLD_TYPE_COUNT := V_NEW_TYPE_COUNT;
        insert into TYPE_SUMMARY
        select ata.TYPE_NAME, ata.OWNER, sum(COLUMN_COUNT) + 2
          from ALL_TYPE_ATTRS ata, TYPE_SUMMARY ts,
                 select distinct TYPE_NAME, OWNER
                   from ALL_TYPES at1
                  where not exists
                           -- Ensure all my attributes are known
                              select 1
                                from ALL_TYPE_ATTRS ata
                               where not exists
                                           select 1
                                             from TYPE_SUMMARY ts
                                            where ts.TYPE_NAME = ata.ATTR_TYPE_NAME
                                              and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
                                 and ata.TYPE_NAME = at1.TYPE_NAME
                                 and ata.OWNER = at1.OWNER
                    and not exists
                          select 1
                            from TYPE_SUMMARY ts
                           where at1.TYPE_NAME = ts.TYPE_NAME
                             and at1.OWNER = ts.OWNER
                    and not exists
                          select 1
                            from ALL_TYPES at
                           where at.SUPERTYPE_NAME = at1.TYPE_NAME
                             and at.SUPERTYPE_OWNER = at1.OWNER
               ) tl
         where ata.TYPE_NAME = tl.TYPE_NAME
           and ata.OWNER = tl.OWNER
           and ts.TYPE_NAME = ata.ATTR_TYPE_NAME
           and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
          group by ata.TYPE_NAME, ata.OWNER;
        commit; 
        select count(*)
          into V_NEW_TYPE_COUNT
          from TYPE_SUMMARY;
      end loop;
      V_OLD_TYPE_COUNT := 0;
      WHILE (V_OLD_TYPE_COUNT <> V_NEW_TYPE_COUNT) loop
        V_OLD_TYPE_COUNT := V_NEW_TYPE_COUNT;
        for t in getTypeSummary loop
          V_COLUMN_COUNT :=  t.TOTAL_COLUMN_COUNT;
          V_SUBTYPES_RESOLVED := TRUE;
          for st in getSubTypes(T.TYPE_NAME,T.OWNER) loop
            begin
              select V_COLUMN_COUNT + (COLUMN_COUNT - t.TOTAL_COLUMN_COUNT)
                into V_COLUMN_COUNT
                from TYPE_SUMMARY
               where TYPE_NAME = st.TYPE_NAME
                 and OWNER = st.OWNER;
            exception
              when no_data_found then
                V_SUBTYPES_RESOLVED := FALSE;
              when others then
                RAISE;
             end;
          end loop;
          if (V_SUBTYPES_RESOLVED) then
            insert into TYPE_SUMMARY values (t.TYPE_NAME,t.OWNER, V_COLUMN_COUNT);
            dbms_output.put_line('Processing : ' || t.TYPE_NAME || ' COLUMN_COUNT = ' || V_COLUMN_COUNT);
          end if;
        end loop;
        commit;
        insert into TYPE_SUMMARY
        select ata.TYPE_NAME, ata.OWNER, sum(COLUMN_COUNT) + 2
          from ALL_TYPE_ATTRS ata, TYPE_SUMMARY ts,
                 select distinct TYPE_NAME, OWNER
                   from ALL_TYPES at1
                  where not exists
                           -- Ensure all my attributes are known
                              select 1
                                from ALL_TYPE_ATTRS ata
                               where not exists
                                           select 1
                                             from TYPE_SUMMARY ts
                                            where ts.TYPE_NAME = ata.ATTR_TYPE_NAME
                                              and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
                                 and ata.TYPE_NAME = at1.TYPE_NAME
                                 and ata.OWNER = at1.OWNER
                    and not exists
                          select 1
                            from TYPE_SUMMARY ts
                           where at1.TYPE_NAME = ts.TYPE_NAME
                             and at1.OWNER = ts.OWNER
                    and not exists
                          select 1
                            from ALL_TYPES at
                           where at.SUPERTYPE_NAME = at1.TYPE_NAME
                             and at.SUPERTYPE_OWNER = at1.OWNER
               ) tl
         where ata.TYPE_NAME = tl.TYPE_NAME
           and ata.OWNER = tl.OWNER
           and ts.TYPE_NAME = ata.ATTR_TYPE_NAME
           and nvl(ts.OWNER,'SYS') = nvl(ata.ATTR_TYPE_OWNER,'SYS')
          group by ata.TYPE_NAME, ata.OWNER;
        commit;
        select count(*)
          into V_NEW_TYPE_COUNT
          from TYPE_SUMMARY;
      end loop;
    end;
    set pages 0 lines 256
    column TYPE_NAME FORMAT A30
    column OWNER FORMAT A30
    select count(*)
      from TYPE_SUMMARY
    select *
      from TYPE_SUMMARY
    where  owner=user
    order by COLUMN_COUNT
    select type_name, owner
      from ALL_TYPES at
    where not exists
              selec

  • ORA 01792 maximum number of columns in a table or view is 1000

    Hello every1, I wish to register a large xmlschema doc, I am using the command
    begin
    dbms_xmlschema.registerschema(
    schemaurl=>'xxxx',
    schemadoc=>bfilename('XMLDIR','xxxxxx.xsd'),
    csid=>nls_charset_id('AL32UTF8'));
    end;
    But the schema file exists 1000 col and it gives me the error msg of
    ORA-01792: maximum number of columns in a table or view is 1000
    is there anyway to solve the problems without edit the original schema document?
    Thanks for your help

    First create this package
    create or replace package XDB_ANALYZE_XMLSCHEMA_10200
    authid CURRENT_USER
    as
      function analyzeStorageModel(P_COMPLEX_TYPE_NAME VARCHAR2) return XMLTYPE;
      function analyzeComplexType(COMPLEX_TYPE VARCHAR2) return XMLTYPE;
      procedure renameCollectionTable (XMLTABLE varchar2, XPATH varchar2, COLLECTION_TABLE_PREFIX varchar2);
      function printNestedTables(XML_TABLE varchar2) return XMLType;
      function getComplexTypeElementList(P_SQLTYPE VARCHAR2, P_SQLSCHEMA VARCHAR2) return XDB.XDB$XMLTYPE_REF_LIST_T;
      procedure scopeXMLReferences;
      procedure indexXMLReferences(INDEX_NAME VARCHAR2);
      function generateSchemaFromTable(P_TABLE_NAME varchar2, P_OWNER varchar2 default USER) return XMLTYPE;
      function showSQLTypes(schemaFolder varchar2) return XMLType;
      function generateCreateTableStatement(XML_TABLE_NAME varchar2, NEW_TABLE_NAME varchar2) return CLOB;
    end XDB_ANALYZE_XMLSCHEMA_10200;
    show errors
    create or replace package body XDB_ANALYZE_XMLSCHEMA_10200
    as
    G_DEPTH_COUNT NUMBER(2) := 0;
    TYPE BASETYPE_T is RECORD  
      SUBTYPE               varchar2(128),
      SUBTYPE_OWNER         varchar2(32),
      BASETYPE              varchar2(128),
      BASETYPE_OWNER        varchar2(32)
    TYPE BASETYPE_LIST_T IS TABLE OF BASETYPE_T;
    BASETYPE_LIST            BASETYPE_LIST_T := BASETYPE_LIST_T();
    function findStorageModel(P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2,  P_INCLUDE_SUBTYPES VARCHAR2 DEFAULT 'YES') return XMLType;
    function getLocalAttributes(P_TYPE_NAME varchar2, P_TYPE_OWNER VARCHAR2) return XMLType;
    function makeElement(P_NAME varchar2)
    return xmltype
    as
      V_NAME varchar2(4000) := P_NAME;
    begin
      -- -- dbms_output.put_line('Processing : ' || P_NAME);
      if (P_NAME LIKE '%$') then
        V_NAME := SUBSTR(V_NAME,1,LENGTH(V_NAME) - 1);
      end if;
      if (P_NAME LIKE '%$%') then
        V_NAME := REPLACE(V_NAME,'$','_0x22_');
      end if;
      return XMLTYPE( '<' || V_NAME || '/>');
    end;
    function getPathToRoot(SUBTYPE VARCHAR2, SUBTYPE_OWNER VARCHAR2)
    return varchar2
    as
      TYPE_HIERARCHY varchar2(4000);
    begin
       SELECT sys_connect_by_path( OWNER || '.' || TYPE_NAME , '/')
         INTO TYPE_HIERARCHY
         FROM ALL_TYPES
        WHERE TYPE_NAME = SUBTYPE
          AND OWNER = SUBTYPE_OWNER
              CONNECT BY SUPERTYPE_NAME = PRIOR TYPE_NAME
                     AND SUPERTYPE_OWNER = PRIOR OWNER
              START WITH SUPERTYPE_NAME IS NULL
                     AND SUPERTYPE_OWNER IS NULL;
       return TYPE_HIERARCHY;
    end;
    function expandSQLType(ATTR_NAME VARCHAR2, SUBTYPE VARCHAR2, SUBTYPE_OWNER VARCHAR2)
    return XMLType
    as
      STORAGE_MODEL       XMLTYPE;
      ATTRIBUTES          XMLTYPE;
      EXTENDED_TYPE       XMLTYPE;
      ATTR_COUNT          NUMBER := 0;
      CURSOR FIND_EXTENDED_TYPES
      is
      select TYPE_NAME, OWNER
        from ALL_TYPES
       where SUPERTYPE_NAME  = SUBTYPE
         and SUPERTYPE_OWNER = SUBTYPE_OWNER;
    begin
      -- dbms_output.put_line('Processing SQLType  : "' || SUBTYPE_OWNER || '.' || SUBTYPE || '".' );
      STORAGE_MODEL := makeElement(ATTR_NAME);
      select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@type',SUBTYPE)
        into STORAGE_MODEL
        from dual;
      select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@typeOwner',SUBTYPE_OWNER)
        into STORAGE_MODEL
        from dual;
      ATTRIBUTES := getLocalAttributes(SUBTYPE, SUBTYPE_OWNER);         
      ATTR_COUNT := ATTR_COUNT + ATTRIBUTES.extract('/' || ATTRIBUTES.getRootElement() || '/@columns').getNumberVal();
      select appendChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),ATTRIBUTES)
        into STORAGE_MODEL        
        from DUAL;
      for t in FIND_EXTENDED_TYPES loop
         EXTENDED_TYPE := expandSQLType('ExtendedType',T.TYPE_NAME,T.OWNER);
         ATTR_COUNT := ATTR_COUNT + EXTENDED_TYPE.extract('/' || EXTENDED_TYPE.getRootElement() || '/@columns').getNumberVal();
         select appendChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),EXTENDED_TYPE)
           into STORAGE_MODEL
           from DUAL;   
      end loop;
      select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@columns',ATTR_COUNT)
        into STORAGE_MODEL
        from dual;
      return STORAGE_MODEL;
    end;
    function getLocalAttributes(P_TYPE_NAME varchar2, P_TYPE_OWNER VARCHAR2)
    return XMLType
    as
      V_ATTRIBUTE_COUNT     NUMBER := 0;
      V_TOTAL_ATTRIBUTES    NUMBER := 0;
      V_TEMP_RESULT         NUMBER;
      V_COLLECTION_TYPE     varchar2(32);
      V_COLLECTION_OWNER    varchar2(32);
      CURSOR FIND_CHILD_ATTRS
      is
      select ATTR_NAME, ATTR_TYPE_OWNER, ATTR_TYPE_NAME, INHERITED
        from ALL_TYPE_ATTRS
       where TYPE_NAME = P_TYPE_NAME
         and OWNER = P_TYPE_OWNER
         and INHERITED = 'NO'
       order by ATTR_NO;       
      V_ATTR                    DBMS_XMLDOM.DOMATTR;
      V_ATTRIBUTE_LIST      XMLTYPE;
      V_ATTRIBUTE_LIST_DOCUMENT DBMS_XMLDOM.DOMDOCUMENT;
      V_ATTRIBUTE_LIST_ROOT     DBMS_XMLDOM.DOMELEMENT;
      V_ATTRIBUTE           XMLTYPE;
      V_ATTRIBUTE_DOCUMENT                DBMS_XMLDOM.DOMDOCUMENT;
      V_ATTRIBUTE_ROOT                    DBMS_XMLDOM.DOMELEMENT;
      V_TYPE_DEFINITION     XMLTYPE;
      V_TYPE_DEFINITION_DOCUMENT  DBMS_XMLDOM.DOMDOCUMENT;
      V_TYPE_DEFINITION_ROOT      DBMS_XMLDOM.DOMELEMENT;
    begin    
      V_ATTRIBUTE_LIST          := makeElement('Attributes');
      V_ATTRIBUTE_LIST_DOCUMENT := DBMS_XMLDOM.NEWDOMDOCUMENT(V_ATTRIBUTE_LIST);
      V_ATTRIBUTE_LIST_ROOT     := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_ATTRIBUTE_LIST_DOCUMENT);
      for ATTR in FIND_CHILD_ATTRS loop
        -- Finding Element / Attribute Name could be tricky. Use SQLName
        V_ATTRIBUTE          := makeElement(ATTR.ATTR_NAME);
        V_ATTRIBUTE_DOCUMENT := DBMS_XMLDOM.NEWDOMDOCUMENT(V_ATTRIBUTE);
        V_ATTRIBUTE_ROOT     := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_ATTRIBUTE_DOCUMENT);
        begin
          -- Check for Attributes based on collection types, With Nested Table storage each Collection will cost 2 columns.
          select ELEM_TYPE_NAME, ELEM_TYPE_OWNER
            into V_COLLECTION_TYPE, V_COLLECTION_OWNER
            from ALL_COLL_TYPES
           where TYPE_NAME = ATTR.ATTR_TYPE_NAME
             and OWNER = ATTR.ATTR_TYPE_OWNER;
          -- -- dbms_output.put_line('Adding "' || ATTR.ATTR_NAME || '". Collection of "' || ATTR.ATTR_TYPE_OWNER || '"."' || ATTR.ATTR_TYPE_NAME || '".');
          -- Attribute is a Collection Type.
          -- Collection will be managed as a NESTED TABLE
          -- Each Collection cost 2 columns.
          -- May want to count the number of columns in the NESTED_TABLE at a later date.
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLCollType');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,ATTR.ATTR_TYPE_NAME);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLCollTypeOwner');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,ATTR.ATTR_TYPE_OWNER);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLType');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,V_COLLECTION_TYPE);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLTypeOwner');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,V_COLLECTION_OWNER);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'columns');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,2);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
        exception
          when no_data_found then
            -- Attribute is not a collection type.
            begin
              -- Check for Attributes based on non-scalar types.
              select 1
                into V_TEMP_RESULT
                from ALL_TYPES
               where TYPE_NAME = ATTR.ATTR_TYPE_NAME
                 and OWNER = ATTR.ATTR_TYPE_OWNER;
              -- Attribute is based on a non-scalar type. Find the Storage Model for this type.
              V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLType');
                             DBMS_XMLDOM.SETVALUE(V_ATTR,ATTR.ATTR_TYPE_NAME);
              V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
              V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLTypeOwner');
                             DBMS_XMLDOM.SETVALUE(V_ATTR,ATTR.ATTR_TYPE_OWNER);
              V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
              V_TYPE_DEFINITION            := findStorageModel(ATTR.ATTR_TYPE_NAME, ATTR.ATTR_TYPE_OWNER, 'YES');   
              V_TYPE_DEFINITION_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_TYPE_DEFINITION);
              V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_TYPE_DEFINITION_DOCUMENT);
              V_ATTRIBUTE_COUNT            := DBMS_XMLDOM.GETATTRIBUTE(V_TYPE_DEFINITION_ROOT,'columns');
              V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_ATTRIBUTE_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT),TRUE));
              V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_ROOT),DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT)));
              DBMS_XMLDOM.FREEDOCUMENT(V_TYPE_DEFINITION_DOCUMENT);
              if (ATTR.ATTR_TYPE_NAME = 'XDB$ENUM_T' and ATTR.ATTR_TYPE_OWNER = 'XDB') then
                -- The cost of a XDB$ENUM_T is 2 columns
                V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'columns');
                               DBMS_XMLDOM.SETVALUE(V_ATTR,2);
                V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
              else
                -- The cost of a non scalar Type is the number of attributes plus one for Type and one for the TYPEID.
                V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'columns');
                               DBMS_XMLDOM.SETVALUE(V_ATTR,V_ATTRIBUTE_COUNT + 2);
                V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
              end if;
            exception
              when no_data_found then
                 -- Attribute is based on a scalar type
                 V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'SQLType');
                                DBMS_XMLDOM.SETVALUE(V_ATTR,ATTR.ATTR_TYPE_NAME);
                 V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
                 V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_DOCUMENT,'columns');
                                DBMS_XMLDOM.SETVALUE(V_ATTR,1);
                 V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_ROOT,V_ATTR);
            end;
        end;
        V_TOTAL_ATTRIBUTES     := V_TOTAL_ATTRIBUTES + DBMS_XMLDOM.GETATTRIBUTE(V_ATTRIBUTE_ROOT,'columns');
        V_ATTRIBUTE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_ATTRIBUTE_LIST_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_ROOT),TRUE));
        V_ATTRIBUTE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_LIST_ROOT),DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_ROOT)));
        DBMS_XMLDOM.FREEDOCUMENT(V_ATTRIBUTE_DOCUMENT);
        if (V_TOTAL_ATTRIBUTES > 25000) then
          exit;
        end if;
      end loop;
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_ATTRIBUTE_LIST_DOCUMENT,'columns');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,V_TOTAL_ATTRIBUTES);
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ATTRIBUTE_LIST_ROOT,V_ATTR);
      return V_ATTRIBUTE_LIST;
    end;
    function getSubTypes(P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2)
    return XMLType
    as
      CURSOR FIND_SUBTYPES
      is
      select TYPE_NAME, OWNER
        from ALL_TYPES
       where SUPERTYPE_NAME  = P_TYPE_NAME
         and SUPERTYPE_OWNER = P_TYPE_OWNER; 
      CURSOR FIND_SUBTYPE_HEIRARCHY
      is
      select LEVEL, TYPE_NAME, OWNER
        from ALL_TYPES
       where TYPE_NAME <> P_TYPE_NAME
         and OWNER <> P_TYPE_OWNER
             connect by SUPERTYPE_NAME = PRIOR TYPE_NAME
                    and SUPERTYPE_OWNER = PRIOR OWNER
             start with TYPE_NAME = P_TYPE_NAME
                    and OWNER = P_TYPE_OWNER;
      V_SUBTYPE_LIST                 XMLType;
      V_SUBTYPE_LIST_DOCUMENT        DBMS_XMLDOM.DOMDOCUMENT;
      V_SUBTYPE_LIST_ROOT            DBMS_XMLDOM.DOMELEMENT;
      V_TYPE_DEFINITION              XMLType;
      V_TYPE_DEFINITION_DOCUMENT     DBMS_XMLDOM.DOMDOCUMENT;
      V_TYPE_DEFINITION_ROOT         DBMS_XMLDOM.DOMELEMENT;
      V_SUBTYPE_DEFINITIONS          XMLType;
      V_SUBTYPE_DEFINITIONS_DOCUMENT DBMS_XMLDOM.DOMDOCUMENT;
      V_SUBTYPE_DEFINITIONS_ROOT     DBMS_XMLDOM.DOMELEMENT;
      V_ATTRIBUTE_LIST               XMLType;
      V_ATTRIBUTE_LIST_DOCUMENT      DBMS_XMLDOM.DOMDOCUMENT;
      V_ATTRIBUTE_LIST_ROOT          DBMS_XMLDOM.DOMELEMENT;
      V_SUBTYPES_EXIST               BOOLEAN := FALSE;
      V_TOTAL_columns                number;
      V_ATTRIBUTE_COUNT              number;
      V_ATTR                         DBMS_XMLDOM.DOMATTR;
      V_COMPLEX_TYPE                 VARCHAR2(256);
    begin
      V_SUBTYPE_LIST          := makeElement('SubTypeDefinitions');
      V_SUBTYPE_LIST_DOCUMENT := DBMS_XMLDOM.NEWDOMDOCUMENT(V_SUBTYPE_LIST);
      V_SUBTYPE_LIST_ROOT     := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_SUBTYPE_LIST_DOCUMENT);
      V_TOTAL_columns := 0;
      for t in FIND_SUBTYPES() loop
        V_SUBTYPES_EXIST  := TRUE;
        V_TYPE_DEFINITION            := makeElement(t.TYPE_NAME);
        V_TYPE_DEFINITION_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_TYPE_DEFINITION);
        V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_TYPE_DEFINITION_DOCUMENT);
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_TYPE_DEFINITION_DOCUMENT,'SQLTypeOwner');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,t.OWNER);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_TYPE_DEFINITION_ROOT,V_ATTR);
        begin
          select x.XMLDATA.NAME
            into V_COMPLEX_TYPE
            from XDB.XDB$COMPLEX_TYPE x
           where x.XMLDATA.SQLTYPE = t.TYPE_NAME
             and x.XMLDATA.SQLSCHEMA = t.OWNER;
          V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_TYPE_DEFINITION_DOCUMENT,'type');
                         DBMS_XMLDOM.SETVALUE(V_ATTR,V_COMPLEX_TYPE);
          V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_TYPE_DEFINITION_ROOT,V_ATTR);
          -- Consider adding Schema URL Attribute
        exception
          when no_data_found then
            null;
          when others then
            raise;
        end;
        V_ATTRIBUTE_LIST            := getLocalAttributes(t.TYPE_NAME, t.OWNER);  
        V_ATTRIBUTE_LIST_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_ATTRIBUTE_LIST);
        V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_ATTRIBUTE_LIST_DOCUMENT);
        V_ATTRIBUTE_COUNT           := DBMS_XMLDOM.GETATTRIBUTE(V_ATTRIBUTE_LIST_ROOT,'columns');
        V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_TYPE_DEFINITION_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_LIST_ROOT),TRUE));
        V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT),DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_LIST_ROOT)));
        DBMS_XMLDOM.FREEDOCUMENT(V_ATTRIBUTE_LIST_DOCUMENT);
        V_SUBTYPE_DEFINITIONS       := getSubTypes(t.TYPE_NAME,t.OWNER);
        if (V_SUBTYPE_DEFINITIONS is not NULL) then
          V_SUBTYPE_DEFINITIONS_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_SUBTYPE_DEFINITIONS);
          V_SUBTYPE_DEFINITIONS_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_SUBTYPE_DEFINITIONS_DOCUMENT);
          V_ATTRIBUTE_COUNT                := V_ATTRIBUTE_COUNT + DBMS_XMLDOM.GETATTRIBUTE(V_SUBTYPE_DEFINITIONS_ROOT,'columns');
          V_SUBTYPE_DEFINITIONS_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_TYPE_DEFINITION_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_SUBTYPE_DEFINITIONS_ROOT),TRUE));
          V_SUBTYPE_DEFINITIONS_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT),DBMS_XMLDOM.MAKENODE(V_SUBTYPE_DEFINITIONS_ROOT)));
        end if;
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_TYPE_DEFINITION_DOCUMENT,'columns');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,V_ATTRIBUTE_COUNT);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_TYPE_DEFINITION_ROOT,V_ATTR);
        V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_SUBTYPE_LIST_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT),TRUE));
        V_TYPE_DEFINITION_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_SUBTYPE_LIST_ROOT),DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION_ROOT)));
        V_TOTAL_columns := V_TOTAL_columns + V_ATTRIBUTE_COUNT;
      end loop;
      if (V_SUBTYPES_EXIST) then
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_SUBTYPE_LIST_DOCUMENT,'columns');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,V_TOTAL_columns);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_SUBTYPE_LIST_ROOT,V_ATTR);
        return V_SUBTYPE_LIST;
      else
        return NULL;
      end if;
    end;
    function findSuperTypeModel(P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2)
    return XMLType
    as
    begin
      -- dbms_output.put_line('Processing Super Type : "' || P_TYPE_OWNER || '"."' || P_TYPE_NAME || '"');
      return findStorageModel(P_TYPE_NAME, P_TYPE_OWNER,'NO');
    end;
    function getStorageModel(P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2, P_INCLUDE_SUBTYPES VARCHAR2 DEFAULT 'YES')
    return XMLType
    as
      V_TYPE_DEFINITION      XMLTYPE;
      V_ATTRIBUTE_COUNT      NUMBER := 0;
      SUBTYPE_STORAGE_MODEL  XMLTYPE;
      V_SUPERTYPE_DEFINITION XMLTYPE;
      V_SUPERTYPE_DOCUMENT   DBMS_XMLDOM.DOMDOCUMENT;
      V_SUPERTYPE_ROOT       DBMS_XMLDOM.DOMELEMENT;
      V_SUBTYPE_DEFINITION XMLTYPE;
      V_SUBTYPE_DOCUMENT   DBMS_XMLDOM.DOMDOCUMENT;
      V_SUBTYPE_ROOT       DBMS_XMLDOM.DOMELEMENT;
      V_ATTRIBUTE_LIST          XMLTYPE;
      V_ATTRIBUTE_LIST_DOCUMENT DBMS_XMLDOM.DOMDOCUMENT;
      V_ATTRIBUTE_LIST_ROOT     DBMS_XMLDOM.DOMELEMENT;
      cursor FIND_SUPERTYPE_HEIRARCHY
      is
      select TYPE_NAME, OWNER
        from ALL_TYPES
       where TYPE_NAME <> P_TYPE_NAME
         and OWNER <> P_TYPE_OWNER
             connect by TYPE_NAME = PRIOR SUPERTYPE_NAME
                    and OWNER = PRIOR SUPERTYPE_OWNER
             start with TYPE_NAME = P_TYPE_NAME
                    and OWNER = P_TYPE_OWNER
       order by LEVEL;
      V_COMPLEX_TYPE        varchar2(256);
      V_SUPERTYPE_NAME      varchar2(256);
      v_SUPERTYPE_OWNER     varchar2(256);
      V_DOCUMENT            DBMS_XMLDOM.DOMDOCUMENT;
      V_ROOT                DBMS_XMLDOM.DOMELEMENT;
      V_ATTR                DBMS_XMLDOM.DOMATTR;
    begin
      -- dbms_output.put_line('Generating Storage Model for : "' || P_TYPE_OWNER || '"."' || P_TYPE_NAME || '"');
      V_TYPE_DEFINITION := makeElement(P_TYPE_NAME);
      V_DOCUMENT  := DBMS_XMLDOM.NEWDOMDOCUMENT(V_TYPE_DEFINITION);
      V_ROOT      := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_DOCUMENT);
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'SQLTypeOwner');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,P_TYPE_OWNER);
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
      begin
        select x.XMLDATA.NAME
          into V_COMPLEX_TYPE
          from XDB.XDB$COMPLEX_TYPE x
         where x.XMLDATA.SQLTYPE = P_TYPE_NAME
           and x.XMLDATA.SQLSCHEMA = P_TYPE_OWNER;
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'type');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,V_COMPLEX_TYPE);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
        -- Consider adding Schema URL Attribute
      exception
        when no_data_found then
          null;
        when others then
          raise;
      end;
      select SUPERTYPE_NAME, SUPERTYPE_OWNER
        into V_SUPERTYPE_NAME, V_SUPERTYPE_OWNER
        from ALL_TYPES
       where TYPE_NAME = P_TYPE_NAME
         and OWNER = P_TYPE_OWNER;
      -- Process SuperType. 
      if (V_SUPERTYPE_NAME is not null) then
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'SQLParentType');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,V_SUPERTYPE_NAME);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
        V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'SQLParentTypeOwner');
                       DBMS_XMLDOM.SETVALUE(V_ATTR,V_SUPERTYPE_OWNER);
        V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
        -- Find the Definition for the super type. Do not include the definition of it's subtypes.
        V_SUPERTYPE_DEFINITION := findSuperTypeModel(V_SUPERTYPE_NAME, V_SUPERTYPE_OWNER);
        -- -- dbms_output.put_line(dbms_lob.substr(V_SUPERTYPE_DEFINITION.getClobVal(),1000,1));
        V_SUPERTYPE_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_SUPERTYPE_DEFINITION);
        V_SUPERTYPE_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_SUPERTYPE_DOCUMENT);
        V_ATTRIBUTE_COUNT      := V_ATTRIBUTE_COUNT + DBMS_XMLDOM.GETATTRIBUTE(V_SUPERTYPE_ROOT,'columns');
        V_SUPERTYPE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_SUPERTYPE_ROOT),TRUE));
        V_SUPERTYPE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ROOT),DBMS_XMLDOM.MAKENODE(V_SUPERTYPE_ROOT)));
        DBMS_XMLDOM.FREEDOCUMENT(V_SUPERTYPE_DOCUMENT);
      end if;
      -- Process Attributes defined directly by the Type.
      V_ATTRIBUTE_LIST            := getLocalAttributes(P_TYPE_NAME, P_TYPE_OWNER);  
      V_ATTRIBUTE_LIST_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_ATTRIBUTE_LIST);
      V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_ATTRIBUTE_LIST_DOCUMENT);
      V_ATTRIBUTE_COUNT           := V_ATTRIBUTE_COUNT + DBMS_XMLDOM.GETATTRIBUTE(V_ATTRIBUTE_LIST_ROOT,'columns');
      V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_LIST_ROOT),TRUE));
      V_ATTRIBUTE_LIST_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ROOT),DBMS_XMLDOM.MAKENODE(V_ATTRIBUTE_LIST_ROOT)));
      DBMS_XMLDOM.FREEDOCUMENT(V_ATTRIBUTE_LIST_DOCUMENT);
      if (P_INCLUDE_SUBTYPES = 'YES') then
        -- Process any Sub-Types...
        V_SUBTYPE_DEFINITION := getSubTypes(P_TYPE_NAME, P_TYPE_OWNER);
        if (V_SUBTYPE_DEFINITION is not null) then
          V_SUBTYPE_DOCUMENT   := DBMS_XMLDOM.NEWDOMDOCUMENT(V_SUBTYPE_DEFINITION);
          V_SUBTYPE_ROOT       := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_SUBTYPE_DOCUMENT);
          V_ATTRIBUTE_COUNT    := V_ATTRIBUTE_COUNT + DBMS_XMLDOM.GETATTRIBUTE(V_SUBTYPE_ROOT,'columns');
          V_SUBTYPE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_SUBTYPE_ROOT),TRUE));
          V_SUBTYPE_ROOT       := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ROOT),DBMS_XMLDOM.MAKENODE(V_SUBTYPE_ROOT)));   
          DBMS_XMLDOM.FREEDOCUMENT(V_SUBTYPE_DOCUMENT);
        end if;
      end if;
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'columns');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,V_ATTRIBUTE_COUNT);
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
      -- Cache the type definition.
      -- dbms_output.put_line('Cached Storage Model for "' || P_TYPE_OWNER || '.' || P_TYPE_NAME || '".');
      insert into XDBPM.XDBPM_STORAGE_MODEL_CACHE (TYPE_NAME, TYPE_OWNER, EXTENDED_DEFINITION, STORAGE_MODEL) VALUES (P_TYPE_NAME, P_TYPE_OWNER, P_INCLUDE_SUBTYPES, V_TYPE_DEFINITION);
      return V_TYPE_DEFINITION;
    end;
    function findStorageModel(P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2, P_INCLUDE_SUBTYPES VARCHAR2 DEFAULT 'YES')
    -- Find the Storage Model for the Base Type.
    -- If the type is derived from another type we need the storage model of the Base Type
    -- As storage models are calculated they are cached in the global temporary table XDBPM_STORAGE_MODEL_CACHE. This makes
    -- the process much more efficient. A global temporary table is used to minimize memory usage.
    return XMLType
    as
      V_STORAGE_MODEL          XMLType;
      V_STORAGE_MODEL_DOCUMENT DBMS_XMLDOM.DOMDOCUMENT;
      V_STORAGE_MODEL_ROOT     DBMS_XMLDOM.DOMELEMENT;
      V_ATTRIBUTE_COUNT        VARCHAR2(10);
    begin
      dbms_output.put_line('findStorageModel(' || G_DEPTH_COUNT || ') : Processing "' || P_TYPE_OWNER || '"."' || P_TYPE_NAME || '".' );
      begin
        SELECT STORAGE_MODEL
          into V_STORAGE_MODEL
          from XDBPM.XDBPM_STORAGE_MODEL_CACHE
         where TYPE_NAME = P_TYPE_NAME
           and TYPE_OWNER = P_TYPE_OWNER
           and EXTENDED_DEFINITION = P_INCLUDE_SUBTYPES;
         -- dbms_output.put_line('Resolved Storage Model from cache.');
      exception
        when no_data_found then
          G_DEPTH_COUNT := G_DEPTH_COUNT + 1;
          V_STORAGE_MODEL := getStorageModel(P_TYPE_NAME,P_TYPE_OWNER, P_INCLUDE_SUBTYPES);
          G_DEPTH_COUNT := G_DEPTH_COUNT - 1; 
        when others then
          raise;
      end;
      V_STORAGE_MODEL_DOCUMENT := DBMS_XMLDOM.NEWDOMDOCUMENT(V_STORAGE_MODEL);
      V_STORAGE_MODEL_ROOT     := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_STORAGE_MODEL_DOCUMENT);
      V_ATTRIBUTE_COUNT          := DBMS_XMLDOM.GETATTRIBUTE(V_STORAGE_MODEL_ROOT,'columns');
      dbms_output.put_line('findStorageModel : Attribute Count for "' || P_TYPE_OWNER || '"."' || P_TYPE_NAME || '" = ' || V_ATTRIBUTE_COUNT || '.' );
      return V_STORAGE_MODEL;
    end;
    function analyzeStorageModel(P_COMPLEX_TYPE_NAME VARCHAR2, P_TYPE_NAME VARCHAR2, P_TYPE_OWNER VARCHAR2)
    -- Generate a map showing the number of columns required to persist an instance of the SQL type.
    return XMLType
    as
      V_STORAGE_MODEL       XMLTYPE;
      V_COUNT               NUMBER := 0;
      V_DOCUMENT            DBMS_XMLDOM.DOMDOCUMENT;
      V_ROOT                DBMS_XMLDOM.DOMELEMENT;
      V_ATTR                DBMS_XMLDOM.DOMATTR;
      V_MODEL               DBMS_XMLDOM.DOMELEMENT;
      V_TYPE_DEFINITION     DBMS_XMLDOM.DOMELEMENT;
    begin
      V_STORAGE_MODEL := makeElement(P_COMPLEX_TYPE_NAME);
      V_DOCUMENT  := DBMS_XMLDOM.NEWDOMDOCUMENT(V_STORAGE_MODEL);
      V_ROOT      := DBMS_XMLDOM.GETDOCUMENTELEMENT(V_DOCUMENT);
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'SQLType');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,P_TYPE_NAME);
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'SQLTypeOwner');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,P_TYPE_OWNER);
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
      V_TYPE_DEFINITION   := DBMS_XMLDOM.GETDOCUMENTELEMENT(DBMS_XMLDOM.NEWDOMDOCUMENT(findStorageModel(P_TYPE_NAME, P_TYPE_OWNER, 'YES')));
      V_TYPE_DEFINITION   := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.IMPORTNODE(V_DOCUMENT,DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION),TRUE));
      V_TYPE_DEFINITION   := DBMS_XMLDOM.MAKEELEMENT(DBMS_XMLDOM.APPENDCHILD(DBMS_XMLDOM.MAKENODE(V_ROOT),DBMS_XMLDOM.MAKENODE(V_TYPE_DEFINITION)));
      V_ATTR      := DBMS_XMLDOM.CREATEATTRIBUTE(V_DOCUMENT,'columns');
                     DBMS_XMLDOM.SETVALUE(V_ATTR,DBMS_XMLDOM.GETATTRIBUTE(V_TYPE_DEFINITION,'columns'));
      V_ATTR      := DBMS_XMLDOM.SETATTRIBUTENODE(V_ROOT,V_ATTR);
      return  V_STORAGE_MODEL;
    end;
    function analyzeStorageModel(P_COMPLEX_TYPE_NAME VARCHAR2)
    return XMLTYPE
    -- Generate a map showing the number of columns required to persist an instance of the complex type.
    as
      pragma autonomous_transaction;
      V_SQLTYPE           VARCHAR2(128);
      V_SQLSCHEMA         VARCHAR2(32);
      V_RESULT            XMLType;
    begin
    G_DEPTH_COUNT := 0;
    select ct.XMLDATA.SQLTYPE, ct.XMLDATA.SQLSCHEMA
        into V_SQLTYPE, V_SQLSCHEMA
        from XDB.XDB$COMPLEX_TYPE ct, XDB.XDB$SCHEMA s
       where ct.XMLDATA.NAME = P_COMPLEX_TYPE_NAME
         and ref(s) = ct.XMLDATA.PARENT_SCHEMA
         and s.XMLDATA.SCHEMA_OWNER = USER;
      delete from XDBPM.XDBPM_STORAGE_MODEL_CACHE;
      -- delete from XDBPM.XDBPM_STORAGE_MODEL;
      V_RESULT := analyzeStorageModel(P_COMPLEX_TYPE_NAME,V_SQLTYPE,V_SQLSCHEMA);
      COMMIT;
      return V_RESULT;
    exception
      when no_data_found then
        -- dbms_output.put_line('Unable to find SQLType mapping for complexType : "' || USER || '"."' || P_COMPLEX_TYPE_NAME || '".' );
        return null;
      when others then
        raise;
    end;
    function analyzeSQLType(ATTR_NAME VARCHAR2, TARGET_TYPE_NAME VARCHAR2, TARGET_TYPE_OWNER VARCHAR2)
    return XMLType
    as
       ROOT_NODE_NAME   VARCHAR2(128);
       ATTR_DETAIL      XMLTYPE;
       XPATH_EXPRESSION VARCHAR2(129);
       CURSOR FIND_CHILD_ATTRS is
         select ATTR_NAME, ATTR_TYPE_OWNER, ATTR_TYPE_NAME, INHERITED
           from ALL_TYPE_ATTRS
          where OWNER = TARGET_TYPE_OWNER
            and TYPE_NAME = TARGET_TYPE_NAME
          order by ATTR_NO;       
       CHILD_ATTR  XMLTYPE;
       ATTR_COUNT NUMBER := 0;
       TEMP number;
       COLLECTION_TYPE_NAME  varchar2(256);
       COLLECTION_TYPE_OWNER varchar2(256);
    begin
      -- -- dbms_output.put_line('Processing Attribute ' || ATTR_NAME || ' of ' || TARGET_TYPE_OWNER || '.' || TARGET_TYPE_NAME );
      ATTR_DETAIL := makeElement(ATTR_NAME);
      XPATH_EXPRESSION := '/' || ATTR_DETAIL.GETROOTELEMENT();
      for ATTR in FIND_CHILD_ATTRS loop
        begin
          select ELEM_TYPE_NAME, ELEM_TYPE_OWNER
            into COLLECTION_TYPE_NAME, COLLECTION_TYPE_OWNER
            from ALL_COLL_TYPES
           where TYPE_NAME = ATTR.ATTR_TYPE_NAME
             and OWNER = ATTR.ATTR_TYPE_OWNER;
          CHILD_ATTR := analyzeSQLType(ATTR.ATTR_NAME, COLLECTION_TYPE_NAME, COLLECTION_TYPE_OWNER );
          ATTR_COUNT := ATTR_COUNT + CHILD_ATTR.extract('/' || CHILD_ATTR.GETROOTELEMENT()  || '/@sqlAttrs').getNumberVal();
          select appendChildXML(ATTR_DETAIL,XPATH_EXPRESSION,CHILD_ATTR)
            into ATTR_DETAIL
            from DUAL;
        exception
          when no_data_found then
            begin
              select 1
                into TEMP
                from ALL_TYPES
               where TYPE_NAME = ATTR.ATTR_TYPE_NAME
                and OWNER = ATTR.ATTR_TYPE_OWNER;
              CHILD_ATTR := analyzeSQLType(ATTR.ATTR_NAME, ATTR.ATTR_TYPE_NAME, ATTR.ATTR_TYPE_OWNER );
              ATTR_COUNT := ATTR_COUNT + CHILD_ATTR.extract('/' || CHILD_ATTR.GETROOTELEMENT() || '/@sqlAttrs').getNumberVal();
              select appendChildXML(ATTR_DETAIL,XPATH_EXPRESSION,CHILD_ATTR)
                into ATTR_DETAIL
                from DUAL;
            exception
             when no_data_found then
               ATTR_COUNT := ATTR_COUNT + 1;
            end;
        end;
      end loop;
      select insertChildXML(ATTR_DETAIL,XPATH_EXPRESSION,'@sqlAttrs',ATTR_COUNT)
        into ATTR_DETAIL
        from dual;
      return ATTR_DETAIL;
    end;
    function analyzeComplexType(COMPLEX_TYPE VARCHAR2)
    return XMLType
    as
      RESULT           xmltype;
      SQLTYPE          varchar2(128);
      SQLTYPE_OWNER    varchar2(32);
    begin
      select SQLTYPE, SQLTYPE_OWNER
        into SQLTYPE, SQLTYPE_OWNER
        from USER_XML_SCHEMAS,
             xmlTable
                xmlnamespaces
                  'http://www.w3.org/2001/XMLSchema' as "xsd",
                  'http://xmlns.oracle.com/xdb' as "xdb"
                '/xsd:schema/xsd:complexType'
                passing Schema
                columns
                COMPLEX_TYPE_NAME varchar2(4000) path '@name',
                SQLTYPE           varchar2(128)  path '@xdb:SQLType',
                SQLTYPE_OWNER     varchar2(32)   path '@xdb:SQLSchema'
       where COMPLEX_TYPE_NAME = COMPLEX_TYPE;
      result := analyzeSQLType(COMPLEX_TYPE,SQLTYPE,SQLTYPE_OWNER);
      select insertChildXML(RESULT,'/' || COMPLEX_TYPE,'@SQLType',SQLTYPE)
        into result
        from dual;
      return result;
    end;
    function showSQLTypes(schemaFolder varchar2) return XMLType
    is
      xmlSchema XMLTYPE;
    begin
      select xmlElement                                 
               "TypeList",                              
               xmlAgg                                   
                  xmlElement                             
                    "Schema",                            
                    xmlElement
                      "ResourceName",
                      extractValue(res,'/Resource/DisplayName')
                    xmlElement                         
                      "complexTypes",                  
                        select xmlAgg                               
                                 xmlElement              
                                   "complexType",        
                                   xmlElement           
                                     "name",             
                                     extractValue(value(XML),'/xsd:complexType/@name',XDB_NAMESPACES.XDBSCHEMA_PREFIXES)                          
                                   xmlElement            
                                     "SQLType",          
                                     extractValue(value(XML),'/xsd:complexType/@xdb:SQLType',XDB_NAMESPACES.XDBSCHEMA_PREFIXES)                            
                          from table                   
                                 xmlsequence           
                                   extract             
                                     xdburitype(p.path).getXML(),
                                     '/xsd:schema/xsd:complexType',
                                     XDB_NAMESPACES.XDBSCHEMA_PREFIXES
                               ) xml
                          -- order by extractValue(value(XML),'/xsd:complexType/@name',XDB_NAMESPACES.XDBSCHEMA_PREFIXES)
              ).extract('/*')                            
         into xmlSchema
         from path_view p                                
        where under_path(res,schemaFolder) = 1      
        order by extractValue(res,'/Resource/DisplayName');
      return xmlSchema;
    end;
    procedure renameCollectionTable (XMLTABLE varchar2, XPATH varchar2, COLLECTION_TABLE_PREFIX varchar2)
    as
       SYSTEM_GENERATED_NAME varchar2(256);
       COLLECTION_TABLE_NAME varchar2(256);
       CLUSTERED_INDEX_NAME  varchar2(256);
       PARENT_INDEX_NAME     varchar2(256);
       RENAME_STATEMENT varchar2(4000);
    begin
       COLLECTION_TABLE_NAME := COLLECTION_TABLE_PREFIX || '_TABLE';
       CLUSTERED_INDEX_NAME := COLLECTION_TABLE_PREFIX || '_DATA';
       PARENT_INDEX_NAME := COLLECTION_TABLE_PREFIX || '_LIST';
       select TABLE_NAME
         into SYSTEM_GENERATED_NAME
         from ALL_NESTED_TABLES
        where PARENT_TABLE_NAME = XMLTABLE
          and PARENT_TABLE_COLUMN = XPATH
          and OWNER = USER;
       RENAME_STATEMENT := 'alter table ' || USER || '."' || SYSTEM_GENERATED_NAME || '" rename to "' ||COLLECTION_TABLE_NAME || '"';
       -- -- dbms_output.put_line(RENAME_STATEMENT);
       execute immediate RENAME_STATEMENT;
       begin
         select INDEX_NAME
           into SYSTEM_GENERATED_NAME
           from ALL_INDEXES
          where TABLE_NAME = COLLECTION_TABLE_NAME
            and INDEX_TYPE = 'IOT - TOP'
            and OWNER = USER;
         RENAME_STATEMENT := 'alter index ' || USER || '."' || SYSTEM_GENERATED_NAME || '" rename to "' || CLUSTERED_INDEX_NAME || '"';
         -- -- dbms_output.put_line(RENAME_STATEMENT);
         execute immediate RENAME_STATEMENT;
       exception
         when NO_DATA_FOUND then
           null;
       end;
       begin
         select INDEX_NAME
           into SYSTEM_GENERATED_NAME
           from ALL_IND_columns
          where COLUMN_NAME = XPATH
            and TABLE_NAME =  XMLTABLE
            and TABLE_OWNER = USER;
         RENAME_STATEMENT := 'alter index ' || USER || '."' || SYSTEM_GENERATED_NAME || '" rename to "' || PARENT_INDEX_NAME || '"';
         -- -- dbms_output.put_line(RENAME_STATEMENT);
         execute immediate RENAME_STATEMENT;
       exception
         when NO_DATA_FOUND then
           null;
       end;
    end;
    function processNestedTable(currentLevel in out number, currentNode in out XMLType, query SYS_REFCURSOR)
    return XMLType
    is
      thisLevel  number;
      thisNode   xmlType;
      result xmlType;
    begin
      thisLevel := currentLevel;
      thisNode := currentNode;
      fetch query into currentLevel, currentNode;
      if (query%NOTFOUND) then
        currentLevel := -1;
      end if;
      while (currentLevel >= thisLevel) loop
        -- Next Node is a decendant of sibling of this Node.
        if (currentLevel > thisLevel) then
          -- Next Node is a decendant of this Node.
          result := processNestedTable(currentLevel, currentNode, query);
          select xmlElement
                    "Collection",
                    extract(thisNode,'/Collection/*'),
                    xmlElement
                      "NestedCollections",
                      result
             into thisNode
             from dual;
        else
          -- Next node is a sibling of this Node.
          result := processNestedTable(currentLevel, currentNode, query);
          select xmlconcat(thisNode,result) into thisNode from dual;
        end if;
      end loop;
      -- Next Node is a sibling of some ancestor of this node.
      return thisNode;
    end;
    function printNestedTables(XML_TABLE varchar2)
    return XMLType
    is
       query SYS_REFCURSOR;
       result XMLType;
       rootLevel number := 0;
       rootNode xmlType;
    begin
       open query for
            select level, xmlElement
                            "Collection",
                            xmlElement
                              "CollectionId",
                              PARENT_TABLE_COLUMN
                          ) as XML
              from USER_NESTED_TABLES
           connect by PRIOR TABLE_NAME = PARENT_TABLE_NAME
                   start with PARENT_TABLE_NAME = XML_TABLE;
        fetch query into rootLevel, rootNode;
        result := processNestedTable(rootLevel, rootNode, query);
        select xmlElement
                  "NestedTableStructure",
                  result
          into result
          from dual;
        return result;
    end;
    function generateSchemaFromTable(P_TABLE_NAME varchar2, P_OWNER varchar2 default USER)
    return XMLTYPE
    as
      xmlSchema XMLTYPE;
    begin
      select xmlElement
               "xsd:schema",
               xmlAttributes
                 'http://www.w3.org/2001/XMLSchema' as "xmlns:xsd",
                 'http://xmlns.oracle.com/xdb' as "xmlns:xdb"
               xmlElement
                 "xsd:element",
                 xmlAttributes
                   'ROWSET' as "name",
                   'rowset' as "type"
               xmlElement
                 "xsd:complexType",
                 xmlAttributes
                   'rowset' as "name"
                 xmlElement
                   "xsd:sequence",
                   xmlElement
                      "xsd:element",
                      xmlAttributes
                        'ROW' as "name",
                        table_name || '_T' as "type",
                        'unbounded' as "maxOccurs"
               xmlElement
                 "xsd:complexType",
                 xmlAttributes
                   table_name || '_T' as "name"
                 xmlElement
                   "xsd:sequence",
                     xmlAgg(ELEMENT order by INTERNAL_COLUMN_ID)
        into xmlSchema
        from (select TABLE_NAME, INTERNAL_COLUMN_ID,
                     case
                       when DATA_TYPE in ('VARCHAR2','CHAR') then
                         xmlElement
                           "xsd:element",
                           xmlattributes
                             column_name as "name",
                             decode(NULLABLE, 'Y', 0, 1) as "minOccurs",
                             column_name as "xdb:SQLName",
                             DATA_TYPE as "xdb:SQLType"
                           xmlElement
                             "xsd:simpleType",
                             xmlElement
                               "xsd:restriction",
                               xmlAttributes
                                 'xsd:string' as "base"
                               xmlElement
                                 "xsd:maxLength",
                                 xmlAttributes
                                   DATA_LENGTH  as "value"
                       when DATA_TYPE = 'NUMBER' then
                         xmlElement
                           "xsd:element",
                           xmlattributes
                             column_name as "name",
                             decode(NULLABLE, 'Y', 0, 1) as "minOccurs",
                             column_name as "xdb:SQLName",
                             DATA_TYPE as "xdb:SQLType"
                           xmlElement
                             "xsd:simpleType",
                             xmlElement
                               "xsd:restriction",
                               xmlAttributes
                                  decode(DATA_SCALE, 0, 'xsd:integer', 'xsd:double') as "base"
                               xmlElement
                                 "xsd:totalDigits",
                                 xmlAttributes
                                   DATA_PRECISION  as "value"
                       when DATA_TYPE = 'DATE' then
                         xmlElement
                           "xsd:element",
                           xmlattributes
                             column_name as "name",
                             decode(NULLABLE, 'Y', 0, 1) as "minOccurs",
                             'xsd:date' as "type",
                             column_name as "xdb:SQLName",
                             DATA_TYPE as "xdb:SQLType"
                       when DATA_TYPE like 'TIMESTAMP%WITH TIME ZONE' then
                         xmlElement
                           "xsd:element",
                           xmlattributes
                             column_name as "name",
                             decode(NULLABLE, 'Y', 0, 1) as "minOccurs",
                             'xsd:dateTime' as "type",
                             column_name as "xdb:SQLName",
                             DATA_TYPE as "xdb:SQLType"
                       else
                         xmlElement
                           "xsd:element",
                           xmlattributes
                             column_name as "name",
                             decode(NULLABLE, 'Y', 0, 1) as "minOccurs",
                             'xsd:anySimpleType' as "type",
                             column_name as "xdb:SQLName",
                             DATA_TYPE as "xdb:SQLType"
                     end ELEMENT
                from all_tab_cols c
               where c.TABLE_NAME = P_TABLE_NAME
                 and c.OWNER = P_OWNER
        group by TABLE_NAME;
      return xmlSchema;
    end;
    function appendElementList(V_ELEMENT_LIST IN OUT XDB.XDB$XMLTYPE_REF_LIST_T, V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T) return XDB.XDB$XMLTYPE_REF_LIST_T;
    function expandModel(P_MODEL XDB.XDB$MODEL_T) return XDB.XDB$XMLTYPE_REF_LIST_T;
    function expandChoiceList(P_CHOICE_LIST XDB.XDB$XMLTYPE_REF_LIST_T) return XDB.XDB$XMLTYPE_REF_LIST_T;
    function expandSequenceList(P_SEQUENCE_LIST XDB.XDB$XMLTYPE_REF_LIST_T) return XDB.XDB$XMLTYPE_REF_LIST_T;
    function expandGroupList(P_GROUP_LIST XDB.XDB$XMLTYPE_REF_LIST_T) return XDB.XDB$XMLTYPE_REF_LIST_T;
    function appendElementList(V_ELEMENT_LIST IN OUT XDB.XDB$XMLTYPE_REF_LIST_T, V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
    begin
      SELECT CAST
               SET
                 CAST(V_ELEMENT_LIST as XDBPM.XMLTYPE_REF_TABLE_T)
                 MULTISET UNION
                 CAST(V_CHILD_ELEMENT_LIST as XDBPM.XMLTYPE_REF_TABLE_T)
               as XDB.XDB$XMLTYPE_REF_LIST_T
        into V_ELEMENT_LIST
        from DUAL;
        return V_ELEMENT_LIST;     
    end;
    function expandModel(P_MODEL XDB.XDB$MODEL_T)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
      V_ELEMENT_LIST       XDB.XDB$XMLTYPE_REF_LIST_T;
      V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T;
    begin
      V_ELEMENT_LIST := XDB.XDB$XMLTYPE_REF_LIST_T();
      if P_MODEL.ELEMENTS is not null then
        V_ELEMENT_LIST := P_MODEL.ELEMENTS;
      end if;
      if (P_MODEL.CHOICE_KIDS is not NULL) then
        V_CHILD_ELEMENT_LIST := expandChoiceList(P_MODEL.CHOICE_KIDS);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end if;
      if (P_MODEL.SEQUENCE_KIDS is not NULL) then
        V_CHILD_ELEMENT_LIST := expandSequenceList(P_MODEL.SEQUENCE_KIDS);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end if;
      -- Process ANYS
      if (P_MODEL.GROUPS is not NULL) then
        V_CHILD_ELEMENT_LIST := expandGroupList(P_MODEL.GROUPS);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end if;
      return V_ELEMENT_LIST;
    end;
    function expandChoiceList(P_CHOICE_LIST XDB.XDB$XMLTYPE_REF_LIST_T)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
      V_ELEMENT_LIST       XDB.XDB$XMLTYPE_REF_LIST_T;
      V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T;
      cursor getChoices is
      select c.XMLDATA MODEL
        from XDB.XDB$CHOICE_MODEL c, TABLE(P_CHOICE_LIST) cl
       where ref(c) = value(cl);
    begin
      V_ELEMENT_LIST := XDB.XDB$XMLTYPE_REF_LIST_T();
      for c in getChoices loop
        V_CHILD_ELEMENT_LIST := expandModel(c.MODEL);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end loop;
      return V_ELEMENT_LIST;
    end;
    function expandSequenceList(P_SEQUENCE_LIST XDB.XDB$XMLTYPE_REF_LIST_T)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
      V_ELEMENT_LIST       XDB.XDB$XMLTYPE_REF_LIST_T;
      V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T;
      cursor getSequences is
      select s.XMLDATA MODEL
        from XDB.XDB$SEQUENCE_MODEL s, TABLE(P_SEQUENCE_LIST) sl
       where ref(s) = value(sl);
    begin
      V_ELEMENT_LIST := XDB.XDB$XMLTYPE_REF_LIST_T();
      for s in getSequences loop
        V_CHILD_ELEMENT_LIST := expandModel(s.MODEL);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end loop;
      return V_ELEMENT_LIST;
    end;
    function expandGroupList(P_GROUP_LIST XDB.XDB$XMLTYPE_REF_LIST_T)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
      V_ELEMENT_LIST       XDB.XDB$XMLTYPE_REF_LIST_T;
      V_CHILD_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T;  V_MODEL  XDB.XDB$MODEL_T;
      cursor getGroups is
      SELECT CASE
               -- Return The MODEL Definition for the CHOICE, ALL or SEQUENCE
               WHEN gd.XMLDATA.ALL_KID is not NULL
                 THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = gd.XMLDATA.ALL_KID)
               WHEN gd.XMLDATA.SEQUENCE_KID is not NULL
                 THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = gd.XMLDATA.SEQUENCE_KID)
               WHEN gd.XMLDATA.CHOICE_KID is not NULL
                 THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = gd.XMLDATA.CHOICE_KID)
              END MODEL
         FROM XDB.XDB$GROUP_DEF gd, XDB.XDB$GROUP_REF gr, TABLE(P_GROUP_LIST) gl
        WHERE ref(gd) = gr.XMLDATA.GROUPREF_REF
          and ref(gr) = value(gl);
    begin
      V_ELEMENT_LIST := XDB.XDB$XMLTYPE_REF_LIST_T();
      for g in getGroups loop
        V_CHILD_ELEMENT_LIST := expandModel(g.MODEL);
        V_ELEMENT_LIST := appendElementList(V_ELEMENT_LIST,V_CHILD_ELEMENT_LIST);
      end loop;
      return V_ELEMENT_LIST;
    end;
    function getComplexTypeElementList(P_COMPLEX_TYPE_REF REF XMLTYPE)
    return XDB.XDB$XMLTYPE_REF_LIST_T
    as
      V_MODEL        XDB.XDB$MODEL_T;
      V_BASE_TYPE    REF XMLTYPE;
      V_ELEMENT_LIST XDB.XDB$XMLTYPE_REF_LIST_T := XDB.XDB$XMLTYPE_REF_LIST_T();
    begin
      SELECT ct.XMLDATA.BASE_TYPE,
             CASE
               -- Return The MODEL Definition for the CHOICE, ALL or SEQUENCE
               WHEN ct.XMLDATA.ALL_KID is not NULL
                 THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = ct.XMLDATA.ALL_KID)
               WHEN ct.XMLDATA.SEQUENCE_KID is not NULL
                 THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = ct.XMLDATA.SEQUENCE_KID)
               WHEN ct.XMLDATA.CHOICE_KID is not NULL
                 THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = ct.XMLDATA.CHOICE_KID)
               WHEN ct.XMLDATA.GROUP_KID is not NULL
                 -- COMPLEXTYPE is based on a GROUP.
                 THEN (
                         -- RETURN The CHOICE, ALL or SEQUENCE for GROUP
                         SELECT CASE
                                  WHEN gd.XMLDATA.ALL_KID is not NULL
                                    THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = gd.XMLDATA.ALL_KID)
                                  WHEN gd.XMLDATA.SEQUENCE_KID is not NULL
                                    THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = gd.XMLDATA.SEQUENCE_KID)
                                  WHEN gd.XMLDATA.CHOICE_KID is not NULL
                                    THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = gd.XMLDATA.CHOICE_KID)
                                  END
                             FROM XDB.XDB$GROUP_DEF gd, xdb.xdb$GROUP_REF gr
                            WHERE ref(gd) = gr.XMLDATA.GROUPREF_REF
                              and ref(gr) = ct.XMLDATA.GROUP_KID
    --           WHEN ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.ALL_KID is not NULL
    --             THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.ALL_KID)
    --           WHEN ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.SEQUENCE_KID is not NULL
    --            THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.SEQUENCE_KID)
    --           WHEN ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.CHOICE_KID is not NULL
    --             THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.CHOICE_KID)
    --           WHEN ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.GROUP_KID is not NULL
    --             -- COMPLEXTYPE is based on a GROUP.
    --             THEN (
    --                     -- RETURN The CHOICE, ALL or SEQUENCE for GROUP
    --                     SELECT CASE
    --                              WHEN gd.XMLDATA.ALL_KID is not NULL
    --                                THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = gd.XMLDATA.ALL_KID)
    --                              WHEN gd.XMLDATA.SEQUENCE_KID is not NULL
    --                                THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = gd.XMLDATA.SEQUENCE_KID)
    --                              WHEN gd.XMLDATA.CHOICE_KID is not NULL
    --                                THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = gd.XMLDATA.CHOICE_KID)
    --                              END
    --                         FROM XDB.XDB$GROUP_DEF gd, xdb.xdb$GROUP_REF gr
    --                       WHERE ref(gd) = gr.XMLDATA.GROUPREF_REF
    --                          and ref(gr) = ct.XMLDATA.COMPLEXCONTENT.RESTRICTION.GROUP_KID
               WHEN ct.XMLDATA.COMPLEXCONTENT.EXTENSION.ALL_KID is not NULL
                 THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = ct.XMLDATA.COMPLEXCONTENT.EXTENSION.ALL_KID)
               WHEN ct.XMLDATA.COMPLEXCONTENT.EXTENSION.SEQUENCE_KID is not NULL
                 THEN ( SELECT s.XMLDATA  from XDB.XDB$SEQUENCE_MODEL s where ref(s) = ct.XMLDATA.COMPLEXCONTENT.EXTENSION.SEQUENCE_KID)
               WHEN ct.XMLDATA.COMPLEXCONTENT.EXTENSION.CHOICE_KID is not NULL
                 THEN ( SELECT c.XMLDATA  from XDB.XDB$CHOICE_MODEL c where ref(c) = ct.XMLDATA.COMPLEXCONTENT.EXTENSION.CHOICE_KID)
               WHEN ct.XMLDATA.COMPLEXCONTENT.EXTENSION.GROUP_KID is not NULL
                 -- COMPLEXTYPE is based on a GROUP.
                 THEN (
                         -- RETURN The CHOICE, ALL or SEQUENCE for GROUP
                         SELECT CASE
                                  WHEN gd.XMLDATA.ALL_KID is not NULL
                                    THEN ( SELECT a.XMLDATA  from XDB.XDB$ALL_MODEL a where ref(a) = gd.XMLDATA.ALL_KID)
                    

  • Registerschema gives ORA-01792: maximum number of columns...

    Hi,
    DB: Oracle9i Enterprise Edition Release 9.2.0.6.0
    Opp Sys: HP-UX
    I've just increased the size of an XSD we have loaded in a customers database and attempting to reload using dbms_xmlschema.registerschema gives the following error:
    ORA-31084: error while creating table "SOLO"."LetterRoot5799_TAB" for element "LetterRoot"
    ORA-01792: maximum number of columns in a table or view is 1000
    ORA-02310: exceeded maximum number of allowable columns in table
    ORA-06512: at "XDB.DBMS_XMLSCHEMA_INT", line 0
    ORA-06512: at "XDB.DBMS_XMLSCHEMA", line 26
    ORA-06512: at "SOLO.WORK_TEST_LETTERS_XSD", line 23
    ORA-06512: at line 2
    Is there a work around for this?
    Thanks,
    Mike Moore

    Hi! I faced the same problem as author of a thread. At first it was just the same and I used solution that was offered - add attribute xdb:SQLInline="false".
    But now this error (ORA-01792: maximum number of columns in a table or view is 1000) became to rise on element that doesn't have a lot of attributes or subelements that coul exceed limit of 1000! Moreover it is based on complex type that already exists! It was created during another schema registration, which is included in schema that I'm trying to register now!
    Does anyone challenged this problem?
    I use Oracle9i Enterprise Edition Release 9.2.0.5.0

  • Need help getting large schema registered in database ORA-19046

    Hi All,
    I'm trying to get this schema registered in our oracle db so we can use the XML as structured storage.  I'm using 11g XE locally and 10.2g in production.  I'm trying to get it loaded locally first.  Here is the command i am using:
    BEGIN
      DBMS_XMLSCHEMA.registerSchema(
        SCHEMAURL => 'http://ACORD.org/Standards/Life/2',
        SCHEMADOC => bfilename('TEMP','TXLife2.28.00.xsd'),
        CSID => nls_charset_id('AL32UTF8'));
    END;
    And this is the error i get back:
    Error report:
    ORA-19046: Out-of-line table cannot be shared by two top-level tables.
    ORA-06512: at "XDB.DBMS_XMLSCHEMA_INT", line 37
    ORA-06512: at "XDB.DBMS_XMLSCHEMA", line 65
    ORA-06512: at "XDB.DBMS_XMLSCHEMA", line 136
    ORA-06512: at line 2
    You can download the schema from here:  http://www.chinacitystpete.com/TXLife2.28.00.xsd
    Any help or suggestions would be greatly appreciated.
    Added link to xsd file. Message was edited by: user5463804

    Hi SonicSwap,
    Spry 1.4 doesn't handle "nested structures" due to the way we
    flatten the data into a tabular row/column structure. Because you
    are selecting "playlist/tracklist/track" as your source of data,
    the repeating <link> nodes under track are considered as a
    "nested structure". You've noticed that the last one wins.
    That said, we are previewing some "nested structure" support
    we are planning on releasing in Spry 1.5. This support comes in the
    form of allowing more control over how the data is flattened, and
    the introduction of "specialized" data sets that know how to
    iterate over nested data.
    You can check out this support here:
    http://labs.adobe.com/technologies/spry/preview/samples/data_region/NestedXMLDataSample.ht ml
    The main 1.5 preview page is here:
    http://labs.adobe.com/technologies/spry/preview/
    --== Kin ==--

  • ORA-24335 - cannot support more than 1000 columns - How to solve this?

    Hi,
    I got error message 'ORA-24335 - cannot support more than 1000 columns ' when i try to insert x no of rows for a table with following code:
    INSERT ALL
    INTO tableA Values ('A', 'B', 'C', 1, 2, 3)
    INTO tableA Values ('D', 'E', 'F', 4, 5, 6)
    INTO tableA Values ('G', 'H', 'I', 7, 8, 9)
    SELECT *
    FROM DUAL
    How to solve above?
    What does it really mean? It's not as easy as if my table has 10 columns than I can't insert more than 100 rows (1000 columns divided with 10 columns = maximun 100 rows to insert), or?
    Is there a better/more appropriate way to do insert many rows?
    Should I do my inserts with an OracleTransaction (My application is developed with C# and asp.net), as ~follows
    BEGIN
    INSERT INTO tableA Values ('A', 'B', 'C', 1, 2, 3)
    INSERT INTO tableA Values ('D', 'E', 'F', 4, 5, 6)
    INSERT INTO tableA Values ('G', 'H', 'I', 7, 8, 9)
    COMMIT
    END
    Thx in advance!
    Edited by: user8819407 on 2010-mar-07 15:40

    Hi,
    So how did you solve the problem? Can you please give an example?
    I have the same problem inserting over 1000 values into my Oracle DB. The table only has 51 columns but to speed up the insert command, I use bulk inserts via insert all command. I need to insert 100 rows at a time for a total of 5100 values.
    Example:
    SQLCmd = INSERT ALL INTO MYTABLE (VAL_ID,VAL_NAME,VAL_NUM,VAL_TIME,VAL_CMM,VAL_TIME1,VAL_TRIP,VAL_REMAINING,VAL_AGE,VAL_COUNT,VAL_RSTS,VAL_VOLT,VAL_RF,VAL_DC,VAL_HOPS,VAL_STATUS,VAL_ELAPSED,MODIFY_TIME) VALUES (?,?,?,TO_DATE(?,?),?,TO_DATE(?,?),?,?,?,?,?,?,?,?,?,?,?,SYSTIMESTAMP)
    INTO MYTABLE (VAL_ID,VAL_NAME,VAL_NUM,VAL_TIME,VAL_CMM,VAL_TIME1,VAL_TRIP,VAL_REMAINING,VAL_AGE,VAL_COUNT,VAL_RSTS,VAL_VOLT,VAL_RF,VAL_DC,VAL_HOPS,VAL_STATUS,VAL_ELAPSED,MODIFY_TIME) VALUES (?,?,?,TO_DATE(?,?),?,TO_DATE(?,?),?,?,?,?,?,?,?,?,?,?,?,SYSTIMESTAMP)
    INTO MYTABLE (VAL_ID,VAL_NAME,VAL_NUM,VAL_TIME,VAL_CMM,VAL_TIME1,VAL_TRIP,VAL_REMAINING,VAL_AGE,VAL_COUNT,VAL_RSTS,VAL_VOLT,VAL_RF,VAL_DC,VAL_HOPS,VAL_STATUS,VAL_ELAPSED,MODIFY_TIME) VALUES (?,?,?,TO_DATE(?,?),?,TO_DATE(?,?),?,?,?,?,?,?,?,?,?,?,?,SYSTIMESTAMP)
    INTO MYTABLE (VAL_ID,VAL_NAME,VAL_NUM,VAL_TIME,VAL_CMM,VAL_TIME1,VAL_TRIP,VAL_REMAINING,VAL_AGE,VAL_COUNT,VAL_RSTS,VAL_VOLT,VAL_RF,VAL_DC,VAL_HOPS,VAL_STATUS,VAL_ELAPSED,MODIFY_TIME) VALUES (?,?,?,TO_DATE(?,?),?,TO_DATE(?,?),?,?,?,?,?,?,?,?,?,?,?,SYSTIMESTAMP)
    SELECT 1 FROM DUAL
    SQLVals = 1 22C38299 80700334 04-19-2012 13:55:33 mm-dd-yyyy hh24:mi:ss MCC93000 04/19/2012 13:55:42 mm-dd-yyyy hh24:mi:ss 12 4 0.792191 23 1 0.00 -113.50 13.48 9 1 9
    1 36PR7038 8070EDC2 04-19-2012 12:24:35 mm-dd-yyyy hh24:mi:ss MCC60360 04/19/2012 12:24:41 mm-dd-yyyy hh24:mi:ss 7 4 0.757501 3 2 13.88 -114.80 14.06 5 1 6
    1 42C63512 8050166F 04-19-2012 16:02:50 mm-dd-yyyy hh24:mi:ss MCC52420 04/19/2012 16:02:57 mm-dd-yyyy hh24:mi:ss 10 4 0.778471 8 1 0.00 -122.30 13.05 8 1 7
    1 33MR3076 80803E75 04-19-2012 13:13:16 mm-dd-yyyy hh24:mi:ss MCC60330 04/19/2012 13:13:22 mm-dd-yyyy hh24:mi:ss 13 5 0.636721 28 3 0.00 -122.19 0.70 8 1 6
    Then I call: &DBInsert($sqlCmd, @sqlVals);
    This is the error I get: ORA-24335: cannot support more than 1000 columns.
    I need to insert about 879,500 rows (51 cols per row). The values I read from a text file in sets of about 48,000 and put them into a hash. I tried inserting one row at a time, but it takes too long, about 28 hrs! Then, I tried the bulk update with only 6 rows and the total time was about 25 minutes. Which is acceptable to us.
    Thanks!

  • Replication on the table with XMLType column and schema registered

    Dear All,
    Does Oracle XML DB 11g support replication for tables with schema registered?
    Is there any recommended approach?
    Thanks and regards,
    Swapnil

    Hmmmm ... I don't know if I should smile or frown with the implication that I am an OO guy :D :D
    Most of my colleagues when I started working as a software engineer, treated me as too low-level because of my C background (started doing C in 1985).
    In my last job, my colleagues hated my guts because I was asking them to squeeze every bit of performance out of C++ by using STL which is definitely not OO (although C++ is).
    My current colleagues treat me as a DB guru (which I most definitely am not) and they overlook/forget the fact that most of them use Java libraries in their projects, that I wrote for them !
    I am inclined to believe that I do not fall into any category in the end...
    The only thing I am for sure - and I am proud of it - is inquisitive. I want to know everything there is about the tools I use, and so I end up spending hours and hours investigating... (Microsoft found that out the hard way when I filed 16 bug reports in 8 days when Visual C++ 6 came out ! Not that it hurt them though...)
    This is where my confession ends (and my working on the XML validator starts...)
    Καληνύχτα Marco
    Philip (Φίλιππος in Greek)
    PS: I did not follow the last solution anyway. I just wanted to verify its operability ;)

  • Getting error ORA-01792

    Hello,
    I am creating a mapping where there are 5 sources. 3 sources are pretty small.
    The remaining 2 are having almost 300 columns each.
    My target table has 700 fields.
    Now when I am running the mapping its giving me this error
    ORA-01792:maximum number of columns in a table or view is 1000.
    My mapping has Set-based configuration & Update/insert strategy.
    I don't know why this error is coming although the target has just 700 fields.
    Let me know what might be the reason. This is the most important dimension in our star-schema.
    Thanks
    Neeraj

    Hi Neeraj
    I have never come across this one before because so far all of my dimensions use a lot less columns than you are using.
    I'm curious though as to where the error is coming. Is it coming during deployment of the table, during the deployment of the map, or during execution of the map?
    Also, are you doing anything like a slowly changing dimension type 2? If so, you are probably using a JOINER to join the original table to the data coming in from the source system. I may be wrong but I have a feeling that OWB will use a temporary table to store this intermediate result. This being the case, the number of coluns will exceed 1000.
    Mind you, why there is this limitation to begin with escapes me. Does anyone reading this know of a way to increase this number and is it set at the database or OWB level?
    I'm afraid that if the number of allowed columns cannot be increased that you, and me too at some point, will have to split the map into smaller chunks. Perhaps you could use two target tables with a one-to-one relationship? Not a nice solution but one that will work.
    Hope this helps
    Regards
    Michael

  • Handeling more than 1000 columns in where clause

    Hi,
    I am using oracle 9i. We are creating a select query and adding where clause at runtime.
    The no of clolumns in where clause depends on the results from another enterprise app. There may be any no of columns from 0-N. Till 1000 columns every thing works fine but when it goes beyond 1000 it gives the following error:
    ERROR:
    java.sql.SQLException: ORA-01795: maximum number of expressions in a list is 100
    0
    at oracle.jdbc.dbaccess.DBError.throwSqlException(DBError.java:134)
    at oracle.jdbc.oci8.OCIDBAccess.check_error(OCIDBAccess.java:2321)
    at oracle.jdbc.oci8.OCIDBAccess.parseExecuteDescribe(OCIDBAccess.java:12
    55)
    at oracle.jdbc.driver.OracleStatement.doExecuteQuery(OracleStatement.jav
    a:2391)
    at oracle.jdbc.driver.OracleStatement.doExecuteWithTimeout(OracleStateme
    nt.java:2672)
    at oracle.jdbc.driver.OracleStatement.executeQuery(OracleStatement.java:
    572)
    Please help.
    Thanks in advance.

    Thanks Archana,
    You are right.
    I think i have not framed my question right.
    Actually its problem with "IN", which i am using in where clause. It working properly till 1000 expressions like "select * from foo where fooid in (n0,n1,n2......,n1000)".
    But throwing exception once the count increases to 1000 like
    "select * from foo where fooid in (n0,n1,n2......,n1000,n1001,n1002)".
    Thanks,
    Mukesh

  • Xs:int , the schema register generate a NUMBER(10), but can not insert xml

    hi guys:
    I found a problem in the Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Production:
    in the schema regist, Oracle help me create a table, with 2 Number(10) segments
    validFrom NUMBER(10)
    validTo NUMBER(10)
    then, I upload the xml file via the ftp, an error report:
    ftp: 19120 bytes received in 0.03Seconds 637.33Kbytes/sec.
    ftp> pwd
    257 "/home/tonyfolder/data" is current directory.
    ftp> put test.xml
    200 PORT Command successful
    150 ASCII Data Connection
    550- Error Response
    ORA-31038: Invalid integer value: "3371475600"
    550 End Error Response
    ftp: 623 bytes sent in 0.00Seconds 623000.00Kbytes/sec.
    3371475600 is really 10 number, the Oracle do not work ?

    hi mdrake, i try this :
    create table XML_DOCUMENT_TABLE
    FILENAME VARCHAR2(64),
    XML_DOCUMENT SYSTEM.XMLTYPE,
    NUMBERTEST NUMBER(10)
    SQL> insert into xml_document_table values ( '' , '' , '3371475600' );
    1 row inserted
    SQL>
    ??? we can insert the '3371475600' into number(10) directly, but we can not input this num via the oracle auto upload
    otherwiseo, your mean is, when the oracle upload xml, oracle checks the number, '3371475600', this value large than int, so ... i can can not input,
    by the way, the num 337147560 ( 9 bit) , xmldb upload success, why ?
    thanks and happy new year

  • Help Needed: Facing the error ORA-01406: fetched column value was truncated

    Hi Everyone,
    When I run a particular PL/SQL query using Oracle 9i ODBC driver, it is working fine and fetching me the desired results.
    However, when I run the same query using the Oracle 10g ODBC driver, I am getting the error: ORA-01406: fetched column value was truncated.
    I have checked all the fields of the table and they are well within the allowable limit.
    Can you please let us know what needs to be done to resolve this issue?
    Thanks and Regards,
    Sudhindra

    Well it's obviously a problem with the client software. Doesn't Datastage have some way of configuring these things?
    rgds, APC

  • Weird ORA-01406: fetched column value was truncated error for SELECT query

    DB version:10gR2
    When one of our application fires the below query, we get
    ORA-01406: fetched column value was truncatederror.
    select     trk_dtl,
         trk_type,
         trk_id,
         trk_desc,
    from     shp_dtl
    where     shp_type = 'HN'
    and     shp_type = 828;The documentation says
    Cause:In a host language program, a FETCH operation was forced to truncate a character string. The program buffer area for this column was not large enough to contain the entire string. The cursor return code from the fetch was +3.But when the application is pointed to an identical schema in the same instance, we don't get this error. So, this has got nothing to do client application as the documentation says.
    Any idea what other possibilities are there?

    Post description of shp_dtl.

  • ORA-00957: duplicate column name

    When I am enableversioning of a table, I get following error messages:
    SQL> execute dbms_wm.enableversioning('transcript');
    BEGIN dbms_wm.enableversioning('transcript'); END;
    ERROR at line 1:
    ORA-00957: duplicate column name
    ORA-06512: at "SYS.LTDDL", line 399
    ORA-06512: at "SYS.LTDDL", line 1117
    ORA-06512: at "SYS.LT", line 7181
    ORA-06512: at line 1
    I checked the column name that will be add by dbms_wm package and did not see any column which would cause this problem.
    Could some one give me the list of reserved column names for dbms_wm package?
    Thanks
    Ashley

    Ashley
    These are some the reserved words used by OWM in its internal views. These can also conflict on enable versioning
    statements.
    RIDCHILD RIDBASE RIDPARENT CHILDSTATE PARENTSTATE BASEDS CHILDDS PARENTDS
    FIRSTCHILDVER CHILDVER PARENTVER POS RID VERSION NEXTVER DELSTATUS
    LTLOCK
    In the release after 9iR2, we have augmented reserved words with a prefix that will commonly not conflict with
    user schema column names.
    Let me know if you were able to identify the reserve word conflict.
    Arun
    [email protected]

  • ORA-00904: invalid column name in select query by using abstract datatype

    Hi,
    I had created abstract datatype as PERSON_TY and ADDRESS_TY ,
    after inserting the record . i'm tryng to select the column but i got the error , even i refferd all those thing. they are given that same please look this finde me a result.
    SQL> DESC PERSON_TY
    Name Null? Type
    NAME VARCHAR2(25)
    ADDRESS ADDRESS_TY
    SQL> DESC ADDRESS_TY
    Name Null? Type
    STREET VARCHAR2(30)
    CITY VARCHAR2(25)
    STATE CHAR(2)
    COUNTRY VARCHAR2(15)
    SQL> SELECT * FROM EMPLOYE
    2 ;
    EMP_CODE
    PERSON(NAME, ADDRESS(STREET, CITY, STATE, COUNTRY))
    10
    PERSON_TY('VENKAT', ADDRESS_TY('112: BLUE MOUNT', 'CHENNAI', 'TN', 'INDIA'))
    20
    PERSON_TY('SRINI', ADDRESS_TY('144: GREEN GARDEN', 'THAMBARAM', 'TN', 'INDIA'))
    SQL> SELECT PERSON.NAME FROM EMPLOYE
    2 ;
    SELECT PERSON.NAME FROM EMPLOYE
    ERROR at line 1:
    ORA-00904: invalid column name
    regards
    venki

    SELECT PERSON.NAME FROM EMPLOYEIf you look in the documentation, you will see that we need to alias the table in order to make this work:
    select e.person.name from employees e
    /Cheers, APC
    Blog : http://radiofreetooting.blogspot.com

  • ORA-01405: fetched column value is NULL

    Hi All,
    I am using OWB 10gR2 and DB 10gR2. I am getting the following error while executing the mapping,
    ORA-01405: fetched column value is NULL.
    I have used NVL function for the measure columns, but the problem is not solved.
    Can anybody please tell me solution,
    Thanks in advance,
    Siva

    Hi Siva
    It may be that you've taken care of null value in just one place and now, the error is coming
    from somewhere further down the line.
    Regards
    Arif

Maybe you are looking for

  • Enable tool tip in Exported PDF document from a CRE Report

    Hi All, We are on BObj 4.0 and using CRE for our reports. We have enabled Tool tip text on mouse over for certain labels which works great in browser. When we export to PDF, we dont see the Tool tip text. Is there a way we can configure this in CRE s

  • Problem selecting and copying items

    I use my iPad Air to work on groups in the photo sharing site, flickr.  Since installing IOS8 I am having extreme difficulty in selecting and copying awards.  Selection is done by dragging through the html, and then clicking on a blue icon "COPY"  So

  • PayPal integration using SOAP messages

    Hello, for a integration scenario we want to call a PayPal SOAP API as described in https://www.x.com/docs/DOC-1244. The PayPal safety requirements are fullfilled by giving a Username, Password and Signature in the SOAP Header: <SOAP-ENV:Header>     

  • PDF export with bookmarks (CR XI R2)

    Hello, Crystal Reports XI R2 supports exporting of PDFs with bookmarks (based on the group tree). How can this feature be accessed via .Net or COM? I can't find a associated property of the export-object. Thank you very much in advance.

  • HELP! Error -19 while trying to update iPhone to 2.1

    Hi, So I tried to update my iphone this afternoon to the 2.1 version. iTunes downloaded the program and when it went to update the phone it said an error (-19) had occured. Does anyone know what this means or how to fix it ?