Xpath performance and xsi namespace

Question

In my xpath, I need to use the "xsi" namespace to specify the xpath condition. It seems to be the performance of the xpath that uses the "xsi" namespace is extremly slow, compared with a similar xpath that does not use the name space, although the number of retrieved objects are the same in my test case.
What causes such a big difference in speed? Is that possible when I use the "xsi" namespace in the xpath, the xpath is not get rewritten? How can I improve the performance when using "xsi" namespace.
1)xpath not use the namespace
select extract(object_value, '/Test/Group/Object[uniqueName="a1"]') from Test where existsNode(object_value, '/Test/Group[uniqueName="N10001"])=1;
2)xpath use the "xsi" namespace
select extract(object_value, '/Test/Group/Object[uniqueName="a1" and @xsi:type="Architecture"]', 'xmlns="http://www.myspace.com/testXML" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') from Test where existsNode(object_value, '/Test/Group[uniqueName="N10001"])=1;

Answer 1

Yes, you'll need to workout where to split the document.. Good, and typical points to break up the entity are if you have a choice of one or more complex structures.
The following code may help with looking at this..
You'll need to register the XML Schema with gentables="false" so that all the types get generated.. You can then look at the types and see how many columns each type will generate if you build a table on it...
create or replace package XDB_ANALYZE_XMLSCHEMA_11100
authid CURRENT_USER
as
  function analyzeStorageModel(COMPLEX_TYPE VARCHAR2) return XMLTYPE;
  function analyzeStorageModel(ATTR_NAME VARCHAR2, SUBTYPE VARCHAR2, SUBTYPE_OWNER 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 generateSchemaFromTable(P_TABLE_NAME varchar2, P_OWNER varchar2 default USER) return XMLTYPE;
  function showSQLTypes(schemaFolder varchar2) return XMLType;
  NAMESPACES varchar2(1024) := xdb_namespaces.XMLSCHEMA_PREFIX_XSD || ' ' || xdb_namespaces.XDBSCHEMA_PREFIX_XDB;
end XDB_ANALYZE_XMLSCHEMA_11100;
show errors
create or replace package body XDB_ANALYZE_XMLSCHEMA_11100
as
TYPE STORAGE_MODEL_T is RECORD
  TYPE_NAME           varchar2(128),
  TYPE_OWNER          varchar2(32),
  STORAGE_MODEL       XMLType
TYPE STORAGE_MODEL_LIST_T is TABLE OF STORAGE_MODEL_T;
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;
DEPTH_COUNT NUMBER(2) := 0;
STORAGE_MODEL_LIST       STORAGE_MODEL_LIST_T := STORAGE_MODEL_LIST_T();
BASETYPE_LIST            BASETYPE_LIST_T := BASETYPE_LIST_T();
function getLocalAttributes(SQLTYPE varchar2, SQLTYPE_OWNER VARCHAR2) return XMLType;
function makeElement(ATTR_NAME varchar2)
return xmltype
as
  VALID_NAME varchar2(4000) := ATTR_NAME;
begin
  -- dbms_output.put_line('Processing : ' || ATTR_NAME);
  if (ATTR_NAME LIKE '%$') THEN
    VALID_NAME := SUBSTR(VALID_NAME,1,LENGTH(VALID_NAME) - 1);
  end if;
  return XMLTYPE( '<' || VALID_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 getTypeHierarchy(ELEMENT_NAME varchar2, TYPE_HIERARCHY varchar2)
return XMLType
as
  SUBTYPE_HIERARCHY     varchar2(4000);
  ATTRIBUTES            XMLTYPE;
  SUBTYPE_STORAGE_MODEL XMLTYPE;
  STORAGE_MODEL         XMLTYPE;
  ATTR_COUNT            NUMBER := 0;
  V_TYPE_OWNER          varchar2(32);
  V_TYPE_NAME           varchar2(128);
  CURSOR FIND_EXTENDED_TYPES
  is
  select TYPE_NAME, OWNER
    from ALL_TYPES
   where SUPERTYPE_NAME  = V_TYPE_NAME
     and SUPERTYPE_OWNER = V_TYPE_OWNER; 
begin
  dbms_output.put_line('Type Hierarchy : ' || TYPE_HIERARCHY );
  if DEPTH_COUNT > 25 then
    return null;
  end if;
  DEPTH_COUNT := DEPTH_COUNT + 1;
  SUBTYPE_HIERARCHY := substr(TYPE_HIERARCHY,instr(TYPE_HIERARCHY,'/',2));
  V_TYPE_OWNER := substr(TYPE_HIERARCHY,2,instr(TYPE_HIERARCHY,'.',2) - 2);
  if (instr(TYPE_HIERARCHY,'/',-1) > 1) then
    V_TYPE_NAME := substr(TYPE_HIERARCHY,instr(TYPE_HIERARCHY,'.',2) + 1,instr(TYPE_HIERARCHY,'/',2) - instr(TYPE_HIERARCHY,'.',2) -1);
  else
    V_TYPE_NAME := substr(TYPE_HIERARCHY,instr(TYPE_HIERARCHY,'.') + 1);
    SUBTYPE_HIERARCHY := null;
  end if;
  dbms_output.put_line('Processing : "' || V_TYPE_OWNER || '"."' || V_TYPE_NAME || '"');
  STORAGE_MODEL := makeElement(ELEMENT_NAME);
  select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@type',V_TYPE_NAME)
    into STORAGE_MODEL
    from dual;
  select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@typeOwner',V_TYPE_OWNER)
    into STORAGE_MODEL
    from dual;
  ATTRIBUTES := getLocalAttributes(V_TYPE_NAME, V_TYPE_OWNER);         
  ATTR_COUNT := ATTR_COUNT + ATTRIBUTES.extract('/' || ATTRIBUTES.getRootElement() || '/@columns').getNumberVal();
  select appendChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),ATTRIBUTES)
    into STORAGE_MODEL        
    from DUAL;
  if (SUBTYPE_HIERARCHY is not null) then
    SUBTYPE_STORAGE_MODEL := getTypeHierarchy('subType',SUBTYPE_HIERARCHY);
    ATTR_COUNT := ATTR_COUNT + SUBTYPE_STORAGE_MODEL.extract('/' || SUBTYPE_STORAGE_MODEL.getRootElement() || '/@columns').getNumberVal();
    select appendChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),SUBTYPE_STORAGE_MODEL)
      into STORAGE_MODEL
      from DUAL;
  else
    dbms_output.put_line('Processing All known SubTypes of : "' || V_TYPE_OWNER || '"."' || V_TYPE_NAME || '"');
    for t in FIND_EXTENDED_TYPES loop
      SUBTYPE_STORAGE_MODEL := expandSQLType('ExtendedType',T.TYPE_NAME,T.OWNER);
      ATTR_COUNT := ATTR_COUNT + SUBTYPE_STORAGE_MODEL.extract('/' || SUBTYPE_STORAGE_MODEL.getRootElement() || '/@columns').getNumberVal();
      select appendChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),SUBTYPE_STORAGE_MODEL)
        into STORAGE_MODEL
        from DUAL;
    end loop;   
  end if;
  select insertChildXML(STORAGE_MODEL,'/' || STORAGE_MODEL.getRootElement(),'@columns',ATTR_COUNT)
    into STORAGE_MODEL
    from dual;
  DEPTH_COUNT := DEPTH_COUNT - 1; 
  return STORAGE_MODEL;
