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

Question

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?

Answer 1

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