// SYS . DUMMY Table

CREATE TABLE SYS.DUMMY (
   dummy_col                                      INTEGER NOT NULL );

// dbo . RowGenerator Table

CREATE TABLE dbo.RowGenerator (
   row_num                        /* PK        */ SMALLINT NOT NULL );

// ***** Primary Key for dbo.RowGenerator *****
ALTER TABLE dbo.RowGenerator ADD PRIMARY KEY (
   row_num );

// SYS . SYSARTICLE Table

CREATE TABLE SYS.SYSARTICLE (
   publication_id                 /* PK FK     */ SMALLINT NOT NULL,
   table_id                       /* PK FK     */ SMALLINT NOT NULL,
   where_expr                                     TEXT NULL,
   subscribe_by_expr                              TEXT NULL,
   query                                          CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSARTICLE *****
// SYS.SYSPUBLICATION
// SYS.SYSTABLE

// ***** Children of SYS.SYSARTICLE *****
// SYS.SYSARTICLECOL

// ***** Primary Key for SYS.SYSARTICLE *****
ALTER TABLE SYS.SYSARTICLE ADD PRIMARY KEY (
   publication_id,
   table_id );

// ***** Foreign Key from SYS.SYSARTICLE to Parent SYS.SYSPUBLICATION *****
ALTER TABLE SYS.SYSARTICLE ADD FOREIGN KEY SYSPUBLICATION (
      publication_id )
   REFERENCES SYS.SYSPUBLICATION (
      publication_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSARTICLE to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSARTICLE ADD FOREIGN KEY SYSTABLE (
      table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSARTICLECOL Table

CREATE TABLE SYS.SYSARTICLECOL (
   publication_id                 /* PK FK     */ SMALLINT NOT NULL,
   table_id                       /* PK FK     */ SMALLINT NOT NULL,
   column_id                      /* PK FK     */ SMALLINT NOT NULL );

// ***** Parents of SYS.SYSARTICLECOL *****
// SYS.SYSARTICLE
// SYS.SYSCOLUMN

// ***** Primary Key for SYS.SYSARTICLECOL *****
ALTER TABLE SYS.SYSARTICLECOL ADD PRIMARY KEY (
   publication_id,
   table_id,
   column_id );

// ***** Foreign Key from SYS.SYSARTICLECOL to Parent SYS.SYSARTICLE *****
ALTER TABLE SYS.SYSARTICLECOL ADD FOREIGN KEY SYSARTICLE (
      publication_id,
      table_id )
   REFERENCES SYS.SYSARTICLE (
      publication_id,
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSARTICLECOL to Parent SYS.SYSCOLUMN *****
ALTER TABLE SYS.SYSARTICLECOL ADD FOREIGN KEY SYSCOLUMN (
      table_id,
      column_id )
   REFERENCES SYS.SYSCOLUMN (
      table_id,
      column_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSCOLLATION Table

CREATE TABLE SYS.SYSCOLLATION (
   collation_id                   /* PK        */ SMALLINT NOT NULL,
   collation_label                                CHAR ( 10 ) NOT NULL,
   collation_name                                 CHAR ( 128 ) NOT NULL,
   collation_order                                BINARY ( 1280 ) NOT NULL );

// ***** Primary Key for SYS.SYSCOLLATION *****
ALTER TABLE SYS.SYSCOLLATION ADD PRIMARY KEY (
   collation_id );

// SYS . SYSCOLPERM Table

CREATE TABLE SYS.SYSCOLPERM (
   table_id                       /* PK FK     */ SMALLINT NOT NULL,
   grantee                        /* PK FK     */ SMALLINT NOT NULL,
   grantor                        /* PK FK     */ SMALLINT NOT NULL,
   column_id                      /* PK FK     */ SMALLINT NOT NULL,
   privilege_type                 /* PK        */ SMALLINT NOT NULL,
   is_grantable                                   CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSCOLPERM *****
// SYS.SYSCOLUMN
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSCOLPERM *****
ALTER TABLE SYS.SYSCOLPERM ADD PRIMARY KEY (
   table_id,
   grantee,
   grantor,
   column_id,
   privilege_type );

// ***** Foreign Key from SYS.SYSCOLPERM to Parent SYS.SYSCOLUMN *****
ALTER TABLE SYS.SYSCOLPERM ADD FOREIGN KEY SYSCOLUMN (
      table_id,
      column_id )
   REFERENCES SYS.SYSCOLUMN (
      table_id,
      column_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSCOLPERM to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSCOLPERM ADD FOREIGN KEY grantee (
      grantee )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSCOLPERM to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSCOLPERM ADD FOREIGN KEY grantor (
      grantor )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSCOLUMN Table

CREATE TABLE SYS.SYSCOLUMN (
   table_id                       /* PK FK     */ SMALLINT NOT NULL,
   column_id                      /* PK        */ SMALLINT NOT NULL,
   pkey                                           CHAR ( 1 ) NOT NULL,
   domain_id                      /*    FK     */ SMALLINT NOT NULL,
   nulls                                          CHAR ( 1 ) NOT NULL,
   width                                          SMALLINT NOT NULL,
   scale                                          SMALLINT NOT NULL,
   estimate                                       INTEGER NOT NULL,
   column_name                                    CHAR ( 128 ) NOT NULL,
   remarks                                        TEXT NULL,
   default                                        TEXT NULL,
   check                                          TEXT NULL,
   user_type                      /*    FK     */ SMALLINT NULL,
   format_str                                     CHAR ( 128 ) NULL );

// ***** Parents of SYS.SYSCOLUMN *****
// SYS.SYSDOMAIN
// SYS.SYSTABLE
// SYS.SYSUSERTYPE

// ***** Children of SYS.SYSCOLUMN *****
// SYS.SYSARTICLECOL
// SYS.SYSCOLPERM
// SYS.SYSFKCOL
// SYS.SYSIXCOL

// ***** Primary Key for SYS.SYSCOLUMN *****
ALTER TABLE SYS.SYSCOLUMN ADD PRIMARY KEY (
   table_id,
   column_id );

// ***** Foreign Key from SYS.SYSCOLUMN to Parent SYS.SYSDOMAIN *****
ALTER TABLE SYS.SYSCOLUMN ADD FOREIGN KEY SYSDOMAIN (
      domain_id )
   REFERENCES SYS.SYSDOMAIN (
      domain_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSCOLUMN to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSCOLUMN ADD FOREIGN KEY SYSTABLE (
      table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSCOLUMN to Parent SYS.SYSUSERTYPE *****
ALTER TABLE SYS.SYSCOLUMN ADD FOREIGN KEY SYSUSERTYPE (
      user_type )
   REFERENCES SYS.SYSUSERTYPE (
      type_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSDOMAIN Table

CREATE TABLE SYS.SYSDOMAIN (
   domain_id                      /* PK        */ SMALLINT NOT NULL,
   domain_name                                    CHAR ( 128 ) NOT NULL,
   type_id                                        SMALLINT NOT NULL,
   precision                                      SMALLINT NULL );

// ***** Children of SYS.SYSDOMAIN *****
// SYS.SYSCOLUMN
// SYS.SYSPROCPARM
// SYS.SYSTYPEMAP
// SYS.SYSUSERTYPE

// ***** Primary Key for SYS.SYSDOMAIN *****
ALTER TABLE SYS.SYSDOMAIN ADD PRIMARY KEY (
   domain_id );

// SYS . SYSEXTENT Table

CREATE TABLE SYS.SYSEXTENT (
   file_id                        /* PK FK     */ SMALLINT NOT NULL,
   extent_id                      /* PK        */ SMALLINT NOT NULL,
   first_page                                     INTEGER NOT NULL,
   last_page                                      INTEGER NOT NULL,
   file_name                                      TEXT NOT NULL );

// ***** Parents of SYS.SYSEXTENT *****
// SYS.SYSFILE

// ***** Primary Key for SYS.SYSEXTENT *****
ALTER TABLE SYS.SYSEXTENT ADD PRIMARY KEY (
   file_id,
   extent_id );

// ***** Foreign Key from SYS.SYSEXTENT to Parent SYS.SYSFILE *****
ALTER TABLE SYS.SYSEXTENT ADD FOREIGN KEY SYSFILE (
      file_id )
   REFERENCES SYS.SYSFILE (
      file_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSFILE Table

CREATE TABLE SYS.SYSFILE (
   file_id                        /* PK        */ SMALLINT NOT NULL,
   file_name                                      TEXT NOT NULL,
   dbspace_name                                   CHAR ( 128 ) NOT NULL );

// ***** Children of SYS.SYSFILE *****
// SYS.SYSEXTENT
// SYS.SYSTABLE

// ***** Primary Key for SYS.SYSFILE *****
ALTER TABLE SYS.SYSFILE ADD PRIMARY KEY (
   file_id );

// SYS . SYSFKCOL Table

CREATE TABLE SYS.SYSFKCOL (
   foreign_table_id               /* PK FK     */ SMALLINT NOT NULL,
   foreign_key_id                 /* PK FK     */ SMALLINT NOT NULL,
   foreign_column_id              /* PK FK     */ SMALLINT NOT NULL,
   primary_column_id                              SMALLINT NOT NULL );

// ***** Parents of SYS.SYSFKCOL *****
// SYS.SYSCOLUMN
// SYS.SYSFOREIGNKEY

// ***** Primary Key for SYS.SYSFKCOL *****
ALTER TABLE SYS.SYSFKCOL ADD PRIMARY KEY (
   foreign_table_id,
   foreign_key_id,
   foreign_column_id );

// ***** Foreign Key from SYS.SYSFKCOL to Parent SYS.SYSCOLUMN *****
ALTER TABLE SYS.SYSFKCOL ADD FOREIGN KEY SYSCOLUMN (
      foreign_table_id,
      foreign_column_id )
   REFERENCES SYS.SYSCOLUMN (
      table_id,
      column_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSFKCOL to Parent SYS.SYSFOREIGNKEY *****
ALTER TABLE SYS.SYSFKCOL ADD FOREIGN KEY SYSFOREIGNKEY (
      foreign_table_id,
      foreign_key_id )
   REFERENCES SYS.SYSFOREIGNKEY (
      foreign_table_id,
      foreign_key_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSFOREIGNKEY Table

CREATE TABLE SYS.SYSFOREIGNKEY (
   foreign_table_id               /* PK FK U   */ SMALLINT NOT NULL,
   foreign_key_id                 /* PK        */ SMALLINT NOT NULL,
   primary_table_id               /*    FK     */ SMALLINT NOT NULL,
   root                                           INTEGER NOT NULL,
   check_on_commit                                CHAR ( 1 ) NOT NULL,
   nulls                                          CHAR ( 1 ) NOT NULL,
   role                           /*       U   */ CHAR ( 128 ) NOT NULL,
   remarks                                        TEXT NULL );

// ***** Parents of SYS.SYSFOREIGNKEY *****
// SYS.SYSTABLE

// ***** Children of SYS.SYSFOREIGNKEY *****
// SYS.SYSFKCOL
// SYS.SYSTRIGGER

// ***** Primary Key for SYS.SYSFOREIGNKEY *****
ALTER TABLE SYS.SYSFOREIGNKEY ADD PRIMARY KEY (
   foreign_table_id,
   foreign_key_id );

// ***** Foreign Key from SYS.SYSFOREIGNKEY to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSFOREIGNKEY ADD FOREIGN KEY foreign_table (
      foreign_table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSFOREIGNKEY to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSFOREIGNKEY ADD FOREIGN KEY primary_table (
      primary_table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSFOREIGNKEY *****
CREATE UNIQUE INDEX role_name ON SYS.SYSFOREIGNKEY (
   role ASC,
   foreign_table_id ASC );

// SYS . SYSGROUP Table

CREATE TABLE SYS.SYSGROUP (
   group_id                       /* PK FK     */ SMALLINT NOT NULL,
   group_member                   /* PK FK     */ SMALLINT NOT NULL );

// ***** Parents of SYS.SYSGROUP *****
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSGROUP *****
ALTER TABLE SYS.SYSGROUP ADD PRIMARY KEY (
   group_id,
   group_member );

// ***** Foreign Key from SYS.SYSGROUP to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSGROUP ADD FOREIGN KEY group_id (
      group_id )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSGROUP to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSGROUP ADD FOREIGN KEY group_member (
      group_member )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSINDEX Table

CREATE TABLE SYS.SYSINDEX (
   table_id                       /* PK FK U   */ SMALLINT NOT NULL,
   index_id                       /* PK        */ SMALLINT NOT NULL,
   root                                           INTEGER NOT NULL,
   file_id                                        SMALLINT NOT NULL,
   unique                                         CHAR ( 1 ) NOT NULL,
   creator                        /*    FK     */ SMALLINT NOT NULL,
   index_name                     /*       U   */ CHAR ( 128 ) NOT NULL,
   remarks                                        TEXT NULL );

// ***** Parents of SYS.SYSINDEX *****
// SYS.SYSTABLE
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSINDEX *****
// SYS.SYSIXCOL

// ***** Primary Key for SYS.SYSINDEX *****
ALTER TABLE SYS.SYSINDEX ADD PRIMARY KEY (
   table_id,
   index_id );

// ***** Foreign Key from SYS.SYSINDEX to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSINDEX ADD FOREIGN KEY SYSTABLE (
      table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSINDEX to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSINDEX ADD FOREIGN KEY SYSUSERPERM (
      creator )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSINDEX *****
CREATE UNIQUE INDEX index_name ON SYS.SYSINDEX (
   index_name ASC,
   table_id ASC );

// SYS . SYSINFO Table

CREATE TABLE SYS.SYSINFO (
   page_size                                      SMALLINT NOT NULL,
   encryption                                     CHAR ( 1 ) NOT NULL,
   blank_padding                                  CHAR ( 1 ) NOT NULL,
   case_sensitivity                               CHAR ( 1 ) NOT NULL,
   default_collation                              CHAR ( 10 ) NULL,
   database_version                               SMALLINT NOT NULL );

// SYS . SYSIXCOL Table

CREATE TABLE SYS.SYSIXCOL (
   table_id                       /* PK FK     */ SMALLINT NOT NULL,
   index_id                       /* PK FK     */ SMALLINT NOT NULL,
   sequence                       /* PK        */ SMALLINT NOT NULL,
   column_id                      /*    FK     */ SMALLINT NOT NULL,
   order                                          CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSIXCOL *****
// SYS.SYSCOLUMN
// SYS.SYSINDEX

// ***** Primary Key for SYS.SYSIXCOL *****
ALTER TABLE SYS.SYSIXCOL ADD PRIMARY KEY (
   table_id,
   index_id,
   sequence );

// ***** Foreign Key from SYS.SYSIXCOL to Parent SYS.SYSCOLUMN *****
ALTER TABLE SYS.SYSIXCOL ADD FOREIGN KEY SYSCOLUMN (
      table_id,
      column_id )
   REFERENCES SYS.SYSCOLUMN (
      table_id,
      column_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSIXCOL to Parent SYS.SYSINDEX *****
ALTER TABLE SYS.SYSIXCOL ADD FOREIGN KEY SYSINDEX (
      table_id,
      index_id )
   REFERENCES SYS.SYSINDEX (
      table_id,
      index_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSLOGIN Table

CREATE TABLE SYS.SYSLOGIN (
   integrated_login_id            /* PK        */ CHAR ( 128 ) NOT NULL,
   login_uid                      /*    FK     */ SMALLINT NOT NULL,
   remarks                                        TEXT NULL );

// ***** Parents of SYS.SYSLOGIN *****
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSLOGIN *****
ALTER TABLE SYS.SYSLOGIN ADD PRIMARY KEY (
   integrated_login_id );

// ***** Foreign Key from SYS.SYSLOGIN to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSLOGIN ADD FOREIGN KEY SYSUSERPERM (
      login_uid )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSOPTION Table

CREATE TABLE SYS.SYSOPTION (
   user_id                        /* PK FK     */ SMALLINT NOT NULL,
   option                         /* PK        */ CHAR ( 128 ) NOT NULL,
   setting                                        TEXT NOT NULL );

// ***** Parents of SYS.SYSOPTION *****
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSOPTION *****
ALTER TABLE SYS.SYSOPTION ADD PRIMARY KEY (
   user_id,
   option );

// ***** Foreign Key from SYS.SYSOPTION to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSOPTION ADD FOREIGN KEY SYSUSERPERM (
      user_id )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSPROCEDURE Table

CREATE TABLE SYS.SYSPROCEDURE (
   proc_id                        /* PK        */ SMALLINT NOT NULL,
   creator                        /*    FK U   */ SMALLINT NOT NULL,
   proc_name                      /*       U   */ CHAR ( 128 ) NOT NULL,
   proc_defn                                      TEXT NULL,
   remarks                                        TEXT NULL,
   replicate                                      CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSPROCEDURE *****
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSPROCEDURE *****
// SYS.SYSPROCPARM
// SYS.SYSPROCPERM

// ***** Primary Key for SYS.SYSPROCEDURE *****
ALTER TABLE SYS.SYSPROCEDURE ADD PRIMARY KEY (
   proc_id );

// ***** Foreign Key from SYS.SYSPROCEDURE to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSPROCEDURE ADD FOREIGN KEY SYSUSERPERM (
      creator )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSPROCEDURE *****
CREATE UNIQUE INDEX procedure_name ON SYS.SYSPROCEDURE (
   proc_name ASC,
   creator ASC );

// SYS . SYSPROCPARM Table

CREATE TABLE SYS.SYSPROCPARM (
   proc_id                        /* PK FK     */ SMALLINT NOT NULL,
   parm_id                        /* PK        */ SMALLINT NOT NULL,
   parm_type                                      SMALLINT NOT NULL,
   parm_mode_in                                   CHAR ( 1 ) NOT NULL,
   parm_mode_out                                  CHAR ( 1 ) NOT NULL,
   domain_id                      /*    FK     */ SMALLINT NOT NULL,
   width                                          SMALLINT NOT NULL,
   scale                                          SMALLINT NOT NULL,
   parm_name                                      CHAR ( 128 ) NOT NULL,
   remarks                                        TEXT NULL,
   default                                        TEXT NULL );

// ***** Parents of SYS.SYSPROCPARM *****
// SYS.SYSDOMAIN
// SYS.SYSPROCEDURE

// ***** Primary Key for SYS.SYSPROCPARM *****
ALTER TABLE SYS.SYSPROCPARM ADD PRIMARY KEY (
   proc_id,
   parm_id );

// ***** Foreign Key from SYS.SYSPROCPARM to Parent SYS.SYSDOMAIN *****
ALTER TABLE SYS.SYSPROCPARM ADD FOREIGN KEY SYSDOMAIN (
      domain_id )
   REFERENCES SYS.SYSDOMAIN (
      domain_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSPROCPARM to Parent SYS.SYSPROCEDURE *****
ALTER TABLE SYS.SYSPROCPARM ADD FOREIGN KEY SYSPROCEDURE (
      proc_id )
   REFERENCES SYS.SYSPROCEDURE (
      proc_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSPROCPERM Table

CREATE TABLE SYS.SYSPROCPERM (
   proc_id                        /* PK FK     */ SMALLINT NOT NULL,
   grantee                        /* PK FK     */ SMALLINT NOT NULL );

// ***** Parents of SYS.SYSPROCPERM *****
// SYS.SYSPROCEDURE
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSPROCPERM *****
ALTER TABLE SYS.SYSPROCPERM ADD PRIMARY KEY (
   proc_id,
   grantee );

// ***** Foreign Key from SYS.SYSPROCPERM to Parent SYS.SYSPROCEDURE *****
ALTER TABLE SYS.SYSPROCPERM ADD FOREIGN KEY SYSPROCEDURE (
      proc_id )
   REFERENCES SYS.SYSPROCEDURE (
      proc_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSPROCPERM to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSPROCPERM ADD FOREIGN KEY SYSUSERPERM (
      grantee )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSPUBLICATION Table

CREATE TABLE SYS.SYSPUBLICATION (
   publication_id                 /* PK        */ SMALLINT NOT NULL,
   creator                        /*    FK U   */ SMALLINT NOT NULL,
   publication_name               /*       U   */ CHAR ( 128 ) NOT NULL,
   remarks                                        TEXT NULL );

// ***** Parents of SYS.SYSPUBLICATION *****
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSPUBLICATION *****
// SYS.SYSARTICLE
// SYS.SYSSUBSCRIPTION

// ***** Primary Key for SYS.SYSPUBLICATION *****
ALTER TABLE SYS.SYSPUBLICATION ADD PRIMARY KEY (
   publication_id );

// ***** Foreign Key from SYS.SYSPUBLICATION to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSPUBLICATION ADD FOREIGN KEY SYSUSERPERM (
      creator )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSPUBLICATION *****
CREATE UNIQUE INDEX publication_name ON SYS.SYSPUBLICATION (
   publication_name ASC,
   creator ASC );

// SYS . SYSREMOTETYPE Table

CREATE TABLE SYS.SYSREMOTETYPE (
   type_id                        /* PK        */ SMALLINT NOT NULL,
   type_name                      /*       U   */ CHAR ( 128 ) NOT NULL,
   publisher_address                              TEXT NOT NULL,
   remarks                                        TEXT NULL );

// ***** Children of SYS.SYSREMOTETYPE *****
// SYS.SYSREMOTEUSER

// ***** Primary Key for SYS.SYSREMOTETYPE *****
ALTER TABLE SYS.SYSREMOTETYPE ADD PRIMARY KEY (
   type_id );

// ***** Unique Index for SYS.SYSREMOTETYPE *****
CREATE UNIQUE INDEX remote_type ON SYS.SYSREMOTETYPE (
   type_name ASC );

// SYS . SYSREMOTEUSER Table

CREATE TABLE SYS.SYSREMOTEUSER (
   user_id                        /* PK FK     */ SMALLINT NOT NULL,
   consolidate                                    CHAR ( 1 ) NOT NULL,
   type_id                        /*    FK U   */ SMALLINT NOT NULL,
   address                        /*       U   */ TEXT NOT NULL,
   frequency                      /*         X */ CHAR ( 1 ) NOT NULL,
   send_time                      /*         X */ TIME NULL,
   log_send                                       NUMERIC ( 20 ) NOT NULL,
   time_sent                                      DATETIME NULL,
   log_sent                                       NUMERIC ( 20 ) NOT NULL,
   confirm_sent                                   NUMERIC ( 20 ) NOT NULL,
   send_count                                     INTEGER NOT NULL,
   resend_count                                   INTEGER NOT NULL,
   time_received                                  DATETIME NULL,
   log_received                                   NUMERIC ( 20 ) NOT NULL,
   confirm_received                               NUMERIC ( 20 ) NULL,
   receive_count                                  INTEGER NOT NULL,
   rereceive_count                                INTEGER NOT NULL );

// ***** Parents of SYS.SYSREMOTEUSER *****
// SYS.SYSREMOTETYPE
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSREMOTEUSER *****
// SYS.SYSSUBSCRIPTION

// ***** Primary Key for SYS.SYSREMOTEUSER *****
ALTER TABLE SYS.SYSREMOTEUSER ADD PRIMARY KEY (
   user_id );

// ***** Foreign Key from SYS.SYSREMOTEUSER to Parent SYS.SYSREMOTETYPE *****
ALTER TABLE SYS.SYSREMOTEUSER ADD FOREIGN KEY SYSREMOTETYPE (
      type_id )
   REFERENCES SYS.SYSREMOTETYPE (
      type_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSREMOTEUSER to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSREMOTEUSER ADD FOREIGN KEY SYSUSERPERM (
      user_id )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSREMOTEUSER *****
CREATE UNIQUE INDEX remote_address ON SYS.SYSREMOTEUSER (
   type_id ASC,
   address ASC );

// ***** Non-Unique Index for SYS.SYSREMOTEUSER *****
CREATE INDEX remote_frequency ON SYS.SYSREMOTEUSER (
   frequency ASC,
   send_time ASC );

// SYS . SYSSQLSERVERTYPE Table

CREATE TABLE SYS.SYSSQLSERVERTYPE (
   ss_user_type                   /* PK        */ SMALLINT NOT NULL,
   ss_domain_id                                   SMALLINT NOT NULL,
   ss_type_name                                   VARCHAR ( 30 ) NOT NULL,
   primary_sa_domain_id                           SMALLINT NOT NULL,
   primary_sa_user_type                           SMALLINT NULL );

// ***** Primary Key for SYS.SYSSQLSERVERTYPE *****
ALTER TABLE SYS.SYSSQLSERVERTYPE ADD PRIMARY KEY (
   ss_user_type );

// SYS . SYSSUBSCRIPTION Table

CREATE TABLE SYS.SYSSUBSCRIPTION (
   publication_id                 /* PK FK     */ SMALLINT NOT NULL,
   user_id                        /* PK FK     */ SMALLINT NOT NULL,
   subscribe_by                   /* PK        */ CHAR ( 128 ) NOT NULL,
   created                                        NUMERIC ( 20 ) NOT NULL,
   started                                        NUMERIC ( 20 ) NULL );

// ***** Parents of SYS.SYSSUBSCRIPTION *****
// SYS.SYSPUBLICATION
// SYS.SYSREMOTEUSER

// ***** Primary Key for SYS.SYSSUBSCRIPTION *****
ALTER TABLE SYS.SYSSUBSCRIPTION ADD PRIMARY KEY (
   publication_id,
   user_id,
   subscribe_by );

// ***** Foreign Key from SYS.SYSSUBSCRIPTION to Parent SYS.SYSPUBLICATION *****
ALTER TABLE SYS.SYSSUBSCRIPTION ADD FOREIGN KEY SYSPUBLICATION (
      publication_id )
   REFERENCES SYS.SYSPUBLICATION (
      publication_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSSUBSCRIPTION to Parent SYS.SYSREMOTEUSER *****
ALTER TABLE SYS.SYSSUBSCRIPTION ADD FOREIGN KEY SYSREMOTEUSER (
      user_id )
   REFERENCES SYS.SYSREMOTEUSER (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSTABLE Table

CREATE TABLE SYS.SYSTABLE (
   table_id                       /* PK        */ SMALLINT NOT NULL,
   file_id                        /*    FK     */ SMALLINT NOT NULL,
   count                                          INTEGER NOT NULL,
   first_page                                     INTEGER NOT NULL,
   last_page                                      INTEGER NOT NULL,
   primary_root                                   INTEGER NOT NULL,
   creator                        /*    FK U   */ SMALLINT NOT NULL,
   table_name                     /*       U   */ CHAR ( 128 ) NOT NULL,
   table_type                                     CHAR ( 10 ) NOT NULL,
   view_def                                       TEXT NULL,
   remarks                                        TEXT NULL,
   replicate                                      CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSTABLE *****
// SYS.SYSFILE
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSTABLE *****
// SYS.SYSARTICLE
// SYS.SYSCOLUMN
// SYS.SYSFOREIGNKEY
// SYS.SYSINDEX
// SYS.SYSTABLEPERM
// SYS.SYSTRIGGER

// ***** Primary Key for SYS.SYSTABLE *****
ALTER TABLE SYS.SYSTABLE ADD PRIMARY KEY (
   table_id );

// ***** Foreign Key from SYS.SYSTABLE to Parent SYS.SYSFILE *****
ALTER TABLE SYS.SYSTABLE ADD FOREIGN KEY SYSFILE (
      file_id )
   REFERENCES SYS.SYSFILE (
      file_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSTABLE to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSTABLE ADD FOREIGN KEY SYSUSERPERM (
      creator )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSTABLE *****
CREATE UNIQUE INDEX table_name ON SYS.SYSTABLE (
   table_name ASC,
   creator ASC );

// SYS . SYSTABLEPERM Table

CREATE TABLE SYS.SYSTABLEPERM (
   stable_id                      /* PK FK     */ SMALLINT NOT NULL,
   grantee                        /* PK FK     */ SMALLINT NOT NULL,
   grantor                        /* PK FK     */ SMALLINT NOT NULL,
   ttable_id                      /*    FK     */ SMALLINT NOT NULL,
   selectauth                                     CHAR ( 1 ) NOT NULL,
   insertauth                                     CHAR ( 1 ) NOT NULL,
   deleteauth                                     CHAR ( 1 ) NOT NULL,
   updateauth                                     CHAR ( 1 ) NOT NULL,
   updatecols                                     CHAR ( 1 ) NOT NULL,
   alterauth                                      CHAR ( 1 ) NOT NULL,
   referenceauth                                  CHAR ( 1 ) NOT NULL );

// ***** Parents of SYS.SYSTABLEPERM *****
// SYS.SYSTABLE
// SYS.SYSUSERPERM

// ***** Primary Key for SYS.SYSTABLEPERM *****
ALTER TABLE SYS.SYSTABLEPERM ADD PRIMARY KEY (
   stable_id,
   grantee,
   grantor );

// ***** Foreign Key from SYS.SYSTABLEPERM to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSTABLEPERM ADD FOREIGN KEY future (
      ttable_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSTABLEPERM to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSTABLEPERM ADD FOREIGN KEY SYSTABLE (
      stable_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSTABLEPERM to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSTABLEPERM ADD FOREIGN KEY grantee (
      grantee )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSTABLEPERM to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSTABLEPERM ADD FOREIGN KEY grantor (
      grantor )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSTRIGGER Table

CREATE TABLE SYS.SYSTRIGGER (
   trigger_id                     /* PK        */ SMALLINT NOT NULL,
   table_id                       /*    FK U   */ SMALLINT NOT NULL,
   event                          /*       U   */ CHAR ( 1 ) NOT NULL,
   trigger_time                   /*       U   */ CHAR ( 1 ) NOT NULL,
   trigger_order                  /*       U   */ SMALLINT NULL,
   foreign_table_id               /*    FK U   */ SMALLINT NULL,
   foreign_key_id                 /*    FK U   */ SMALLINT NULL,
   referential_action                             CHAR ( 1 ) NULL,
   trigger_name                   /*       U   */ CHAR ( 128 ) NULL,
   trigger_defn                                   TEXT NOT NULL,
   remarks                                        TEXT NULL );

// ***** Parents of SYS.SYSTRIGGER *****
// SYS.SYSFOREIGNKEY
// SYS.SYSTABLE

// ***** Primary Key for SYS.SYSTRIGGER *****
ALTER TABLE SYS.SYSTRIGGER ADD PRIMARY KEY (
   trigger_id );

// ***** Foreign Key from SYS.SYSTRIGGER to Parent SYS.SYSFOREIGNKEY *****
ALTER TABLE SYS.SYSTRIGGER ADD FOREIGN KEY SYSFOREIGNKEY (
      foreign_table_id,
      foreign_key_id )
   REFERENCES SYS.SYSFOREIGNKEY (
      foreign_table_id,
      foreign_key_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSTRIGGER to Parent SYS.SYSTABLE *****
ALTER TABLE SYS.SYSTRIGGER ADD FOREIGN KEY SYSTABLE (
      table_id )
   REFERENCES SYS.SYSTABLE (
      table_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Index for SYS.SYSTRIGGER *****
CREATE UNIQUE INDEX trigger_index ON SYS.SYSTRIGGER (
   table_id ASC,
   event ASC,
   trigger_time ASC,
   trigger_order ASC );

// ***** Unique Index for SYS.SYSTRIGGER *****
CREATE UNIQUE INDEX trigger_name ON SYS.SYSTRIGGER (
   trigger_name ASC );

// ***** Unique Index for SYS.SYSTRIGGER *****
CREATE UNIQUE INDEX trigger_referential_actions ON SYS.SYSTRIGGER (
   table_id ASC,
   foreign_table_id ASC,
   foreign_key_id ASC,
   event ASC );

// SYS . SYSTYPEMAP Table

CREATE TABLE SYS.SYSTYPEMAP (
   ss_user_type                                   SMALLINT NOT NULL,
   sa_domain_id                   /*    FK     */ SMALLINT NOT NULL,
   sa_user_type                                   SMALLINT NULL,
   nullable                                       CHAR ( 1 ) NULL );

// ***** Parents of SYS.SYSTYPEMAP *****
// SYS.SYSDOMAIN

// ***** Foreign Key from SYS.SYSTYPEMAP to Parent SYS.SYSDOMAIN *****
ALTER TABLE SYS.SYSTYPEMAP ADD FOREIGN KEY SYSDOMAIN (
      sa_domain_id )
   REFERENCES SYS.SYSDOMAIN (
      domain_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// SYS . SYSUSERMESSAGES Table

CREATE TABLE SYS.SYSUSERMESSAGES (
   error                          /*       U   */ INTEGER NOT NULL,
   uid                                            SMALLINT NOT NULL,
   description                                    VARCHAR ( 255 ) NOT NULL,
   langid                         /*       U   */ SMALLINT NOT NULL );

// ***** Unique Constraint for SYS.SYSUSERMESSAGES *****
ALTER TABLE SYS.SYSUSERMESSAGES ADD UNIQUE (
   error,
   langid );

// SYS . SYSUSERPERM Table

CREATE TABLE SYS.SYSUSERPERM (
   user_id                        /* PK        */ SMALLINT NOT NULL,
   user_name                      /*       U   */ CHAR ( 128 ) NOT NULL,
   password                                       BINARY ( 36 ) NULL,
   resourceauth                                   CHAR ( 1 ) NOT NULL,
   dbaauth                                        CHAR ( 1 ) NOT NULL,
   scheduleauth                                   CHAR ( 1 ) NOT NULL,
   publishauth                                    CHAR ( 1 ) NOT NULL,
   remotedbaauth                                  CHAR ( 1 ) NOT NULL,
   user_group                                     CHAR ( 1 ) NOT NULL,
   remarks                                        TEXT NULL );

// ***** Children of SYS.SYSUSERPERM *****
// SYS.SYSCOLPERM
// SYS.SYSGROUP
// SYS.SYSINDEX
// SYS.SYSLOGIN
// SYS.SYSOPTION
// SYS.SYSPROCEDURE
// SYS.SYSPROCPERM
// SYS.SYSPUBLICATION
// SYS.SYSREMOTEUSER
// SYS.SYSTABLE
// SYS.SYSTABLEPERM
// SYS.SYSUSERTYPE

// ***** Primary Key for SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSUSERPERM ADD PRIMARY KEY (
   user_id );

// ***** Unique Index for SYS.SYSUSERPERM *****
CREATE UNIQUE INDEX user_name ON SYS.SYSUSERPERM (
   user_name ASC );

// SYS . SYSUSERTYPE Table

CREATE TABLE SYS.SYSUSERTYPE (
   type_id                        /* PK        */ SMALLINT NOT NULL,
   creator                        /*    FK     */ SMALLINT NOT NULL,
   domain_id                      /*    FK     */ SMALLINT NOT NULL,
   nulls                                          CHAR ( 1 ) NOT NULL,
   width                                          SMALLINT NOT NULL,
   scale                                          SMALLINT NOT NULL,
   type_name                      /*       U   */ CHAR ( 128 ) NOT NULL,
   default                                        TEXT NULL,
   check                                          TEXT NULL,
   format_str                                     CHAR ( 128 ) NULL );

// ***** Parents of SYS.SYSUSERTYPE *****
// SYS.SYSDOMAIN
// SYS.SYSUSERPERM

// ***** Children of SYS.SYSUSERTYPE *****
// SYS.SYSCOLUMN

// ***** Primary Key for SYS.SYSUSERTYPE *****
ALTER TABLE SYS.SYSUSERTYPE ADD PRIMARY KEY (
   type_id );

// ***** Foreign Key from SYS.SYSUSERTYPE to Parent SYS.SYSDOMAIN *****
ALTER TABLE SYS.SYSUSERTYPE ADD FOREIGN KEY SYSDOMAIN (
      domain_id )
   REFERENCES SYS.SYSDOMAIN (
      domain_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Foreign Key from SYS.SYSUSERTYPE to Parent SYS.SYSUSERPERM *****
ALTER TABLE SYS.SYSUSERTYPE ADD FOREIGN KEY SYSUSERPERM (
      creator )
   REFERENCES SYS.SYSUSERPERM (
      user_id ) ON UPDATE RESTRICT ON DELETE RESTRICT 

// ***** Unique Constraint for SYS.SYSUSERTYPE *****
ALTER TABLE SYS.SYSUSERTYPE ADD UNIQUE (
   type_name );