end;
function getStorageModel(TYPE_NAME VARCHAR2, TYPE_OWNER VARCHAR2)
return XMLType
as
  BASETYPE            varchar2(128);
  BASETYPE_OWNER      varchar2(32);
  STORAGE_MODEL       STORAGE_MODEL_T;
begin
  dbms_output.put_line('Depth  : ' || DEPTH_COUNT || '. Getting Storage Model for "' || TYPE_OWNER || '.' || TYPE_NAME || '".' );
  if DEPTH_COUNT > 25 then
    return null;
  end if;
  DEPTH_COUNT := DEPTH_COUNT + 1;
  for i in 1..STORAGE_MODEL_LIST.count loop
    STORAGE_MODEL := STORAGE_MODEL_LIST(i);
    if (STORAGE_MODEL.TYPE_NAME = TYPE_NAME and STORAGE_MODEL.TYPE_OWNER = TYPE_OWNER) then
      DEPTH_COUNT := DEPTH_COUNT - 1;
      return STORAGE_MODEL.STORAGE_MODEL;
    end if;
  end loop;
  STORAGE_MODEL.TYPE_NAME     := TYPE_NAME;
  STORAGE_MODEL.TYPE_OWNER    := TYPE_OWNER;
  STORAGE_MODEL.STORAGE_MODEL := getTypeHierarchy('RootType',getPathToRoot(TYPE_NAME,TYPE_OWNER));
  STORAGE_MODEL_LIST.extend(1);
  STORAGE_MODEL_LIST(STORAGE_MODEL_LIST.count) := STORAGE_MODEL;
  DEPTH_COUNT := DEPTH_COUNT - 1;
  return STORAGE_MODEL.STORAGE_MODEL;
