create table t4k
as
with data as (
   select cast(rpad('0',2000,'0') as raw(2000)) r1 from dual
)
select  r1||r1 xxx
from data
where rownum = 0

I also came to the conclusion that sys_op_map_nonnull() is a bit of a red herring, though I had not thought much past that yet as to whether this might be intentional or a bug.

The explanation for the error “ORA-00910: specified length too long for its datatype” provides a clue that helps ferret out why this may be allowed.

[jkstill]$ oerr ora 910
00910, 00000, “specified length too long for its datatype”
// *Cause: for datatypes CHAR and RAW, the length specified was > 2000;
// otherwise, the length specified was > 4000.
// *Action: use a shorter length or switch to a datatype permitting a
// longer length such as a VARCHAR2, LONG CHAR, or LONG RAW

Notice that the length restriction pertains to CHAR as well as RAW data types.

Suspecting that that allowance for 4k data types might have been made for the data dictionary, I ran a query looking for CHAR and RAW data type columns with a length > 2000.

Output is edited for brevity:

select owner, table_name, column_name, data_type, data_length
from dba_tab_columns
where data_type in ('CHAR','RAW')
and data_length > 2000
order by 1,2,3
/


OWNER      TABLE NAME                     COLUMN     DATA_TYPE  DATA_LENGTH
---------- ------------------------------ ---------- ---------- -----------
JKSTILL    T4000                          XXX        RAW               4000
SYS        KU$_10_1_FHTABLE_VIEW          TSTZ_COLS  CHAR              4000
...
SYS        KU$_TABLE_DATA_VIEW            TSTZ_COLS  CHAR              4000

23 rows selected.

In this 11.2.0.3 database all of the columns that exceed the 2k limit belong to SYS and are all CHAR(4000), with the exception of the test table.
In addition, these are all views that are used to track columns that are of type TIMESTAMP WITH TIMEZONE.

Taking a look at how the view KU$_IOTABLE_DATA_VIEW is created (found in OH/rdbms/admin/catmeta.sql) it is seen that it and all the other views of interest here are created from object types, and use an inline view that selects from a funtion to create the TSTZ_COLS column:

  (select sys.dbms_metadata_util.has_tstz_cols(t.obj#) from dual)

A little test shows that uses the same method as seen in catmeta.sql to create a test view creates a view with a column of CHAR(4000).

create or replace type char_test_t as object
(
   tstz_test char(1)
)
/

create or replace function f return char
as
begin
   return 'Y';
end;
/

create or replace force view char_test of char_test_t
with object OID(1)
as select (select f from dual)
from dual
/

desc char_test

Nicely done. So it’s not a specific anomaly due to the use of sys_op_map_nonnull(), it’s a generic feature of a derived raw() value in a CTAS.

One last tiny, peripheral, touch – if you add ‘where rownum = 0′ to the create statement, table t4k still gets created with a column of type raw(4000), but with no data in it.

I traced both a standard create statement and the execute immediate create.

The trace for execute immedate revealed this:

PARSING IN CURSOR #47836159092840 len=4081 dep=1 uid=90 oct=1 lid=90 tim=1346458078205323 hv=2343315936 ad='aaa2dee8' sqlid='88qs6bf5usag0'
create table t4k as select sys_op_map_nonnull(sys_op_map_nonnull('000000' # truncated for brevity
END OF STMT
...
EXEC #47836159092840:c=69989,e=85539,p=0,cr=177,cu=85,mis=0,r=1,dep=1,og=1,plh=2781518217,tim=1346458078290968
STAT #47836159092840 id=1 cnt=0 pid=0 pos=1 obj=0 op='LOAD AS SELECT  (cr=113 pr=0 pw=1 time=36322 us)'
STAT #47836159092840 id=2 cnt=1 pid=1 pos=1 obj=0 op='FAST DUAL  (cr=0 pr=0 pw=0 time=7 us cost=2 size=0 card=1)'
CLOSE #47836159092840:c=0,e=8,dep=1,type=0,tim=1346458078291140

The LOAD AS keywords indicate a direct path load.
Direct path load is what is used by CTAS, so here is a method to create the table directly as DDL:

drop table t4k;

create table t4k
as
with data as (
   select
      cast(rpad('0',2000,'0') as raw(2000)) r1
      , cast(rpad('0',2000,'0') as raw(2000)) r2
   from dual
)
select  r1||r2 xxx
from data
/

desc t4k;

Not that I am expecting anyone to answer these directly, these are just the things that come to mind.

Here is a slight modification to the code to create the 4k RAW column.
Its only advantage it is quite a bit faster to run than the loop.
The trick is nested calls to sys_op_map_nonnull to add the extra 2 bytes.

drop table t4k purge;

declare
   r1 raw(2000);
   r2 raw(2000);
   v_sql varchar2(10000);
begin
    select cast(rpad('0',2000,'0') as raw(2000)) into r1 from dual;
    select cast(rpad('0',1998,'0') as raw(1998)) into r2 from dual;
    v_sql := 'create table t4k as select sys_op_map_nonnull(sys_op_map_nonnull(''' || r1||r2 || ''')) xxx from dual';
    dbms_output.put_line(v_sql);
    execute immediate v_sql;
end;
/

desc t4k

If you click on the “show source” icon in the comment the window expands to show the echoed output of a demonstration script. (You might want to add a “purge” to the drop table command.)

I ran it, and ended up with a table with a column of type raw(4000), and a block dump showed that the internal length of the newly inserted row was actually stored as 4,000 bytes – and yes, a simple “create table” won’t allow you to get past raw(2000).

Extraordinary – how do you manage to find such bizarre cases ?!

Connected to Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 
Connected as test_user
 
SQL> 
SQL> begin
  2    execute immediate 'create table t2001 as select sys_op_map_nonnull(cast(null as raw(2000))) xxx from dual';
  3    for i in 1 .. 1999 loop
  4      execute immediate 'create table t'||(2001+i)||' as select sys_op_map_nonnull(xxx) xxx from t'||(2000+i);
  5      execute immediate 'drop table t'||(2000+i);
  6    end loop;
  7  end;
  8  /
 
PL/SQL procedure successfully completed
 
SQL> select dbms_metadata.get_ddl('TABLE', 'T4000') from dual;
 
DBMS_METADATA.GET_DDL('TABLE',
--------------------------------------------------------------------------------
 
  CREATE TABLE "TEST_USER"."T4000" 
   (	"XXX" RAW(4000)
   ) SEGMENT CREATION IMMEDIATE 
  PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING
  STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645
  PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)
  TABLESPACE "USERS" 
 
 

SQL> declare
  2    raw4000 raw(4000) := hextoraw(lpad('0',8000,'0'));
  3  begin
  4    dbms_output.put_line(utl_raw.length(raw4000));
  5    insert into T4000 values (raw4000);
  6  end;
  7  /
 
PL/SQL procedure successfully completed
 
SQL> select utl_raw.length(xxx) from T4000;
 
UTL_RAW.LENGTH(XXX)
-------------------
               2000
               4000