end;
function getLocalAttributes(SQLTYPE varchar2, SQLTYPE_OWNER VARCHAR2)
return XMLType
as
  CHILD_ATTR          XMLTYPE;
  ATTR_COUNT          NUMBER := 0;
  COLLECTION_TYPE     varchar2(128);
  COLLECTION_OWNER    varchar2(32);
  SUPERTYPE           varchar2(128);
  STORAGE_MODEL       xmlType;
  SQL_ATTRIBUTES      XMLTYPE := xmlType('<SQLAttributes/>');
  CURSOR FIND_CHILD_ATTRS
  is
  select ATTR_NAME, ATTR_TYPE_OWNER, ATTR_TYPE_NAME, INHERITED
    from ALL_TYPE_ATTRS
   where TYPE_NAME = SQLTYPE
     and OWNER = SQLTYPE_OWNER
     and INHERITED = 'NO'
   order by ATTR_NO;       
begin    
  for ATTR in FIND_CHILD_ATTRS loop
    CHILD_ATTR := makeElement(ATTR.ATTR_NAME);
    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 COLLECTION_TYPE, COLLECTION_OWNER
        from ALL_COLL_TYPES
       where TYPE_NAME = ATTR.ATTR_TYPE_NAME
         and OWNER = ATTR.ATTR_TYPE_OWNER;
      -- Attribute is a Collection Type. Each Collection requires 2 columns.
      select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@collectionType',COLLECTION_TYPE)
        into CHILD_ATTR
        from dual;
      select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@collectionOwner',COLLECTION_OWNER)
        into CHILD_ATTR
        from dual;
      select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@columns',2)
        into CHILD_ATTR
        from dual;
    exception
      when no_data_found then
        -- Attribute is not a collection type.
        begin
          -- Check for Attributes based on non-scalar types.
          select SUPERTYPE_NAME
            into SUPERTYPE
            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.
          select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@type',ATTR.ATTR_TYPE_NAME)
            into CHILD_ATTR
            from dual;
          select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@owner',ATTR.ATTR_TYPE_OWNER)
            into CHILD_ATTR
            from dual;
          STORAGE_MODEL := getStorageModel(ATTR.ATTR_TYPE_NAME, ATTR.ATTR_TYPE_OWNER);   
          select appendChildXML(CHILD_ATTR,'/' || ATTR.ATTR_NAME,STORAGE_MODEL)
            into CHILD_ATTR
            from DUAL;
         -- The cost of a non scalar Type is the number of attributes plus one for Type and one for the TYPEID.
         select insertChildXML(CHILD_ATTR,'/' || ATTR.ATTR_NAME,'@columns',STORAGE_MODEL.extract(STORAGE_MODEL.GETROOTELEMENT() || '/@columns').getNumberVal() + 2)
           into CHILD_ATTR
           from dual;
        exception
          when no_data_found then
            -- Attribute is based on a scalar type
            select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@type',ATTR.ATTR_TYPE_NAME)
              into CHILD_ATTR
              from dual;
            select insertChildXML(CHILD_ATTR,'/' || CHILD_ATTR.getRootElement(),'@columns',1)
              into CHILD_ATTR
              from dual;
        end;
    end;
    select appendChildXML(SQL_ATTRIBUTES,'/' || SQL_ATTRIBUTES.getRootElement(),CHILD_ATTR)
      into SQL_ATTRIBUTES
      from DUAL;
    ATTR_COUNT := ATTR_COUNT + CHILD_ATTR.extract('/' || CHILD_ATTR.getRootElement() || '/@columns').getNumberVal();
  end loop;
  select insertChildXML(SQL_ATTRIBUTES,'/' || SQL_ATTRIBUTES.getRootElement(),'@columns',ATTR_COUNT)
    into SQL_ATTRIBUTES
    from dual;
  return SQL_ATTRIBUTES;
end;
function analyzeStorageModel(ATTR_NAME VARCHAR2, SUBTYPE VARCHAR2, SUBTYPE_OWNER VARCHAR2)
return XMLType
as
  ROOT_NODE_NAME      VARCHAR2(128);
  TYPE_DEFINITION     XMLTYPE;
  STORAGE_MODEL       XMLTYPE;  
  ATTR_COUNT          NUMBER := 0;
begin
  dbms_output.put_line('Processing Attribute : "' || ATTR_NAME || '". SQLType="' || SUBTYPE_OWNER || '.' || SUBTYPE || '".' );
  TYPE_DEFINITION := makeElement(ATTR_NAME);
  select insertChildXML(TYPE_DEFINITION,'/' || TYPE_DEFINITION.getRootElement(),'@type',SUBTYPE)
    into TYPE_DEFINITION
    from dual;
  select insertChildXML(TYPE_DEFINITION,'/' || TYPE_DEFINITION.getRootElement(),'@owner',SUBTYPE_OWNER)
   into TYPE_DEFINITION
   from dual;
  STORAGE_MODEL := getStorageModel(SUBTYPE, SUBTYPE_OWNER);         
  ATTR_COUNT := ATTR_COUNT + STORAGE_MODEL.extract('/' || STORAGE_MODEL.getRootElement() || '/@columns').getNumberVal();
  select insertChildXML(TYPE_DEFINITION,'/' || TYPE_DEFINITION.getRootElement(),'@columns',ATTR_COUNT)
    into TYPE_DEFINITION
    from dual;
  select appendChildXML
           TYPE_DEFINITION,
           '/' || TYPE_DEFINITION.getRootElement(),
           STORAGE_MODEL
    into TYPE_DEFINITION        
    from DUAL;
  return TYPE_DEFINITION;
end;
function analyzeStorageModel(COMPLEX_TYPE VARCHAR2)
return XMLTYPE
as
  SQLTYPE           VARCHAR2(128);
  SQLTYPE_OWNER     VARCHAR2(32);
  RESULT            XMLTYPE;
begin
STORAGE_MODEL_LIST := STORAGE_MODEL_LIST_T();
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;
  -- dbms_output.put_line('Processing SQLType : "' || SQLTYPE_OWNER || '.' || SQLTYPE || '".' );
  return analyzeStorageModel(COMPLEX_TYPE,SQLTYPE,SQLTYPE_OWNER);
exception
  when no_data_found then
    dbms_output.put_line('Unable to find SQLType mapping for complexType : "' || COMPLEX_TYPE || '".' );
    return null;
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()  || '/@columns').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() || '/@columns').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,'@columns',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',NAMESPACES)                          
                               xmlElement            
                                 "SQLType",          
                                 extractValue(value(XML),'/xsd:complexType/@xdb:SQLType',NAMESPACES)                            
                      from table                   
                             xmlsequence           
                               extract             
                                 xdburitype(p.path).getXML(),
                                 '/xsd:schema/xsd:complexType',
                                 NAMESPACES
                           ) xml
                      -- order by extractValue(value(XML),'/xsd:complexType/@name',NAMESPACES)
          ).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 = 'VARCHAR2' then
                     xmlElement
                       "xsd:element",
                       xmlattributes
                         column_name as "name",
                         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 = 'DATE' then
                     xmlElement
                       "xsd:element",
                       xmlattributes
                         column_name as "name",
                         'xsd:dateTime' as "type",
                         column_name as "xdb:SQLName",
                         DATA_TYPE as "xdb:SQLTYPE"
                   else
                     xmlElement
                       "xsd:element",
                       xmlattributes
                         column_name as "name",
                         '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;
end XDB_ANALYZE_XMLSCHEMA_11100;
show errors
--You can use this as follows...
SQL> set long 100000
SQL> select xdb_analyze_xmlschema.analyzeStorageModel('ComponentA') from dual;
<ComponentA type="COMPONENTA_T" owner="XDBTEST" columns="50">
  <RootType type="COMPONENTA_T" typeOwner="XDBTEST" columns="50">
    <SQLAttributes columns="14">
      <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
      <COMPONENTA_UNIQUENAME type="COMPONENTA_UNIQUENAME_T" owner="XDBTEST" columns="6">
        <RootType type="COMPONENTA_UNIQUENAME_T" typeOwner="XDBTEST" columns="4">
          <SQLAttributes columns="4">
            <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
            <SYS_XDBBODY type="VARCHAR2" columns="1"/>
            <DISPLAYNAME type="VARCHAR2" columns="1"/>
          </SQLAttributes>
        </RootType>
      </COMPONENTA_UNIQUENAME>
      <COMPONENTA_DESCRIPTION type="COMPONENTA_DESCRIPTION_T" owner="XDBTEST" columns="6">
        <RootType type="COMPONENTA_DESCRIPTION_T" typeOwner="XDBTEST" columns="4">
          <SQLAttributes columns="4">
            <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
            <SYS_XDBBODY type="VARCHAR2" columns="1"/>
            <DISPLAYNAME type="VARCHAR2" columns="1"/>
          </SQLAttributes>
        </RootType>
      </COMPONENTA_DESCRIPTION>
    </SQLAttributes>
    <ExtendedType type="COMPONENTB_T" typeOwner="XDBTEST" columns="30">
      <SQLAttributes columns="12">
        <COMPONENTB_CONTROLNUMBER type="COMPONENTB_CONTROLNUMBER_T" owner="XDBTEST" columns="6">
          <RootType type="COMPONENTB_CONTROLNUMBER_T" typeOwner="XDBTEST" columns="4">
            <SQLAttributes columns="4">
              <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
              <SYS_XDBBODY type="VARCHAR2" columns="1"/>
              <DISPLAYNAME type="VARCHAR2" columns="1"/>
            </SQLAttributes>
          </RootType>
        </COMPONENTB_CONTROLNUMBER>
        <COMPONENTB_COREFOLDER type="COMPONENTB_COREFOLDER_T" owner="XDBTEST" columns="6">
          <RootType type="COMPONENTB_COREFOLDER_T" typeOwner="XDBTEST" columns="4">
            <SQLAttributes columns="4">
              <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
              <SYS_XDBBODY type="VARCHAR2" columns="1"/>
              <DISPLAYNAME type="VARCHAR2" columns="1"/>
            </SQLAttributes>
          </RootType>
        </COMPONENTB_COREFOLDER>
      </SQLAttributes>
      <ExtendedType type="COMPONENTD_T" typeOwner="XDBTEST" columns="18">
        <SQLAttributes columns="18">
          <COMPONENTD_FINDINGTYPE type="COMPONENTD_FINDINGTYPE_T" owner="XDBTEST" columns="6">
            <RootType type="COMPONENTD_FINDINGTYPE_T" typeOwner="XDBTEST" columns="4">
              <SQLAttributes columns="4">
                <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
                <SYS_XDBBODY type="VARCHAR2" columns="1"/>
                <DISPLAYNAME type="VARCHAR2" columns="1"/>
              </SQLAttributes>
            </RootType>
          </COMPONENTD_FINDINGTYPE>
          <COMPONENTD_PRIORITY type="COMPONENTD_PRIORITY_T" owner="XDBTEST" columns="6">
            <RootType type="COMPONENTD_PRIORITY_T" typeOwner="XDBTEST" columns="4">
              <SQLAttributes columns="4">
                <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
                <SYS_XDBBODY type="VARCHAR2" columns="1"/>
                <DISPLAYNAME type="VARCHAR2" columns="1"/>
              </SQLAttributes>
            </RootType>
          </COMPONENTD_PRIORITY>
          <COMPONENTD_SUMMARY type="COMPONENTD_SUMMARY_T" owner="XDBTEST" columns="6">
            <RootType type="COMPONENTD_SUMMARY_T" typeOwner="XDBTEST" columns="4">
              <SQLAttributes columns="4">
                <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
                <SYS_XDBBODY type="VARCHAR2" columns="1"/>
                <DISPLAYNAME type="VARCHAR2" columns="1"/>
              </SQLAttributes>
            </RootType>
          </COMPONENTD_SUMMARY>
        </SQLAttributes>
      </ExtendedType>
    </ExtendedType>
    <ExtendedType type="COMPONENTC_T" typeOwner="XDBTEST" columns="6">
      <SQLAttributes columns="6">
        <COMPONENTC_CONTROLNUMBER type="COMPONENTC_CONTROLNUMBER_T" owner="XDBTEST" columns="6">
          <RootType type="COMPONENTC_CONTROLNUMBER_T" typeOwner="XDBTEST" columns="4">
            <SQLAttributes columns="4">
              <SYS_XDBPD collectionType="RAW" collectionOwner="" columns="2"/>
              <SYS_XDBBODY type="VARCHAR2" columns="1"/>
              <DISPLAYNAME type="VARCHAR2" columns="1"/>
            </SQLAttributes>
          </RootType>
        </COMPONENTC_CONTROLNUMBER>
      </SQLAttributes>
    </ExtendedType>
  </RootType>
</ComponentA>THis will tell you that a table based xml element of the complexType 'componentA' will have approx 50 columns..