View source for SQL Data Definition Language (DDL)

This topic describes the characteristics of the Model 204 SQL Data Definition Language (DDL). DDL statements are SQL statements that are used to maintain the SQL catalog by creating and altering table, view, and column definitions that describe Model 204 file data. DDL also includes SQL GRANT and REVOKE statements that define the security associated with SQL tables, views, and columns. 
<p>
Emphasis in this topic is on the characteristics of Model 204 SQL DDL that differ from the ANSI SQL 1989 standard DDL. Unless otherwise specified, references to "the standard" in this topic are to the ANSI SQL 1989 standard. </p>
<p>
The description of the Model 204 SQL DDL is organized by function (creating, altering, dropping, and granting), including basic syntax for the statements that perform each function. </p>
<p>
A diagram of the entire Model 204 SQL DDL statement syntax is found in [[SQL DDL syntax]].</p>

==Model 204 SQL DDL statements==
<p>
The following table identifies the DDL statements that can be processed against CCACAT, the SQL catalog file. Each statement is discussed in this topic.</p>
<p>
The statements in the table affect only the SQL catalog file. Model 204 database files other than CCACAT are never affected by these statements. </p>
<p>
The second column of the table explains the effect of each of the statements on the SQL catalog records. The catalog has the following record types:   </p>
<ul>
<li>SCHEMA (S)</li>
<li>TABLE
<ul>
<li>TABLE (T)</li>
<li> TABLE (V) </li>
</ul></li>
<li>PRIVILEGE (P)</li>
<li>CONSTRAINT (C)</li>
</ul>

<p class="note"><b>Note:</b> TABLE has two subtypes: TABLE(T) for tables and TABLE(V) for views.</p>
<p class="caption">Effects of DDL statements</p>
<div id="EffectsDDLstatements"></div>
<table>
<tr>
<th>DDL statement</th>
<th>Effect on CCACAT</th>
</tr>
<tr>
<td>CREATE SCHEMA</td>
<td>Adds a SCHEMA record if none is already present.</td>
</tr>
<tr>
<td>CREATE TABLE</td>
<td>Adds a TABLE(T) record and possibly CONSTRAINT records for multicolumn unique indexes, if present.
<p>Adds PRIVILEGE records for the table owner. </p></td>
</tr>
<tr>
<td>CREATE VIEW</td>
<td>Adds a TABLE(V) record and adds PRIVILEGE records for the view owner.</td>
</tr>
<tr>
<td>GRANT</td>
<td>Adds or updates one or more PRIVILEGE records.
<p>If no column list, number of records is: </p>
<p><code>no.-of-grantees * no.-of-privileges</code></p>
<p>If a column list, number of records is: </p>
<p><code>no.-of-grantees * (no.-of-privileges-without-lists + no.-of-columns)</code></p>
</td>
</tr>
<tr>
<td>SET SCHEMA</td>
<td>None.</td>
</tr>
<tr>
<td>SET USER</td>
<td>None.</td>
</tr>
<tr>
<td>DROP SCHEMA</td>
<td>Physically deletes SCHEMA record and all TABLE, VIEW, PRIVILEGE, and CONSTRAINT records for objects associated with this schema.</td>
</tr>
<tr>
<td>DROP TABLE</td>
<td>Physically deletes TABLE(T) record and all PRIVILEGE and CONSTRAINT records associated with this table.
<p>
If a parent table, it cannot be dropped before nested tables associated with it are dropped.</p>
<p>
No effect on TABLE(V) records that reference this table: view definitions involving this table are left intact.</p>
</td>
</tr>
<tr>
<td>DROP VIEW</td>
<td>Physically deletes the TABLE(V) record and all PRIVILEGE records for the view.</td>
</tr>
<tr><td>ALTER TABLE
<p>&nbsp;&nbsp;&nbsp;&nbsp;ADD</p>   
<p>&nbsp;&nbsp;&nbsp;&nbsp;DROP</p>   
<p>&nbsp;&nbsp;</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;MODIFY</p></td>
<td>Cannot be used against views, so no effect on TABLE(V) records.
<p>Adds COLUMN occurrence group to existing TABLE(T) record.</p>
<p>Deletes COLUMN occurrence group from existing TABLE(T) record. Deletes PRIVILEGE record(s) that reference this column. <br>No effect on CONSTRAINT records because DROP is not allowed for columns that are part of multi-column unique constraints.</p>
<p>Updates column occurrence group on existing TABLE(T) record.<BR>
No effect on CONSTRAINT records, because MODIFY is not allowed for constrained columns. </p>
</td>
</tr>
<tr>
<td>REVOKE</td>
<td>Updates or deletes existing PRIVILEGE records.</td>
</tr>
</TABLE>

===Model 204 SQL DDL extensions===
<p>In addition to the statements in [[#EffectsDDLstatements|Effects of DDL statements]], Model 204 SQL DDL includes the extensions listed in the following table.</p>
<table>
<p class="caption">DDL extensions</p>
<th>Extension</th>
<th>Statement</th>
<th>Description</th>
<tr>
<td>NESTED USING clause</td>
<td>CREATE TABLE</td>
<td>Defines the table as nested within a parent table and specifies the joining column. Used for mapping Model 204 files with repeating fields or repeating groups of fields.</td>
</tr>
<tr>
<td>REFERENCES clause</td>
<td>CREATE TABLE</td>
<td>Syntax as part of an optional referential constraint definition is the same as defined in the standard. Its extended functionality in Model 204 SQL DDL is that it is <b>required</b> in any nested table definition, it is ignored for non-nested tables, and it implies a CASCADE action.</td>
</tr>
<tr>
<td>SYSNAME clause</td>
<td>CREATE TABLE</td>
<td>Identifies the actual name of the Model 204 file or field associated with the SQL table or column being defined. For more information, see [[#Mapping table names to file names|Mapping table names to file names]] and [[#Column naming and the SYSNAME extension|Column naming and the SYSNAME extension]].</td>
</tr>
<tr>
<td>SYSTEM clause</td>
<td>CREATE TABLE</td>
<td>Used in column definition with the PRIMARY KEY option to provide a system-generated primary key. For more information, see [[#Using system-generated keys|Using system-generated keys]].</td>
</tr>
<tr>
<td colspan="2">SET USER statement</td>
<td>Sets SQL authorization ID without affecting Model 204 login ID, which allows a system manager to create SQL objects for another user without having to login as that user or give that user system manager privileges.</td>
</tr>
</table>

==Creating SQL objects==
<p>
SQL objects (tables, columns, and views) are created with the CREATE statement in the context of a schema. The Model 204 SQL syntax for CREATE SCHEMA is shown in [[#Creating schemas|Creating schemas]].</p>
<p>
This section introduces the descriptions of the Model 204 SQL DDL statements with which you define SQL objects: </p>
<code>CREATE SCHEMA <br>
CREATE TABLE<br>
CREATE VIEW</code>

<p class="note"><b>Note:</b> The use and function of the DDL statements in this topic conform to the standard except where otherwise specified.</p>

===Authorization ID is equivalent to Model 204 user ID===
<p>
You establish yourself as a valid SQL user by logging in to Model 204 with the LOGIN command. You are verified as a valid SQL user by Model 204 login security and any external security package that is in effect. The Model 204 user ID you specify in the LOGIN command becomes the SQL user authorization ID used by various DDL statements in a Model 204 SQL session. This Model 204 login ID is also the value returned when an SQL DML query specifies the SQL keyword USER.          </p>
<p>
For more information about Model 204 login security, see [[Storing security information (CCASTAT)]].</p>

===Model 204 SQL table types===
Model 204 SQL DDL defines the following types of tables:
<ul>
<li><var class="term">Base tables</var> are SQL schema tables that map directly to Model 204 files and fields. Such tables are not defined in terms of any other tables. </li>
<li><var class="term">Views</var> are schema tables that map directly to SQL base tables or to other views. Base tables are created by CREATE TABLE; views are created by CREATE VIEW.    </li>
<li><var class="term">Nested tables</var> are base tables that have columns that map to Model 204 multiply occurring fields or groups of fields. A nested table is associated with a single base table <i>parent</i> by a unique table column key that joins the nested table to the parent table. Nested tables are a Model 204 SQL extension.</li>
</ul>

===Statement ordering is important===
You must create objects before they are referenced by other objects. For example, tables referenced by views must be created before the views that reference them.
<p>
Rocket Software recommends that you organize statements in a CREATE SCHEMA statement in the following order:</p>
<table>
<th>Order</th>
<th>Statement</th>
<th>Description</th>
<tr>
<td>1.</td>
<td>CREATE table statements</td>
<td>Parent tables, which cannot be nested, referenced in a NESTED clause must be defined before the nested table being created.</td>
</tr>
<tr>
<td>2.</td>
<td>CREATE view statements</td>
<td>Views referenced in other views must be created before the other views.</td>
</tr>
<tr>
<td>3.</td>
<td style="white-space:nowrap">GRANT statements (for tables and views)</td>
<td>Creating objects before objects that they reference causes a semantic error during compilation.</td>
</tr>
</table>

===Naming SQL objects===
The Model 204 SQL rules for naming SQL schemas, tables, views, and columns are the same as the standard SQL identifier rules: SQL object names can contain the characters A-Z, 0-9, or underscore, can have as many as 18 characters, and must begin with a letter. You cannot use embedded blanks or [[SQL reserved words]].

==Creating schemas==
<p>
Like tables and columns, schemas exist as distinct records in the SQL catalog that are created by CREATE SCHEMA. Unlike tables and columns, a schema does not map directly to a Model 204 file. </p>
<p>
This section focuses on the rules governing schema creation. </p>

===CREATE SCHEMA statement===
====Syntax====
<p class="syntax">CREATE SCHEMA {<span class="term">schemaname</span>
  | AUTHORIZATION <span class="term">authorization-id</span>
  | <span class="term">schemaname</span> AUTHORIZATION <span class="term">authorization-id</span>}
  [<span class="term">schema-element</span> ...]</p>

====Parameters====
where:
<ul>
<li><var class="term">schemaname</var> conforms to rules for an SQL identifier (see [[#Naming SQL objects|Naming SQL objects]]). <var class="term">schemaname</var> does not have to be explicitly specified. Examples in [[#Indicating schema name and owner|Indicating schema name and owner]] show how you can indicate the schema name.</li>
<li><var class="term">authorization-id</var> conforms to the rules for a Model 204 login user ID (no more than 10 characters and no underscore characters, must begin with an alphabetic character and must not contain certain character combinations). The authorization ID cannot be an [[SQL reserved words|SQL reserved word]]). </li>
<li><var class="term">schema-element</var> is one of the following:

<p class="syntax"><span class="term">table-definition</span> | <span class="term">view-definition</span> | <span class="term">privilege-definition</span></p>
<ul>
<li><var class="term">table-definition</var> as described in [[#Creating tables|Creating tables]]. </li>
<li><var class="term">view-definition</var> as described in [[#Creating views|Creating views]]. </li>
<li><var class="term">privilege-definition</var> as described in [[#GRANT statement|GRANT statement]] and [[#REVOKE statement|REVOKE statement]]. </li>
</ul>
</li>
</ul>

====Syntax rules====
The following CREATE SCHEMA syntax rules apply:
<ul>
<li>The schema name must be unique within the SQL catalog. </li>
<li>The default authorization ID is the Model 204 login user ID. </li>
<li>If the schema name is not specified, the schema name defaults to the authorization ID.</li>
<li>Issuing CREATE SCHEMA for a schema that already exists is an error.</li>
<li>Only a Model 204 system manager can issue CREATE SCHEMA. </li>
<li>You can create schemas that have no tables, views, or privileges. Such an empty schema can be defined first and populated later. For example, the following sequence is valid DDL:
<p class="code">CREATE SCHEMA S
CREATE SCHEMA P
CREATE SCHEMA SP </p></li>
</ul>

===Indicating schema name and owner===
<p>
Examples of schema creation with different CREATE SCHEMA formats follow. These examples show different ways to indicate the schema name and owner. You can choose whether to explicitly specify a schema name or to explicitly specify an authorization ID. </p>
<p>
In the following example, schema name is TED, schema owner is TED. If you specify no name, the default name is your authorization ID.</p>
<p class="code">CREATE SCHEMA AUTHORIZATION TED 
   CREATE TABLE S (...)
   CREATE TABLE P (...)
   CREATE TABLE SP (...) </p>
<p>
In the following example, schema name is MATERIAL_CONTROL, schema owner is MFTNG.</p>
<p class="code">CREATE SCHEMA MATERIAL_CONTROL AUTHORIZATION MFTNG 
   CREATE TABLE PARTS (...) 
   CREATE TABLE SHIPMENTS (...) </p>
<p>
In the following example, schema name is ACCOUNTS, schema owner defaults to the authorization ID of the issuing user. </p>
<p class="code">CREATE SCHEMA ACCOUNTS
   CREATE TABLE ACCOUNTS_PAYABLE (...)
   CREATE TABLE ACCOUNTS_RECEIVE (...) </p>
<p>
The schema name determined by a CREATE SCHEMA statement remains the default schema name, which is assigned to the SQL objects you define, until the CREATE SCHEMA transaction completes. For information about setting the default schema outside the context of a CREATE SCHEMA using the Model 204 SQL extension SET SCHEMA, see [[#Using SET SCHEMA|Using SET SCHEMA]].</p>

==Creating tables==
<p>
This section describes table creation syntax and considerations that apply generally to both nested and non-nested SQL tables. Information that is nested-table specific is presented in [[#Creating nested tables|Creating nested tables]]. The definition of columns for a table is described in [[#Defining columns|Defining columns]]. </p>
<p>
A slightly abridged version of the CREATE TABLE statement syntax that the Model 204 SQL Server supports is shown below. See [[SQL DDL syntax]] for the complete syntax. </p>

===CREATE TABLE statement===
====Syntax====
<p class="syntax">CREATE TABLE &lt;<span class="term">tablename</span>&gt;
 [ SYSNAME '<span class="term">filename</span>' | NESTED USING <span class="term">columname</span> ] 
 ( &lt;<span class="term">column-definition</span>&gt; | &lt;<span class="term">table-constraint-definition</span>&gt;
 [,&lt;<span class="term">column-definition</span>&gt; | &lt;<span class="term">table-constraint-definition</span>&gt; ]
  ...)</p>

====Parameters====

where:
<ul>
<li>
<var class="term">tablename</var> conforms to rules for an SQL identifier (see [[#Naming SQL objects|Naming SQL objects]]). See also [[#Prefixing the schema name to an SQL object|Prefixing the schema name to an SQL object]]. </li>
<li>SYSNAME '<var class="term">filename</var>' maps a table to a physical file; see [[#Mapping table names to file names|Mapping table names to file names]] for more detail. </li>
<li>
NESTED USING <var class="term">columname</var> is an extension that identifies a nested table. See [[#Creating nested tables|Creating nested tables]].</li>
<li>
<var class="term">column-definition</var> has the following syntax, as described in [[#Defining columns|Defining columns]].
<p class="syntax"><span class="term">columname</span> &lt;<span class="term">datatype</span>&gt; [SYSNAME '<span class="term">fieldname</span>']
  [&lt;<span class="term">column-constraint</span>&gt; ...]</p>
</li>
<li>
<var class="term">table-constraint-definition</var> has the following syntax:
<p class="syntax">{ UNIQUE  | PRIMARY KEY [ SYSTEM ] } ( &lt;<span class="term">column-list</span>&gt; ) 
[ SYSNAME '&lt;<span class="term">fieldname</span>&gt;' ]  
| FOREIGN KEY ( <span class="term">columname</span> ) REFERENCES <span class="term">parent-table-name</span>
[ &lt;<span class="term">referential-triggered-action</span>&gt; ]</p>
<ul>
<li>UNIQUE must map to a Model 204 ORDERED UNIQUE field. For discussion, see [[#Specifying a multicolumn UNIQUE key|Specifying a multicolumn UNIQUE key]].</li>
<li>PRIMARY KEY [SYSTEM], where SYSTEM is an extension with which you can have the Model 204 SQL Server generate and manage a unique primary key, as described in [[#Using system-generated keys|Using system-generated keys]].</li>
<li>SYSNAME '<i>fieldname</i>' maps a column to the named Model 204 field; see [[#Column naming and the SYSNAME extension|Column naming and the SYSNAME extension]].</li>
<li>FOREIGN KEY and REFERENCES clauses for defining referential integrity constraints are supported for nested tables only.</li>
</ul>
</li>
</ul>

====Syntax rules====
<p>
The CREATE TABLE syntax rules follow:</p>
<ul>
<li>The table name must be unique within a schema. </li>
<li>A table must have at least one column defined. </li>
<li>CHECK table constraint is not supported in Model 204 SQL. If you include a CHECK clause in your SQL DDL, it does not become part of the SQL catalog definition, although you receive no syntax error.   

<p>Model 204 SQL does support the WITH CHECK OPTION for views, however.</p></li>
</ul>

===Mapping table names to file names===
<p>
The SQL Server maps the table you define to a Model 204 file. Your CREATE TABLE statement determines both the name of the SQL table and the name of the Model 204 file to which the table is mapped. You can implicitly or explicitly identify the Model 204 file to which the table is mapped, or you can have Model 204 generate a unique file name. </p>
<p>
Implicitly identifying the file means mapping the table you name in the CREATE TABLE to a file with the same name. Explicitly identifying the file means mapping the table you name to a file that you specify with the keyword SYSNAME. Automatic system generation of the file name is based on your CREATE TABLE specification and is invoked by setting the Model 204 parameter SQLFILE. </p>
<p>
As shown in the following table, you indicate which of these file-naming options you want by whether you specify a SYSNAME clause in your CREATE TABLE statement and by your setting of the Model 204 SQLFILE parameter.  </p>
<p class="caption">Naming the corresponding Model 204 file</p>
<table>
<th>Method</th>
<th>Add SYSNAME filename to <br>CREATE TABLE tablename?</th>
<th>SQLFILE setting</th>
<th>Resulting file name</th>
<tr>
<td>Implicit</td>
<td>No</td>
<td>0</td>
<td><i>tablename</i></td>
</tr>
<tr>
<td>Explicit</td>
<td>Yes</td>
<td>0 or 1</td>
<td><i>filename</i></td>
</tr>
<tr>
<td>System generated</td>
<td>No</td>
<td>1</td>
<td>Uniquely determined by Model 204</td>
</tr>
</table>
<p>
The SYSNAME clause is an optional Model 204 extension. If you specify a SYSNAME value, that value is the file name to which your table is mapped. This is true <b>regardless</b> of the SQLFILE setting.</p>
<p>
SQLFILE is a Model 204 CCAIN parameter whose default setting of zero turns off system generation of file names. If the SQLFILE value is one, and no SYSNAME clause is specified, Model 204 generates a unique file name for the specified SQL table.</p>

====Processing file names====
<p>
File names you provide explicitly or implicitly are subject to Model 204 file naming rules.</p>
<p>
If you are implicitly naming a file (no SYSNAME, SQLFILE=0), the SQL table name you specify is assumed to be the name of the Model 204 file. If this table name does not conform to the Model 204 file naming rules, it is truncated and/or compressed to satisfy the Model 204 rules. (Model 204 file names cannot have more than eight characters, underscore characters, initial numbers, or certain character combinations.) </p>
<p>
This assumed name is recorded in the SQL catalog as the Model 204 file name. If the assumed name does not match an existing Model 204 file name, you get an error when your application queries the database with that file in the query. </p>
<p>
For example, with no SYSNAME and SQLFILE=0, Model 204 SQL maps the SQL table OUR_OLD_DATA to the Model 204 file OUROLDDA. </p>
<p>
If you identify the file explicitly with a SYSNAME clause, the name processing is simpler: if the name you specify in the SYSNAME clause is greater than eight characters, it is truncated to eight characters and stored in the catalog as the file name. Any violations of Model 204 file naming rules are not detected until your application queries the database with that file in the query. </p>
<p>
For more information about Model 204 file naming rules, see [[Creating a file]].</p>

===Using CLOB or BLOB data===
<p>
The CREATE TABLE statement supports the Character Large Object (CLOB) and Binary Large Object (BLOB) data types.</p>
<p>
To define a column containing CLOB or BLOB data, specify the keyword &quot;CLOB&quot; or &quot;BLOB&quot; for the data type in the CREATE TABLE statement.</p>
<p>
The following example defines a TABLE called MANUALS that contains all of the manuals for Model204. RECTYPE and NAME are CHARACTER columns that identify the format and the name of the manual. MANUAL is a CLOB column that contains the actual text of the manual.</p>
<p class="code">CREATE TABLE MANUALS
( RECTYPE
CHAR(15),
NAME
CHAR(25)
MANUAL
CLOB)</p>
<p>
The following example defines a table containing employee information and a picture of the employee.</p>
<P CLASS="code">CREATE TABLE EMPLOYEE
( ID
CHAR(15),
NAME
CHAR(20),
PICTURE
BLOB)</p>

==Defining columns==
<p>
This section describes column definition syntax and considerations that apply generally to both nested and non-nested SQL tables. Information that is nested-table specific is presented in [[#Creating nested tables|Creating nested tables]].</p>

===Column definition statement===
====Syntax====
<p class="syntax"><span class="term">columname</span> &lt;<span class="term">datatype</span>&gt; 
 [ SYSNAME '<span class="term">fieldname</span>' ] 
 [ &lt;<span class="term">column-constraint</span>&gt; ... ]</p>

====Parameters====
where:
<ul>
<li><var class="term">columname</var> conforms to rules for an SQL identifier (see [[#Naming SQL objects|Naming SQL objects]]).</li>
<li><var class="term">datatype</var> is the column's data format, the options for which are: 
<p class="syntax">CHAR[ACTER] [(<span class="term">length</span>)] | NUM[ERIC]
[(<span class="term">precision</span> [,<span class="term">scale</span>])] | DEC[IMAL] 
[(<span class="term">precision</span> [,<span class="term">scale</span>])]
| INT[EGER] | SMALLINT | FLOAT [(<span class="term">precision</span>)] 
| REAL | DOUBLE PRECISION | CLOB | BLOB </p>
For more information about choosing data types, see [[#Matching Model 204 and SQL data formats|Matching Model 204 and SQL data formats]].
</li>
<li>SYSNAME '<var class="term">fieldname</var>' maps a column to a Model 204 field; see [[#Column naming and the SYSNAME extension|Column naming and the SYSNAME extension]]. </li>
<li>
<var class="term">column-constraint</var> specifies the following syntax:
<p class="syntax">[NOT NULL] [UNIQUE | PRIMARY KEY [SYSTEM]]
| REFERENCES <span class="term">parent-table-name</span>
[ &lt;<span class="term">referential-triggered-action</span>&gt; ]  </p>
<ul>
<li>NOT NULL column maps to a Model 204 field that has a non-null, nonempty value on every record in the Model 204 file. The Model 204 SQL Server does not allow you to violate this rule in an SQL DML update. If you add a NOT NULL column to an existing table, be sure the corresponding Model 204 field has non-null, nonempty values in all the records in the file. For more information about Model 204 SQL handling of nulls, see [[#Handling NOT NULL, UNIQUE, and multiply occurring data|Handling NOT NULL, UNIQUE, and multiply occurring data]]. </li>
<li>UNIQUE must map to a Model 204 ORDERED UNIQUE field. For discussion about multiple-column uniqueness, see [[#Specifying a multicolumn UNIQUE key|Specifying a multicolumn UNIQUE key]]. </li>
<li>PRIMARY KEY [SYSTEM], where SYSTEM is an extension with which you can have the Model 204 SQL Server generate and manage a unique primary key, as described in [[#Using system-generated keys|Using system-generated keys]]. </li>
<li>REFERENCES clause for defining a referential integrity constraint is supported for nested tables only, as described in [[#Nested tables require a referential constraint definition|Nested tables require a referential constraint definition]].   </li></ul>
</li></ul>
====Syntax rules====
<ul>
<li>Only one PRIMARY KEY clause is allowed per table. Specifying more than one brings an error message.</li>
<li>A primary key call is based on a Model 204 field with unique and ordered attributes.</li>
<li>Unlike the SQL standard, PRIMARY KEY is syntactically independent of NOT NULL. Specifying PRIMARY KEY without NOT NULL is not a syntax error. However, regardless of whether you specify NOT NULL, when you specify PRIMARY KEY, the SQL Server includes NOT NULL checking by default.</li>
<li>Unlike the SQL standard, UNIQUE is independent of NOT NULL. If you specify UNIQUE, NOT NULL is not implied.</li>
<li>The DEFAULT clause for column definition is not supported in Model 204 SQL.   If you include a DEFAULT clause in your SQL DDL, it does not become part of the SQL catalog definition, although you receive no syntax error.</li>
<li>The CHECK column constraint is not supported in Model 204 SQL.   If you include a CHECK clause in your SQL DDL, it does not become part of the SQL catalog definition, although you receive no syntax error.</li>
<li>Model 204 SQL does support the WITH CHECK OPTION for views, however.</li>
</ul>

===Mapping columns to Model 204 fields===
<p>
The following are requirements and recommendations for mapping SQL columns to Model 204 fields:</p>
<ul>
<li>
You cannot map two different columns in the same table to the same Model 204 field.</li>
<li>
To ensure accurate and efficient data handling, you must map Model 204 fields to SQL columns that have compatible data types. For information about specifying data types for selected columns, see [[#Compatibility of Model 204 and SQL data formats|Compatibility of Model 204 and SQL data formats]]. See also [[#Specifying attributes|Specifying attributes]] for additional data type requirements. </li>
<li>
You can map a Model 204 INVISIBLE field to an individual SQL column, but the column's usability in DML operations is restricted. For example, you can use the column in certain circumstances in the WHERE clause of a SELECT statement but cannot use the column in the SELECT list. You can use the column as the target of an INSERT, but cannot use it as the target or in the source expression of an UPDATE. 
<p>For more information about restrictions on DML operations with columns mapped to INVISIBLE fields, see [[#Using SQL DML against INVISIBLE fields|Using SQL DML against INVISIBLE fields]].</p>
<p>
You cannot map an INVISIBLE field to a column that serves as a primary key nor to a nested table column. You can map an INVISIBLE field to a <i>multicolumn unique</i> constraint key, but not to the individual columns that comprise the key. For information about multicolumn unique keys, see [[#Specifying a multicolumn UNIQUE key|Specifying a multicolumn UNIQUE key]] and, in the Table Specification facility, [[#Defining multicolumn unique keys (Multi-Column Unique panel|Defining multicolumn unique keys (Multi-Column Unique panel]]. </p>
</li>
<li>
If a Model 204 file is a sorted or hash key file, specify the sort or hash key as a column in the table for the file if the table is a parent or base table and the Model 204 FILEORG parameter has the X`02' option (key required) set. Failure to do so does not result in a DDL error message, but DML file insert attempts fail.
<p>
Also for such files, you cannot update the sort or hash key with SQL DML. SQL UPDATE statements fail if a column that maps to the sort or hash key is included.</p>
<p>
The Model 204 SQL Table Specification facility <b>requires</b> you to specify the sort or hash key as a column. However, if you do not want to include a column for the sort or hash key, you can edit the DDL generated by the TSF  (if you are setting up a read-only table or if the sort or hash key is not required, for example). </p>
</li>
<li>
Model 204 UNIQUE fields are guaranteed to have unique values but are not guaranteed to have no null values. When you map an SQL UNIQUE column to such a field, the SQL NOT NULL constraint is not implied. This decoupling of UNIQUE and NOT NULL is a Model 204 SQL extension to the SQL standard.    
<p>
If you include NOT NULL in an SQL UNIQUE column's definition, the SQL Server prevents updates that violate the NOT NULL condition, as well as provides Model 204 uniqueness protection.</p>
</li>
</ul>

===Column naming and the SYSNAME extension===

Model 204 SQL maps the SQL column you name to a Model 204 field. Unless you designate with the SYSNAME clause the Model 204 field you are mapping to the SQL column, the SQL Server assumes the SQL column name is the Model 204 field name. If your column name does not match the Model 204 field name, you are notified of the error when you attempt a DML query involving the column.

An SQL column name can contain as many as 18 characters (A-Z, 0-9, and underscore), and it must have no embedded blanks. Model 204 field names can have 255 characters, embedded blanks, and a variety of special characters; only certain character combinations are restricted.

SYSNAME allows you to resolve any conflicts between existing Model 204 names and SQL naming rules. Any pre-existing SQL naming format you have can be retained without modification.

For an example of using SYSNAME, see [[#Specifying a multicolumn UNIQUE key|Specifying a multicolumn UNIQUE key]], which also describes how multicolumn key names are modified and stored in the SQL catalog.

For more information about Model 204 field naming rules, see [[Field names]].

===Specifying a multicolumn UNIQUE key===
<p>
You can provide uniqueness checking for an SQL column by mapping it to a Model 204 field that has the ORDERED UNIQUE field attribute. Any SQL operation on such a column that violates its uniqueness in the table is not allowed. To provide such a uniqueness constraint for the combination of the values of two or more columns in a table, you can designate a multicolumn unique key. </p>
<p>
In Model 204 SQL DDL, a multicolumn unique key is a constraint key that has no SQL name and is not queriable. You map such a key to a Model 204 UNIQUE index field that your Model 204 file manager must add to the Model 204 file. This special field, which must be ORDERED CHAR, is a concatenation of the fields that correspond to the SQL columns in the key. Directions for defining and populating such a field follow.   </p>
<p>
Once the key is defined to the SQL catalog, SQL updates to any of the fields automatically update the index field that was added to support the multi-column unique definition. SQL INSERTs add values to the index, DELETEs remove values, and UPDATEs modify values. </p>

====Defining the key====
<p>
You can use the Table Specification facility (see <A HREF="Chap5.htm#0_25938" CLASS="XRef">See </A>) or manually define the multicolumn unique key in the DDL you submit to the SQL catalog. </p>
<p>
To manually define a multicolumn unique key: </p>
<ul>
<li>
Make sure the definitions of the columns that are to comprise the key include a NOT NULL specification. </li>
<li>
Include a UNIQUE constraint clause after the column definitions. Follow the UNIQUE keyword with a parenthesized sequence of the names of the columns forming the key. The order of the columns in parentheses determines the order in which they are concatenated to build the supporting Model 204 UNIQUE index field. </li>
</ul>
<p>
In the following example, two columns are concatenated to form a unique key. </p>
<p class="syntax">CREATE TABLE SITE
 ( ORG_ID CHAR(8) SYSNAME 'ORG ID' NOT NULL,
   SITE_ID CHAR(4) SYSNAME 'SITE ID' NOT NULL,
   SITE_NAME CHAR(36) SYSNAME 'SITE NAME' ,
   UNIQUE (ORG_ID, SITE_ID) SYSNAME 'ORG SITE ID INVIS' )</p>
<p>
In this example, a SYSNAME clause is used in each column definition, including the multicolumn unique key. Although using SYSNAME is optional for the multicolumn unique key, remember that the Model 204 SQL Server generates an assumed field name if you do not specify one with SYSNAME.   </p>
<p>
Without the SYSNAME clause following the UNIQUE clause in the example above, the Model 204 SQL Server concatenates the individual names ORG_ID and SITE_ID with an ampersand character (&amp;) in between to get ORG_ID&amp;SITE_ID. This name is stored in the SQL catalog as the name of the Model 204 index field.  </p>
<p>
The maximum number of columns you may concatenate depends on your data. You cannot exceed the Model 204 limit of 255 characters for the combined lengths of the concatenated field values. In addition, you cannot exceed the 255 characters for the key name (either the SYSNAME value for the Model 204 field or, if SYSNAME is not used, the concatenation of the SQL column names).  </p>
<p>
The Model 204 field that corresponds to the SQL multicolumn unique key is normally INVISIBLE to save Table B space. The key's constituent columns (ORG_ID and SITE_ID in the example above) cannot be mapped to INVISIBLE fields.</p>

====Populating the index field====
<p>
Once the Model 204 index field and multicolumn unique key are defined, you must populate the index. If you are defining a key for a table column that maps to a new Model 204 file, Model 204 SQL automatically populates the index as you insert records through SQL. </p>
<p>
If the Model 204 file data already exists, you must populate the index with values that are concatenations of the data values in the fields that are mapped to the columns comprising the key. You can populate the index for an existing file in two ways:</p>
<ul>
<li>
Automatically, with an SQL UPDATE statement. Use this method if you are maintaining the associated Model 204 file exclusively with SQL.

<p>Issue an SQL UPDATE in which you SET one of the multicolumn unique key columns equal to itself. This triggers an automatic building or rebuilding of the index for any multicolumn unique key that includes the column. If the column is a member of more than one multicolumn unique key, issuing such an UPDATE triggers the rebuilding of all of them. </p>
<p>
For example, you can issue the following UPDATE statement to populate the index for the key (ORG SITE ID INVIS):</p>
<code>UPDATE SITE SET ORG_ID=ORG_ID</code>
<p>
As a precaution, make a backup copy of the file before the UPDATE. </p>
</li>
<li>
Manually, with Model 204 SOUL or Host Language Interface manipulation. Use this method if you are maintaining the associated Model 204 file with SOUL or the Host Language Interface. You can use the algorithm described in [[#Using the multicolumn unique key algorithm|Using the multicolumn unique key algorithm]].
<p>
If you allow updates to the Model 204 file with SOUL or the Host Language Interface, you must ensure that you continue to manually maintain the index field.</p>
</li>
</ul>
<p>
If you want or need to repopulate an index field, use either of the following methods:</p>
<ul>
<li>
If the field is INVISIBLE, delete the field (with the Model 204 DELETE command), define it again (with the Model 204 DEFINE command), then repopulate the field using the SQL UPDATE method. </li>
<li>
If the field is not INVISIBLE, flush the old index by redefining (with the Model 204 REDEFINE command) the index field without the ORDERED attribute. Then redefine the field again, this time with the ORDERED CHAR attribute. Finally, repopulate the field using the SQL UPDATE method. </li>
</ul>

====Using the multicolumn unique key algorithm====
<p>
This algorithm defines for each column in the key the method for generating the field value to be concatenated into the key. The algorithm is affected only by the SQL column attribute; how the data is stored in Model 204 does not matter. Each data value is individually generated as described in the following table. The values are then concatenated and stored in the index as described in the following steps.</p>

<ol>
<li>For each component field, define the data value to a variable according to column data type, as shown in the following table.
<p class="caption">Multicolumn unique key encoding rules</p>
<table>
<th>Column data type</th>
<th>Encoding rules</th>
<tr>
<td>CHARACTER</td>
<td>Remove trailing blanks, then convert to counted string (character string with one-byte prefix that specifies the number of characters in the string).</td>
</tr>
<tr>
<td>INTEGER or SMALLINT</td>
<td>Store as 4-byte IBM binary integer.</td>
</tr>
<tr>
<td>DECIMAL</td>
<td>Convert to a right-justified string with length dependent on scale:
<p><code>scale=o: length=precision + 1</code></p>
<p><code>scale=precision: length=precision + 3</code></p>
<p><code>scale&gt;precision: length=precision + 2</code></p>
</td>
</tr>
<tr>
<td>NUMERIC</td>
<td>Same as DECIMAL.</td>
</tr>
<tr>
<td><p>REAL</p>
<p>DOUBLE</p>
<p>FLOAT</p>
</td>
<td>For floating point data, use the SQL UPDATE method described in [[#Populating the index field|Populating the index field]]. Model 204 SQL converts floating point data according to proprietary rules that you cannot reliably duplicate.</td>
</tr>
</table>
</li>
<li>
Concatenate the generated variables, removing trailing blanks (X`40'), leaving embedded blanks, and keeping one blank if the length of the concatenated key after this processing is zero.</li>
<li>
Store the concatenated value as your index value.</li>
</ol>

====Algorithm example====
<p>
Build an index value from the following columns and values:</p>
<table class="noBorder">
<tr>
<td rowspan="4" colspan="1">
<code>COL1 is DECIMAL (7, 2) <br>
COL2 is CHARACTER (6) <br>
COL3 is DOUBLE <br>
COL4 is INTEGER</code></td>
<td rowspan="4" colspan="1">
(sample value: 10.2)<br>
(sample value: 'JOHN')<br>
(sample value: 16.0)<br>
(sample value: 1)</td>
</tr>
</table>

<code>The concatenated value is:</code>
<p class="figure">[[File:SQL_Server_UG_ch4_Algorithm_example.gif]] </p>

==Creating nested tables==
<p>
A nested table is a base table with columns that map to Model 204 multiply occurring fields or groups of fields. A nested table is associated with a single base table parent by a unique table column key, which joins the nested table to the parent table. </p>
<p>
The NESTED USING clause is the optional clause in a CREATE TABLE statement that identifies the table as a nested table. The abridged CREATE TABLE syntax for a nested table below shows this NESTED clause extension. </p>
<p>
Nested tables are Model 204 SQL DDL extensions. There are no extensions to Model 204 SQL DML for using nested tables. For a DML query, nested tables are logically represented like a typical SQL table. Querying nested tables is discussed in [[SQL Data Manipulation Language (DML)]].</p>
<p>
This section describes the DDL coding rules and requirements for the creation of nested tables. For information about creating nested tables with the TSF, see [[#Defining nested tables|Defining nested tables]]. For introductory information about Model 204 nested tables, see [[SQL representation of Model 204 data#Mapping multiply occurring fields to nested tables|Mapping multiply occurring fields to nested tables]].</p>

===Nested table statements===

====Syntax====
<p class="syntax">CREATE TABLE <span class="term">tablename</span> NESTED USING <span class="term">columname</span>
 ( <span class="term">column-definition</span> | <span class="term">table-constraint-definition</span>
 [ ,<span class="term">column-definition</span> | <span class="term">table-constraint-definition</span> ]... 
)</p>

====Parameters====
<i>where:</i>
<ul>
<li>
<var class="term">column-definition</var> has the following syntax:
<p class="syntax"><span class="term">columname</span> <span class="term">datatype</span> [ SYSNAME '<span class="term">fieldname</span>' ] 
[ <span class="term">column-constraint</span> ] ...</p>
<ul>
<li><var class="term">column-constraint</var> has the following syntax:
<p class="syntax">NOT NULL [ UNIQUE ]
| REFERENCES <span class="term">parent-table-name</span>
[ <span class="term">referential-triggered-action</span> ] </p>
<ul>
<li><var class="term">referential triggered action</var> has the following syntax:
<p class="syntax">ON UPDATE CASCADE [ ON DELETE CASCADE ]
| ON DELETE CASCADE [ ON UPDATE CASCADE ]</p>
</li>
</ul>
</ul>
</li>
<li><var class="term">table-constraint-definition</var> has the following syntax:
<p class="syntax"><span class="term">unique-constraint-definition</span>
| <span class="term">referential-constraint-definition</span></p>
<ul>
<li><var class="term">unique-constraint-definition</var> has the following syntax:
<p class="syntax">UNIQUE ( <span class="term">columname</span> ) [ SYSNAME '<span class="term">fieldname</span>' ] </p></li>
<li><var class="term">referential constraint definition</var> has the following syntax:
<p class="syntax">[FOREIGN KEY (<span class="term">columname</span>)
REFERENCES <span class="term">parent-table-name</span>
[<span class="term">referential-triggered-action</span>]] </p>
<ul>
<li><var class="term">referential triggered action</var> has the following syntax:
<p class="syntax">ON UPDATE CASCADE [ ON DELETE CASCADE ]
| ON DELETE CASCADE [ ON UPDATE CASCADE ]</p></li>
</ul>
</li>
</li>
</ul>
</ul>
====Syntax rules====
<p>
Unless otherwise specified, all the rules that apply to tables apply also to nested tables. </p>

====Rules for nested table columns====
<ul>
<li>Only one column can be referenced by a NESTED clause, and only one NESTED clause is allowed per table.</li>
<li>Nested table must have one foreign key column, and can have no more.</li>
<li>Nested table must have at least one column in addition to the foreign key column.</li>
<li>All columns in a nested table must be defined as NOT NULL.</li>
<li>Column in a nested table cannot be mapped to a field with the Model 204 field attribute INVISIBLE.</li>
<li>Column in a nested table may not be mapped to a field with the Model 204 field attribute UPDATE AT END.</li>
<li>Multicolumn composite UNIQUE key is not allowed for a nested table.</li>
</ul>

====Rules for PRIMARY KEY and FOREIGN KEY====
<ul>
<li>A parent table that a foreign key refers to with the REFERENCES clause must have a PRIMARY KEY. This PRIMARY KEY can be a system-generated key.
<ul>
<li>
A PRIMARY KEY must map to a Model 204 UNIQUE ORDERED field. </li>
<li>
PRIMARY KEY cannot map to a Model 204 INVISIBLE field. </li>
</ul>
</li>
<li>If a foreign key is defined twice, first with a REFERENCES clause and then with a FOREIGN KEY clause, the statement is accepted only if the two clauses are identical and reference the same column. </li>
<p>
SQL error message -4703 is generated if a FOREIGN key is defined twice for a nested table and the two keys do not reference the same column. 

For example:</p>

<b>Acceptable:</b>
<p class="code">CREATE TABLE NESTEDINVENTOR2 NESTED USING PART_NO
      (PART_NO 
        DECIMAL(8) NOT NULL 
        REFERENCES INVENTORY, 
       ON_HAND 
        SYSNAME 'ON HAND' 
        FLOAT(4) NOT NULL, 
       LOCATION 
        CHAR(255) NOT NULL, 
       FOREIGN KEY (PART_NO) REFERENCES INVENTORY) </p>

<b>Returns SQL error -4703:</b>
<p class="code">CREATE TABLE NESTEDINVENTOR2 NESTED USING PART_NO
      (PART_NO
        DECIMAL(8) NOT NULL
        REFERENCES INVENTORY,
       ON_HAND
        SYSNAME 'ON HAND'
        FLOAT(4) NOT NULL,
       LOCATION
        CHAR(255) NOT NULL,
       FOREIGN KEY (ON_HAND) REFERENCES INVENTORY)</p>
</li>
<li>
The data type of the FOREIGN KEY of a nested table must match exactly (both in type and length) the data type of the PRIMARY KEY of the referenced table. Violation causes an error message to be issued.</li>
<li>
When paired in a nested table relationship, PRIMARY KEY and FOREIGN KEY can specify only single-column keys. For multicolumn primary key functionality, use PRIMARY KEY SYSTEM. </li>
</ul>
<p>
For more information, see [[#Nested tables require a foreign key|Nested tables require a foreign key]] and [[#Using system-generated keys|Using system-generated keys]]. For more information about multiple-column primary keys, see [[#Simulating multicolumn primary keys|Simulating multicolumn primary keys]]. </p>

====Rules for SYSTEM and SYSNAME====
<ul>
<li>
The SYSTEM keyword is optional, but if SYSTEM is specified, PRIMARY KEY must also be specified. The column associated with PRIMARY KEY SYSTEM must have a data type of INTEGER. </li>
<li>
SYSNAME cannot be specified with PRIMARY KEY SYSTEM. SYSTEM causes the mapping of the column to a system-generated field. Specifying SYSNAME, which implies a link to a Model 204 field name, conflicts with this automatic mapping. 
A violation of this rule causes an error message to be issued.</li>
<li>
Neither SYSTEM nor SYSNAME can be specified with the foreign key column of a nested table. 
A violation of this rule causes an error message to be issued.</li>
<li>
SYSTEM and SYSNAME are Model 204 SQL extensions. Using SYSTEM is discussed in [[#Using system-generated keys|Using system-generated keys]]; using SYSNAME is discussed in [[#Mapping table names to file names|Mapping table names to file names]] and [[#Column naming and the SYSNAME extension|Column naming and the SYSNAME extension]]. 
</li>
</ul>

===Mapping multiply occurring groups===
<p>
Nested table rows are ordered and retrieved by matching occurrence: the first row is mapped to the first occurrences of the repeating field values, the second row is mapped to the second occurrences of the repeating field values, and so on. The rank of occurrence (first, second, and so on) is determined by physical storage order in the file. For an example showing this row-to-occurrence mapping, see [[#Simulating normalization of Model 204 record data|Simulating normalization of Model 204 record data]].</p>
<p>
To preserve the matching occurrence ordering, each member of a group of multiply occurring values mapped to nested table columns must have the same number of occurrences. Otherwise, retrievals of these columns are not reliable. In addition, since null values invalidate matching occurrence ordering, nested table columns must be NOT NULL.</p>
<p>
If you want to add a new column to an existing nested table, the column must have as many rows as the other table columns and must have a value for each of the existing rows.</p>

===Nested tables require a foreign key===
<p>A nested table must have a foreign key column. A foreign key is equivalent to its related primary key in the parent table. The unique values of the primary or foreign key are used to locate the Model 204 records with the repeating field values.</p>

<p>You cannot update the foreign key directly with SQL DML. Updates to the primary key are propagated to the foreign key. You must specify the foreign key in an SQL INSERT; it is used to locate the parent record.</p>

<p>For an example of specifying the foreign key in DDL, see [[#Table constraint format|Table constraint format]].</p>

===Nested tables require a referential constraint definition===
<p>
A referential constraint definition (REFERENCES clause) is required in conjunction with the NESTED clause to define a nested table and its relationship to its parent. This constraint protects SQL database integrity by ensuring that all the values of a column in the nested table (the foreign key) match all the values of the primary key of the referenced parent table. Operations that violate a defined referential constraint are not allowed. </p>
<p>
Only one referential constraint is allowed per table. If you specify two REFERENCES clauses for a single table (one in a column definition and one in a foreign key definition), the clauses must be the same and reference the same column. </p>
<p>
How you specify a referential constraint depends on whether you are using the column definition or table constraint definition option of the Model 204 SQL CREATE TABLE statement. Examples of each follow.</p>

<p>In addition, the format changes slightly if you are using a system-generated primary key. For examples with system-generated primary keys, see [[#Using system-generated keys|Using system-generated keys]].</p>

====Table constraint format====
There must be a FOREIGN KEY clause that refers to the column (the foreign key) specified in the NESTED clause. The FOREIGN KEY clause must be followed by a REFERENCES clause referring to the parent table.   

For example:
<p class="code">CREATE TABLE PEOPLE 
 ( NAME CHAR(60) NOT NULL PRIMARY KEY 
   HIRE_DATE CHAR(8) )

 CREATE TABLE TASKS NESTED USING FNAME 
 ( TASK CHAR (25) NOT NULL,
   FNAME CHAR (60) NOT NULL,
   FOREIGN KEY (FNAME) REFERENCES PEOPLE ) </p>

====Column constraint format====
The column that is specified in the NESTED clause must have a REFERENCES clause referring to the parent table in the column definition. 

For example: 

<p class="code">CREATE TABLE PEOPLE 
 ( NAME CHAR(60) NOT NULL PRIMARY KEY, 
   HIRE_DATE CHAR(8) )

 CREATE TABLE TASKS NESTED USING FNAME 
 ( TASK CHAR (25) NOT NULL,
   FNAME CHAR (60) NOT NULL REFERENCES PEOPLE ) </p>

===CASCADE is the only referential triggered action===
<p>
A referential triggered action is a delete rule (ON DELETE action) and/or an update rule (ON UPDATE action) that governs what action a system takes if a referential constraint is violated. A system can refuse to execute a constraint-violating request, or it can cascade (that is, can automatically execute an operation that compensates for the violation). </p>
<p>
For example, if you change a value of the primary key of the parent table referenced by a nested table, you violate the referential integrity (REFERENCES clause) of the foreign key. A system can protect the referential integrity by preventing you from changing the primary key value. Or a system can cascade, automatically associating the nested table rows that refer to the changed primary key value with the new primary key value. The Model 204 SQL Server uses only the cascade action; it does not prevent you from changing the primary key value. </p>
<p>
If you change a value of the primary key of the parent table from n1 to n2, the Model 204 SQL Server changes all nested table foreign key references from n1 to n2.</p>
<p>
A referential triggered action is specified with a REFERENCES clause used in a nested table definition. For the column in a nested table defined in the NESTED clause, the only Model 204 SQL Server referential triggered action that you can specify is the CASCADE action. Updates and deletes are automatically cascaded. </p>
<p>
If you do not specify an update or delete rule, the rule is set to CASCADE by default. </p>

===Using system-generated keys===
<p>
A primary key is a column that has values that uniquely identify each record in the table. A nested table parent is required to have such a column. If no single column is a unique identifier in a nested table parent, or if a combination of two or more columns comprise the unique identifier, you must have the Model 204 SQL Server generate and manage a unique primary key.</p>
<p>
This system-generated key is a nonupdatable, unique integer key automatically assigned to each row occurrence by the system when the row is inserted. In fact, this key is the Model 204 internal record number, and other than being nonupdatable, it is like any other relational column. You can retrieve it with SELECT and use it in predicates. You can give it any name you want. </p>
<p>
In some queries, system-generated keys might be more efficient than specified single-column keys, because they provide direct access to the data. However, the system-generated values for SYSTEM keys are not necessarily preserved across a file reorganization: after a reorganization, the value for a system-generated column might change for any particular row occurrence. Because of this impermanence, avoid operations with the value of this column if the result of the operations is required for longer than the current session. </p>

====Defining system-generated keys====
<p>
To define a system-generated key, specify the SYSTEM modifier to the PRIMARY KEY constraint in the parent table column definition. The following examples use the column constraint format of CREATE TABLE. </p>

<b><I>Example 1 - Primary key is not system-generated</I></b>
<p>
In this example, repeated from [[#Column constraint format|Column constraint format]], the primary key is not system-generated. Here, NAME is a unique identifier for each record in the parent table.</p>
<p class="code">CREATE TABLE PEOPLE
 ( NAME CHAR(60) NOT NULL PRIMARY KEY,
   HIRE_DATE CHAR(8) )

 CREATE TABLE TASKS NESTED USING FNAME
 ( TASK CHAR (25) NOT NULL,
   FNAME CHAR (60) NOT NULL REFERENCES PEOPLE )</p>
<p>
The column name used for the primary key in the parent table is different from its related foreign key in the nested table, but this is not a requirement in SQL. </p>

<b><I>Example 2 - Primary key is system-generated</I></b>
<p>
In this example, the primary key is system-generated. Assume NAME and HIRE_DATE together form a unique identifier for each record in the parent table. Such a composite key requires you to use a system-generated primary key, because the primary key for nesting must be a single column. </p>
<p>
To define a system-generated key, specify a name for the system-generated primary key in the parent table column definition, and follow the token PRIMARY KEY with the modifier SYSTEM: </p>
<p class="code"> CREATE TABLE PEOPLE
 ( PKEY INTEGER NOT NULL PRIMARY KEY SYSTEM,
   NAME CHAR(60) NOT NULL 
   HIRE_DATE CHAR(8) )

 CREATE TABLE TASKS NESTED USING PKID
 ( TASK CHAR (25) NOT NULL,
   PKID INTEGER NOT NULL REFERENCES PEOPLE ) </p>

Notice that the FNAME column definition included in Example 1 is not included in the definition in Example 2. 

In Example 1, FNAME is the foreign key, that is, it is equivalent to the primary key NAME. 

In Example 2, PKEY replaces NAME as the primary key. A foreign key in TASKS equivalent to PKID must be included.
<p>
For information about multicolumn keys for non-nested tables, see [[#Specifying a multicolumn UNIQUE key|Specifying a multicolumn UNIQUE key]].</p>

====Simulating multicolumn primary keys====
<p>
As stated in Example 2, Model 204 SQL does not allow you to define a multicolumn primary key in conjunction with a nested table foreign key. In such a case, however, you can use a system-generated primary key to get the functionality of a multicolumn primary key. </p>
<p>
In addition to the definition of the system-generated primary key shown in example 2, add a uniqueness constraint definition for the columns that together form a unique identifier for each record in the parent table. (This constraint requires designating HIRE_DATE as NOT NULL.) </p>
<p class="code">CREATE TABLE PEOPLE 
 ( PKEY INTEGER NOT NULL PRIMARY KEY SYSTEM,
   NAME CHAR(60) NOT NULL 
   HIRE_DATE CHAR(8) NOT NULL
   UNIQUE (NAME, HIRE_DATE) SYSNAME 'HIRE ID' )</p>
<p>
The system-generated key satisfies the Model 204 SQL requirement for a single-column unique primary key. The multicolumn unique key definition for NAME and HIRE_DATE preserves their uniqueness.</p>
<p>
To SELECT the composite key columns (NAME and HIRE_DATE) and the multiply occurring column (TASK), you need to use the following joined-table SELECT instead of a simple non-joined SELECT:</p>
<p class="code">SELECT NAME, HIRE_DATE, TASK
  FROM PEOPLE, TASKS
  WHERE PKEY=PKID</p>

====Inserts into tables with system-generated keys====
<p>
You cannot insert column values into a table that has a system-generated key unless you specify the target-column list. For example, the following insert into table PEOPLE, whose primary key PKEY is system-generated, is valid. Model 204 SQL automatically provides a value for PKEY:</p>
<p class="code">INSERT INTO PEOPLE (NAME, HIRE_DATE)
  VALUES (`CJDATE','10/01/90')</p>
<p>
SQL syntax rules dictate that inserts without a column list require you to provide values for all the columns in the table. Because you cannot provide the primary key value (because PKEY is system-generated and you cannot update a system-generated key), removing (NAME, HIRE_DATE) from the example above causes the insert to fail.</p>
<p>
These rules for inserts into tables that have system-generated keys apply to base and parent tables. For inserts into nested tables that have system-generated keys, you must provide the primary key value from the parent table.</p>

==Creating views==
<p>
Unlike tables and columns, views do not map directly to Model 204 files and fields. A view is a selected set of columns and rows from one or more SQL tables or views that can be displayed as a unit. A view contains no data but instead is defined to access data in one or more tables. </p>
<p>
The Model 204 SQL CREATE VIEW statement includes extended SELECT functionality that enables the simulation of Model 204 groups.   </p>
<p>
For a discussion and detailed example of the DDL statement security considerations affecting view creation and access, see [[#Model 204 SQL view privileges|Model 204 SQL view privileges]].</p>

===CREATE VIEW statement===
<b>Syntax</b>
<p class="syntax">CREATE VIEW &lt;<span class="term">viewname</span>&gt; [ ( &lt;<span class="term">column-list</span>&gt; ) ]
 AS &lt;<span class="term">query-expression</span>&gt; [ WITH CHECK OPTION ] </p>

<b>Parameters</b>
<p>
where:</p>
<ul>
<li><var class="term">viewname</var> conforms to the rules for a SQL identifier. </li>
<li><var class="term">column-list</var> has the following syntax:
<p class="syntax"><span class="term">columname</span> [,<span class="term">columname</span> ] ...</p>
</li>
<li><var class="term">query-expression</var> is a query specification or a UNION of query specifications, where a query specification is a SELECT statement (with no ORDER BY clause).</li>
<li>The WITH CHECK OPTION checks DML inserts and updates to ensure that they do not violate view definition conditions.</li>
</ul>

<b>Syntax rules</b>
<p>
Query specifications joined by the UNION operator: </p>
<ul>
<li>cannot contain joined tables</li>
<li>cannot include GROUP BY or HAVING</li>
<li>cannot contain an EXISTS clause</li>
</ul>

===Rules for updating views===
<p>
The following rules govern whether you can update a particular view.</p>
<ul>
<li>
The definition of the view cannot include the UNION keyword or the DISTINCT keyword.</li>
<li>
You can refer to only one table in the FROM clause.</li>
<li>
If the CREATE VIEW statement includes a WHERE clause, the WHERE clause cannot include a subquery.</li>
<li>
The CREATE VIEW statement cannot include a GROUP BY clause or a HAVING clause.</li>
<li>
If the CREATE VIEW statement includes a SELECT clause, the SELECT clause cannot contain expressions.</li>
</ul>
<p>
This means that DDL used to define a view cannot grant the privileges UPDATE, INSERT, or DELETE to any view that ignores the [[#rules for updating views|rules for updating views]]. </p>
<p>For example, the following view DDL generates an error.</p>
<p class="code">SET SCHEMA DEMO
SET USER AGENT1
DROP VIEW TEST_VIEW
CREATE VIEW TEST_VIEW  (TEST_ID, POLICY_NO)
    AS SELECT TEST_TABLE.TEST_ID, CLIENTS.POLICY_NO

    FROM TEST_TABLE, CLIENTS

GRANT SELECT, UPDATE, DELETE, INSERT ON TEST_VIEW TO ADMIN</p>
<p>
Because you cannot update a view that is based on more than one table (TEST_TABLE and CLIENTS) this DDL generates the following error:</p>
<p class="code">SQL Error -551 AGENT1 does not have the privilege to perform operation GRANT on object DEMO.TEST_VIEW.</p>
<p>
However, the following GRANT SELECT clause is valid:</p>
<p class="code">GRANT SELECT ON TEST_VIEW TO ADMIN</p>
<p>
Only the updating clauses (UPDATE, INSERT, DELETE) are disallowed.</p>

===Guideline for view definitions===
<p>
The following general rule for view definitions governs what is allowed in a view definition and how you can select against that view: </p>
<ul>
<li>
Query in a DML SELECT against a view is evaluated by substituting the view definition for the references to the view in the DML SELECT. The query that results from this substitution or translation process must always be a valid SQL SELECT statement.</li></ul>

===Using SQL views in Model 204 SQL DDL===
<p>
Use SQL views for the following operations:</p>
<ul>
<li>
To implement your security strategy more efficiently.  
<p>Once a view is defined, the Model 204 SQL Server checks only the privileges to access the view itself, not the privileges for each of the elements of the view. For example, you might want to secure data by record type in a mixed record type file. After defining the views by record type, you can then limit access to each type of record by selectively granting privileges to access each view. </p>

For more information about privileges for views, see [[#DDL statement-level security|DDL statement-level security]].
</li>
<li>
To provide security that is similar to Model 204 field level security.

<p>Using GRANT to selectively permit updates to individual columns of a table can be degrading to DML processing performance. You can instead define a view with these columns and grant limited access to the view. Such a view is easier to define and maintain and is the only way to also grant SELECT access to just those columns. </p>
</li>
<li>
To [[#Simulating file groups|simulate Model 204 file groups]].

<p>File groups are not directly supported in Model 204 SQL DDL. However, you can use a Model 204 SQL CREATE VIEW extension to create views that simulate Model 204 groups.</p></li>

<li>
To [[#Mapping files with mixed record types|map Model 204 files that contain mixed record types]]. 

<p>
Define individual tables to the SQL catalog that map to files that have a variety of types of records. You can isolate the individual record types by defining a separate view for each one.</p></li>
</ul>

===Simulating file groups===
<p>
An SQL table cannot be mapped to a Model 204 file group. You can simulate a group, however, by creating a view that is comprised of a concatenation of tables that are mapped to the files in the group. </p>
<p>
First, map an SQL table to each of the files in the Model 204 group. Then create a view defined as a UNION (or UNION ALL) of SQL SELECT statements, each of which selects all the rows in one of the tables mapped to the group. This union of SELECT statements is extended functionality to the CREATE VIEW statement.</p>
<p>
The following example shows three table definitions and then a view definition based on those tables that simulates a Model 204 file group:</p>
<p class="code">CREATE TABLE POLICIES_89
  ( POL_NO INTEGER, ACC INTEGER, STATE CHAR(2) )

CREATE TABLE POLICIES_90
  ( POL_NO INTEGER, ACC INTEGER, STATE CHAR(2) )

CREATE TABLE POLICIES_91
  ( POL_NO INTEGER, ACC INTEGER, STATE CHAR(2) )

CREATE VIEW MA_POLICIES (POLICY_NO, ACCIDENTS) AS
  SELECT POL_NO, ACC FROM POLICIES_89 WHERE STATE = 'MA'
  UNION ALL
  SELECT POL_NO, ACC FROM POLICIES_90 WHERE STATE = 'MA'
  UNION ALL
  SELECT POL_NO, ACC FROM POLICIES_91 WHERE STATE = 'MA'</p>
<p>
You can use SELECT statements against the view to query the "group" of tables. However, you <b>cannot</b>
 update the file group through these views.</p>
<p>An example of a SELECT statement against the view is: </p>
<P CLASS="code">SELECT POLICY_NO FROM MA_POLICIES WHERE ACCIDENTS > 5</p>

===Mapping files with mixed record types===
<p>
An example of views defined for mixed record type files follows. The example shows manually generated DDL that defines two views of the CLIENTS file from the Model 204 demonstration database. After mapping all the fields (regardless of record type) to a single base table, you define a view for each record type:  </p>
<p class="code">CREATE SCHEMA AUTHORIZATION GEORGE
CREATE VIEW DRIVERS
  (DATE_OF_BIRTH, DRIVER_ID, FULLNAME, MARITAL_STATUS,
   POLICY_NO, SEX, STATE) AS
 SELECT
   DATE_OF_BIRTH, DRIVER_ID, FULLNAME, MARITAL_STATUS,
   POLICY_NO, SEX, STATE
 FROM CLIENTS
 WHERE RECTYPE = 'DRIVER'
GRANT ALL PRIVILEGES ON DRIVERS TO PUBLIC

CREATE VIEW POLICIES
  (ADDRESS, AGENT, ANNIV_DATE, CITY, DATE_OF_BIRTH,
   FULLNAME,   POLICY_NO, POLICYHOLDER, STATE,
   TOTAL_PREMIUM, ZIP) AS
 SELECT
   ADDRESS, AGENT, ANNIV_DATE, CITY, DATE_OF_BIRTH,
    FULLNAME, POLICY_NO, POLICYHOLDER, STATE, TOTAL_PREMIUM,
   ZIP
 FROM CLIENTS
 WHERE RECTYPE = 'POLICYHOLDER'
GRANT ALL PRIVILEGES ON POLICIES TO PUBLIC </p>
<p>
For the sake of simplicity, these views do not include the CLIENTS nested table columns. These columns map to multiply occurring Model 204 fields. </p>

===Maintaining views===
<p>
You are responsible for ensuring that your views remain valid over time. The Model 204 SQL Server does not warn you when a view is invalidated and does not prevent you from issuing DDL that renders a view invalid.  </p>
<p>
The DDL statements you can use for views are:</p>
<p class="code">CREATE VIEW
DROP VIEW
GRANT
REVOKE</p>
<p>
You can change the roster of users that can access a view (with GRANT and REVOKE), but you cannot change the view definition itself. Once a view is defined, you can modify it only by deleting it (with DROP VIEW) and redefining a new one (with CREATE VIEW).</p>
<p>
You can modify objects that the view references, but the modifications are not propagated to the view definition itself. For example, if you drop a table that is referenced by a view, the change is not propagated to the view definition. The view becomes invalid, yet the view definition remains in the catalog. You are not notified that your view is invalid until the time of DML query validation.</p>
<p>
The Model 204 SQL Server does not delete invalid views from the SQL catalog unless you explicitly drop the view or drop the schema to which the view belongs.</p>

===Querying views===
<p>
Queries against views whose definitions contain UNION ALL, GROUP BY, HAVING, or SELECT DISTINCT have the following restrictions. </p>

====Views defined with UNION ALL====
<p>
SELECT statements in a query expression that contains the UNION operator cannot reference any views that have definitions that contain the UNION operator.</p>
<p>
An SQL DML statement:</p>
<ul>
<li>
that references a view that has a UNION operator cannot itself use a UNION operator.</li>
<li>
cannot reference in a subquery a view that has a UNION operator.</li>
<li>
that references a view that has a UNION operator cannot use that view in a join expression. That is, no other view or table can be specified in the FROM clause of the query specification used in the DML statement.</li>
</ul>
<p>
An SQL SELECT statement:</p>
<ul>
<li>
that references a view that has a UNION operator cannot apply the GROUP BY clause nor any of the aggregating functions (COUNT, AVG, MAX, MIN, SUM).</li>
</ul>

====Views defined with GROUP BY, HAVING, or SELECT DISTINCT====
<p>
Query against a view defined with</p>
<ul>
<li>
GROUP BY, HAVING, or both, can have no other views or tables in the FROM clause, and cannot have a WHERE, GROUP BY, or HAVING clause.  </li>
<li>
SELECT DISTINCT can have no other views or tables in the FROM clause, and cannot have a GROUP BY or HAVING clause. Such queries must specify SELECT *. </li>
<li>
GROUP BY along with SELECT DISTINCT cannot have WHERE, GROUP BY, or HAVING clauses. </li>
</ul>

==Setting the schema and user context==
<p>
This section describes how to determine, indicate, and change the schema and user context, and introduces the SET SCHEMA and SET USER statements.    </p>

===Determining the default schema context===
<p>
At the beginning of an SQL session, the default schema context (name) is the Model 204 user ID established at login (with trailing blanks removed). The default schema name is assigned to any SQL objects you indicate in your DDL for the entire session, unless you specify another schema name. This default context is in effect except when a CREATE SCHEMA transaction is active (see [[#Indicating schema name and owner|Indicating schema name and owner]]). You can change the default context with the SET SCHEMA statement.</p>

===Prefixing the schema name to an SQL object===
<p>
After SQL objects are created, you may need to make adjustments to your schemas to accommodate new users, changes to privileges, or new data. To revise SQL objects already defined in the SQL catalog, you cannot use CREATE SCHEMA, because it can be used only once per schema, that is, when you initially create the schema. Issuing a CREATE SCHEMA that names an existing schema is an error. </p>
<p>
To selectively modify SQL objects that reside in different schemas, you need to identify the schema to which the objects belong. You can do so by specifying the schema name as qualification along with the name of the object (table, view) you are adding or modifying. For example: </p>
<p class="syntax"><span class="term">schemaname.tablename</span></p>
<p>
You can qualify the name of a column with a table name or with a table name and a schema name. For example:</p>
<p class="syntax"><span class="term">schemaname.tablename.columname</span></p>
<p>
If you do not specify the schema name along with the object, the schema name assigned is the current default schema.</p>
<p>
You can  qualify a table or view name only with the schema name that is the current default, if you are issuing CREATE TABLE or CREATE VIEW as part of a CREATE SCHEMA transaction. This restriction does not apply to GRANT statements in a CREATE SCHEMA transaction.</p>
<p>
You can reset or change the current default schema by using SET SCHEMA.</p>

===Using SET SCHEMA===
<p>You can change the default schema name in SQL DDL or DML by using the following Model 204 SQL extension statement:</p>
<p class="syntax">SET SCHEMA <span class="term">schemaname</span></p>
<p>
SET SCHEMA defines the current default schema context. Statements following SET SCHEMA are assumed to apply to this schema. This default remains in effect for the entire session or until reset by another SET SCHEMA statement.</p>
<p>
SET SCHEMA allows you to avoid continual specification of the schema name with SQL objects you are modifying or using. If no schema name is appended to an SQL object you add or modify after issuing SET SCHEMA, the schema name of the object defaults to the current setting of SET SCHEMA.</p>
<p>
Any user can issue SET SCHEMA, because it has no effect on a schema definition other than establishing the context. Once the schema context is set, however, permission to operate with DDL or DML on the SQL objects in the schema depends on the individual statement. The privileges required to issue individual Model 204 SQL DDL statements are summarized in [[#DDL statement-level security|DDL statement-level security]].</p>

===Using SET USER===
<p>
In Model 204, authority to issue commands is based on the user role or type. A system manager (determined by login ID) typically is the pivotal user with greatest authority. In SQL, authority is based on object ownership, the authorization ID of the schema to which an object belongs. Model 204 SQL statement security combines these characteristics: to create schemas and tables, you must be a system manager and your login ID must match the authorization ID for the schema to which the object belongs.</p>
<p>
However, this approach has the following drawback: to create a schema that has an SQL authorization ID other than the system manager's, the system manager has to give system manager privileges to that SQL user. The Model 204 SQL extension statement SET USER resolves this drawback.</p>
<p>
SET USER, available to system managers only, changes the current SQL user context.   A system manager issues SET USER ABC and in effect acquires the SQL authorization ID ABC and its associated SQL privileges. At the same time, the system manager retains Model 204 login ID privileges.</p>
<p>
SET USER thus enables a kind of superuser, who can issue SQL statements for another SQL user without having to log in as that user or give that user system manager privileges. The system manager gains immediate access to, and authority to change, all defined SQL objects.</p>
<p>
The SET USER syntax is:</p>
<b>Syntax</b>
<p class="syntax">SET USER <span class="term">authorization-id</span></p>
<p>
SET USER can be used with SQL DML or DDL statements. For an example showing how SET USER is used, see [[#SQL statement security example|SQL statement security example]].</p>

==Altering SQL objects==
<p>
ALTER TABLE allows you to change the definition of a table. New columns may be added with the ADD clause. Existing columns may be modified with the MODIFY clause. Columns may be removed using the DROP clause. </p>
<p>
ALTER TABLE also lets you shift the relative positions of the columns in a table. To protect against losing track of the column positions, you should always specify the column names when issuing an SQL INSERT.</p>

===ALTER TABLE statement===

<b>Syntax</b>
<p class="syntax">ALTER TABLE <span class="term">tablename</span> 
    ADD <span class="term">column-definition</span>
  | DROP <span class="term">columname</span>
  | MODIFY <span class="term">column-parameters</span></p>

<b>Parameters</b>
<p>
where:</p>
<ul>
<li><var class="term">column-definition</var> has the following syntax:
<p class="syntax"><span class="term">columname</span> &lt;<span class="term">datatype</span>&gt; [ SYSNAME '<span class="term">fieldname</span>' ]
[ &lt;<span class="term">column-constraint</span>&gt; ] ...</p>

<var class="term">column-constraint</var> has the following syntax:

<p class="syntax">[ NOT NULL ] [ UNIQUE | PRIMARY KEY [ SYSTEM ] ]
| REFERENCES <span class="term">parent-table-name</span>
[ &lt;<span class="term">referential-triggered-action</span>&gt; ]</p>

<p>Individual parameters are described in [[#CREATE TABLE statement|CREATE TABLE statement]] and [[#Creating nested tables|Creating nested tables]].</p></li>

<li><var class="term">column-parameters</var> has the following syntax:

<p class="syntax"><span class="term">columname</span> [<span class="term">datatype</span>] [SYSNAME '<span class="term">fieldname</span>']
[[NOT] NULL | [NOT] UNIQUE] </p>
</li>
<li>MODIFY is discussed in [[#Using MODIFY column|Using MODIFY column]].</li>
<li>NOT NULL column must map to a Model 204 field that has a non-null, nonempty value on every record in the Model 204 file. The Model 204 SQL Server does not allow you to violate this rule in an SQL DML update. If you add a NOT NULL column to an existing table, be sure the corresponding Model 204 field has non-null, nonempty values in all the records in the file. 
<p>For more information about Model 204 SQL handling of nulls, see [[#How Model 204 SQL processes dirty data|How Model 204 SQL processes dirty data]].</p></li>
</ul>

<b>Syntax rule</b>
<p>
As described in [[#Prefixing the schema name to an SQL object|Prefixing the schema name to an SQL object]], the name of the table can be optionally specified along with the schema name as qualification: </p>
<p class="syntax"><span class="term">schemaname.tablename</span></p>

===Using ADD column===
ADD adds a column to a table but does not update any view definitions that reference the table.

Use ADD for adding columns to a table when column position in the table is not important.

With ADD, all columns are added to a table in the last position of the column list. If you DROP a column and then ADD an updated version of that column, the updated column occupies a different position in the table than it did before you executed DROP and ADD. Such a change in order of the column data can introduce errors into queries that use SELECT * or INSERT (without a column list) and that depend on the correct position of the column data.

===Using DROP column===
Dropping a column deletes the column from the table and deletes any privileges granted for this column. It has no effect on any view definitions that reference this column.

<p class="note"><b>Note:</b> Because tables cannot be left empty, you cannot drop the last column in a table. Because nested tables cannot be left with only a foreign key column, you cannot drop the last nonforeign key column in a nested table. </p>

If you want to drop a referenced primary key column, you must first drop the nested table that contains the REFERENCES clause; if not, you receive an error message.

You cannot DROP a column that is part of a multicolumn unique key.

===Using MODIFY column===
<p>
Use MODIFY for the following operations:</p>
<ul>
<li>
To change the UNIQUE or NOT NULL status of a column.    </li>
<li>
To change a column definition other than making an addition or a deletion, use MODIFY instead of using DROP and ADD. </li>
<li>
To change a column's data type or field mapping clause or attributes. </li>
<li>
When the position of the column data in a table must not be disturbed.</li>
</ul>
<p>
MODIFY affects only the column definition elements you specify; the rest of the definition remains as is.</p> 
<p>For example, for a column originally defined as INTEGER NOT NULL that you want to change to DECIMAL (11,2) NOT NULL, specify only: </p>
<p class="syntax">ALTER TABLE <span class="term">tablename</span> MODIFY <span class="term">columname</span> DECIMAL (11,2) </p>
<p>
You cannot ALTER or MODIFY an SQL object that does not already exist. You cannot ALTER or MODIFY a column that is part of a multicolumn unique key.</p>
<p>
Only modify the UNIQUE or NOT NULL status of a column if the table is empty. If the UNIQUE or NOT NULL status of a column is modified on a nonempty table, you must ensure that this definition is compatible with the data in the existing Model 204 file. If it is not, an error might occur when processing an SQL request against this file.  </p>

<p class="note"><b>Note:</b> If more extensive modification to a table definition is required, you can drop the table and redefine it using CREATE TABLE as you did initially to set up the table. Remember, the Model 204 SQL catalog is not active, so dropping a table does not affect the actual file data.</p>

==Dropping SQL objects==
<p>
You can delete SQL objects from the SQL catalog with the Model 204 SQL DROP statements and clause listed below. These deletion statements are discussed in turn in this section. </p>
<p class="syntax">DROP TABLE &lt;<span class="term">tablename</span>&gt;
DROP VIEW &lt;<span class="term">view name</span>&gt;
DROP SCHEMA <span class="term">schemaname</span></p>

<p class="note"><b>Reminder:</b> You can avoid an inadvertent or unanticipated loss of data due to deletion of SQL objects by backing up CCACAT before executing a DROP or by using the catalog reporting utility (CCACATREPT). With CCACATREPT you can generate a copy of the catalog DDL before you execute a DROP.</p>
<p>
CCACATREPT is discussed in [[SQL catalog reporting and querying]]. For more information about backing up CCACAT, see [[#Backup and restore|Backup and restore]].</p>

===Dropping tables===
<p>
DROP TABLE causes the following actions to occur:</p>
<ul>
<li>
Catalog entry for the table and its columns is deleted.</li>
<li>
Any privilege and constraint records that reference this table are deleted.</li>
</ul>
<p>
Once DROP TABLE eliminates all entries for a table from the SQL catalog, the table no longer exists in the SQL catalog. However, the Model 204 file associated with the table remains unaffected.</p>
<p>
To avoid catalog data inconsistencies, drop SQL objects that depend on other objects before you drop the objects that are depended upon. For example, you must drop nested tables that reference a parent table before you drop the parent. Otherwise, your DROP TABLE statement is rejected. Also, drop any views associated with a table before you drop the table.</p>
<p>
For convenience, you can qualify the table name by prefixing the schema name.</p>

===Dropping views===
<p>
Views are permanent objects but do not map to Model 204 files or fields directly. The view's definition in terms of other tables or views is stored in the catalog in the form of a view record. </p>
<p>
When you drop a view, the view record and all privilege records (records of users granted access to the view) associated with the dropped view are deleted from the catalog.   DROP VIEW has no effect on the base table(s) associated with the view. </p>
<p>
The only time the Model 204 SQL Server deletes a view from the SQL catalog is when you explicitly drop it or drop the schema to which it belongs. You can render a view invalid by deleting objects referenced by the view, but the invalid view definition remains in the catalog. You are notified of the invalidity when you next attempt to access the data files through this view. </p>
<p>
For convenience, you can qualify the view name by prefixing the schema name.</p>

===Dropping schemas===
<p>
Dropping a schema deletes the SCHEMA record in the catalog and all TABLE, PRIVILEGE, and CONSTRAINT records that reference this schema.</p>
<p>
Dropping a schema also deletes views belonging to the schema and all PRIVILEGE records associated with them. </p>

==Granting privileges for SQL objects==
<p>
To perform an operation on an SQL object, you must hold the necessary privilege for that combination of operation and object. That privilege might result from ownership of the object or from being granted that privilege by another user (with the GRANT statement). You can change privilege assignments by adding privileges with subsequent GRANT statements or by deleting privileges with the REVOKE statement.</p>
<p>
This section provides the statement syntax for GRANT and REVOKE and discusses elements of their use that are special to Model 204 SQL.</p>

===GRANTs are for adding privileges===
<p>
GRANT statements always and only add privileges. If you want to change privilege assignments, you can add privileges with subsequent GRANT statements. To delete or diminish the current level of privileges you must use REVOKE, not GRANT. The Model 204 SQL Server allows a new GRANT for an object to replace an earlier GRANT for that object only to the extent that the new GRANT expands the current set of privileges.</p>
<p>
For example, if you try to reduce the current privileges for an object by issuing a new GRANT that allows fewer privileges, the new GRANT is ignored. To reduce the scope of given privileges you must use REVOKE.</p>

===GRANT and REVOKE handle nearly all SQL security===
<p>
SQL access to a Model 204 file is protected exclusively by Model 204 login security and Model 204 SQL GRANT and REVOKE statements. Existing Model 204 file access security is not enforced by the Model 204 SQL Server. </p>
<p>
Since GRANT and REVOKE are the principal security sources, the final SQL file access safeguard is SQL statement security. That is, you can permit only certain users per SQL object to issue GRANT and REVOKE statements. </p>
<p>
For more information about the privileges required for execution of the individual Model 204 SQL DDL statements, see [[#DDL statement-level security|DDL statement-level security]].</p>

===GRANT statement===
<p>
The GRANT statement is the privilege definition option of the CREATE SCHEMA statement. The syntax is:</p>

<b>Syntax</b>
<p class="syntax">GRANT &lt;<span class="term">privileges</span>&gt; ON &lt;<span class="term">object-name</span>&gt;
 TO &lt;<span class="term">grantee</span>&gt; [,&lt;<span class="term">grantee</span>&gt; ] ... 
 [ WITH GRANT OPTION ] </p>

<b>Parameters</b>
<p>
where:</p>
<ul>
<li><var class="term">privileges</var> has the following syntax:

<p class="syntax">ALL PRIVILEGES | <span class="term">action</span> [,<span class="term">action</span> ] ...</p>
</li>
<li>
<i>action</i> has the following syntax:

<p class="syntax"> SELECT |  INSERT | DELETE
|  UPDATE [ ( <span class="term">columname</span> [,<span class="term">columname</span> ] ... ) ] </p>
</li>
<li><var class="term">object-name</var> is the table or view name.</li>
<li><var class="term">grantee</var> has the following syntax:

<p class="syntax">PUBLIC | <span class="term">authorization-id</span></p>
</li>
</ul>

<b>Usage notes</b>
<p>
The privileges you can grant apply only to DML operations for specified SQL objects or to defining which users can issue additional GRANT statements for specified SQL objects. For information about privileges for issuing DDL statements, see [[#DDL statement-level security|DDL statement-level security]]. </p>
<p>
Model 204 SQL DDL has no REFERENCES privileges.  </p>
<p>
Unlike the other privileges, the UPDATE option can be applied to a specified list of columns. If no column list is specified with UPDATE, by default it is assumed that all columns in the table are included. </p>
<p>
You can use UPDATE to provide privileges for selective access to certain columns in the database. However, using UPDATE with a column list typically yields poorer performance than using a view of these columns and granting selective access through the view. </p>
<p>
You cannot grant UPDATE privileges on the columns of a system-generated primary key, because such a key by definition cannot be updated. </p>
<p>
Whether you specify UPDATE by itself or specify UPDATE followed by a list of the columns in the table, you can affect subsequent privilege assignments. This is discussed further in [[#Granting and altering column UPDATE privileges|Granting and altering column UPDATE privileges]]. </p>

===REVOKE statement===
<p>
The REVOKE statement is a Model 204 SQL extension with which you can revise the privileges given by the GRANT statement. A table's owner can REVOKE privileges for any authorization ID. Other users can REVOKE privileges for those rights they were granted with the WITH GRANT OPTION.</p>  
<p>The syntax is:</p>

<b>Syntax</b> 
<p class="syntax">REVOKE [ GRANT OPTION FOR ] <span class="term">privileges</span> 
 ON <span class="term">object-name</span>
 FROM <span class="term">grantee</span> [,<span class="term">grantee</span> ] ... </p>

<b>Parameters</b>
<p>
where:</p>
<ul>
<li><var class="term">privileges</var> is the same as for the GRANT statement.</li>
<li><var class="term">object-name</var> is the same as for the GRANT statement.</li>
<li><var class="term">grantee</var> has the following syntax:

<p class="syntax">PUBLIC | <span class="term">authorization-id</span> </p>
</li></ul>

<b>Usage notes</b>
<p>
Each time you issue REVOKE, it revokes one of the following:</p>
<ul>
<li>Entire privilege (SELECT, UPDATE, INSERT, or DELETE) or list of privileges</li>
<li>Ability of the specified user or users to grant this privilege to another user</li>
</ul>
<p>
Revocation of privileges does not cascade. That is, if your privileges to grant updates on a particular table are revoked, the update privileges for that table you can have granted to other users are not revoked. For example, USERA grants update privileges with grant option on TABLET to USERB, and USERB grants the same privileges to USERC. If USERA later revokes USERB'S TABLET privileges, USERC's TABLET privileges are <b>not</b> affected. </p>
<p>
Similarly, if USERB's privileges to grant updates on TABLET are revoked, the revoking action does not cascade to VIEWV, which references TABLET. USERB can still use VIEWV, and USERC can still use VIEWV. </p>
<p>
You receive an error message if you issue REVOKE against an unauthorized user (or against an authorized user whose name is misspelled).</p>

===Granting and altering column UPDATE privileges===

The REVOKE and ALTER TABLE statements in Model 204 SQL DDL allow for changes over time to the columns of a table and to the privileges for updating those columns. To avoid unwanted effects from such changes over time, you need to understand how the Model 204 SQL Server handles grants of column updating privileges.

The Model 204 SQL catalog stores your column UPDATE privileges for a table in one of the following ways:
<ul>
<li>
Single marker that indicates you can update all the columns in the table </li>
<li>
List of the individual columns you can update </li>
</ul>

The method of storage depends on the form of the UPDATE clause used to assign your privileges. The first method results from a GRANT statement UPDATE clause that does not specify an individual column list. By default, all columns in the table are included in the privilege. The second method results from a GRANT statement UPDATE clause that specifies an individual column list.

The storage method is significant, because subsequent changes to the table's columns or privileges can produce different outcomes depending on the initial storage method.

===Column UPDATE examples===
<p>
This section has a series of examples showing how the effects on a user's table column privileges of subsequent ALTER TABLE, REVOKE, and GRANT statements can depend on the format of the UPDATE clause of the initial GRANT statement.</p>

====Effect of ADD and DROP in ALTER TABLE statement====
<p>
Assuming table TABLEZ has columns COL_A, COL_B, and COL_C and proper grant authorization, consider the following GRANT statements, both of which grant UPDATE privileges to each of the columns in TABLEZ: </p>
<P CLASS="code">GRANT UPDATE ON TABLEZ TO JUAN</p>
<P CLASS="code">GRANT UPDATE (COL_A, COL_B, COL_C) ON TABLEZ TO MARIA</p>
<p>
The Model 204 SQL Server stores this information approximately as follows, where * means all columns, and GRANT OPTION, which refers to the WITH GRANT OPTION of GRANT UPDATE, is N (no) unless specified in the GRANT statement:</p>

<table>
<tr style="border-bottom:solid 2px black">
<td style="border-right-style:hidden;background-color:#fff;"><b>USER</b></td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;"><b>PRIVILEGE</b></td>
<td style="border-right-style:hidden;background-color:#fff;"><b>COLUMNS</b></td>
<td style="border-left-style:hidden;background-color:#fff;"><b>GRANT OPTION</b></td></tr>
<tr>
<td style="border-right-style:hidden;background-color:#fff;">JUAN</td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;">UPDATE</td>
<td style="text-align:center;border-left-style:hidden;border-right-style:hidden;background-color:#fff;">*</td>
<td style="text-align:center;border-left-style:hidden;">N</td></tr>
</table>

<table>
<tr style="border-bottom:solid 2px black">
<td style="border-right-style:hidden;background-color:#fff;"><b>USER</b></td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;"><b>PRIVILEGE</b></td>
<td style="border-right-style:hidden;background-color:#fff;"><b>COLUMNS</b></td>
<td style="border-left-style:hidden;background-color:#fff;"><b>GRANT OPTION</b></td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">MARIA</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">UPDATE</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;ackground-color:#fff;">COL_A</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;text-align:center;">N</td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">COL_B</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
<tr>
<td style="border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;">COL_C</td>
<td style="border-left-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
</table>

Now, note the effect of the following statement on Juan and Maria's UPDATE privileges:
<p class="code">ALTER TABLE TABLEZ ADD COL_D</p>

Juan's stored UPDATE privilege information, though physically unchanged, now includes the ability to update the newly added COL_D. However, Maria's unchanged privileges do not include the ability to update COL_D.

Continuing, note the effect of the following statements on Juan and Maria's UPDATE privileges:
<p class="code">ALTER TABLE TABLEZ DROP COL_A

ALTER TABLE TABLEZ ADD COL_A</p>

Juan's stored UPDATE privilege information remains physically unaffected, and he can still update all the columns in TABLEZ: COL_A, COL_B, COL_C, and COL_D. However, Maria's UPDATE privilege for COL_A gets dropped when COL_A is dropped from TABLEZ.  (See [[#Using DROP column|Using DROP column]] for the additional actions propagated when a column is dropped.) If COL_A is added back to the table, Maria's UPDATE privileges do not change and she can update only COL_B and COL_C.

====Effect of REVOKE====
<p>
Continuing the conditions of the previous example, note the effect of the following REVOKE statement. Remember, Juan can update all columns in TABLEZ, namely, COL_A, COL_B, COL_C, and COL_D. </p>
<p class="code">REVOKE UPDATE ( COL_C ) ON TABLEZ TO JUAN</p>
<p>
The Model 204 SQL Server must change the storage format and store Juan's privilege information in list format:</p>

<table>
<tr style="border-bottom:solid 2px black">
<td style="border-right-style:hidden;background-color:#fff;"><b>USER</b></td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;"><b>PRIVILEGE</b></td>
<td style="border-right-style:hidden;background-color:#fff;"><b>COLUMNS</b></td>
<td style="border-left-style:hidden;background-color:#fff;"><b>GRANT OPTION</b></td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">JUAN</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">UPDATE</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;ackground-color:#fff;">COL_A</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;text-align:center;">N</td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">COL_B</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
<tr>
<td style="border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;">COL_D</td>
<td style="border-left-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
</table>

If the REVOKE statement had preceded the ALTER TABLE statements in the example, Juan's UPDATE privileges would have been affected like Maria's were. That is, instead of automatically expanding and contracting with changes to the table, they would apply only to the explicitly named original columns, and they could be dropped if a table column were dropped.

====Effect of WITH GRANT OPTION====
<p>
Return to the example situation for Juan after the first GRANT statements and before the ALTER TABLE statements. Juan's UPDATE privileges are stored as follows:</p>

<table>
<tr style="border-bottom:solid 2px black">
<td style="border-right-style:hidden;background-color:#fff;"><b>USER</b></td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;"><b>PRIVILEGE</b></td>
<td style="border-right-style:hidden;background-color:#fff;"><b>COLUMNS</b></td>
<td style="border-left-style:hidden;background-color:#fff;"><b>GRANT OPTION</b></td></tr>
<tr>
<td style="border-right-style:hidden;background-color:#fff;">JUAN</td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;">UPDATE</td>
<td style="text-align:center;border-left-style:hidden;border-right-style:hidden;background-color:#fff;">*</td>
<td style="text-align:center;border-left-style:hidden;">N</td></tr>
</table>

Note the effect of the following statements on Juan's UPDATE privileges:
<p class="code">GRANT UPDATE (COL_A) ON TABLEZ TO JUAN

GRANT UPDATE (COL_A) ON TABLEZ TO JUAN WITH GRANT OPTION</p>

The first GRANT statement has no effect on Juan's privileges, which already include the privilege to update COL_A. But the WITH GRANT OPTION of the second GRANT statement introduces information that Juan's stored privileges do not include. Consequently, the Model 204 SQL Server stores Juan's privilege information in list format as follows:

<table>
<tr style="border-bottom:solid 2px black">
<td style="border-right-style:hidden;background-color:#fff;"><b>USER</b></td>
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;"><b>PRIVILEGE</b></td>
<td style="border-right-style:hidden;background-color:#fff;"><b>COLUMNS</b></td>
<td style="border-left-style:hidden;background-color:#fff;"><b>GRANT OPTION</b></td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">JUAN</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">UPDATE</td>
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;ackground-color:#fff;">COL_A</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;text-align:center;">Y</td></tr>
<tr>
<td style="border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;border-bottom-style:hidden;background-color:#fff;">COL_B</td>
<td style="border-left-style:hidden;border-bottom-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
<tr>
<td style="border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;" />
<td style="border-left-style:hidden;border-right-style:hidden;background-color:#fff;">COL_C</td>
<td style="border-left-style:hidden;background-color:#fff;text-align:center;">N</td></tr>
</table>

==DDL statement-level security==
<p>
The following table displays the privileges required for execution of the individual Model 204 SQL DDL statements. These privilege requirements are checked when you submit your DDL to the CVI utility. </p>
<p>
System manager privileges are determined by the Model 204 login user ID.</p>
<p>
This section also contains a discussion of view privileges and an example showing the application of statement security rules, especially for CREATE VIEW and GRANT. </p>

<p class="note"><b>Note:</b> You can replace Model 204 SQL statement security with privilege checking by an external security package. You provide user exits to the security package in a Model 204-defined format, as described in the [[Security interfaces]] topic.</p>
<p>
The SQL Server passes to the user exit all the information necessary to perform privilege checking identical to the Model 204 SQL privilege checking. The extent of the checking done is an option of the user exit.</p>
<p class="caption">DDL statement security</p>
<table>
<tr>
<th>To issue... </th>
<th>You must have... </th>
<th>Comments </th>
</tr>
<tr>
<td>CREATE SCHEMA</td>
<td>Model 204 system manager privileges
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  AND  -</p>
The schema authorization ID must match the Model 204 login ID of the user issuing the CREATE SCHEMA statement 
</td>
<td>Ensure the match between login ID and authorization ID by issuing SET USER before CREATE SCHEMA.
<p>If no authorization ID is specified in the CREATE, the logon ID is used. </p></td>
</tr>
<tr>
<td>CREATE TABLE</td>
<td>Model 204 system manager privileges
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  AND  -</p>
A Model 204 login ID that matches the authorization ID for the schema containing the table
</td>
<td>Ensure the match between login ID and authorization ID by using SET USER.
<p>If CREATE TABLE is part of a CREATE SCHEMA transaction, you cannot create a table that is qualified by a schema name other than the schema that is the current default.</p>
<p>The table owner (containing schema's authorization ID) automatically gets all privileges (including WITH GRANT OPTION) for the table.</p>
<p>The Model 204 file to which the table maps is not opened during the processing of the CREATE TABLE DDL.</p>
</td>
</tr>
<tr>
<td>CREATE VIEW</td>
<td>
A Model 204 login ID that matches the authorization ID for the view's schema and an authorization ID that matches the authorization ID for every object referenced in the view (that is, you own the schema and all the objects referenced in the view)
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  OR  -</p>

A Model 204 login ID that matches the authorization ID for the view's schema <b>and</b> <br>
the authorization ID for the view's schema has at least SELECT privileges on every object referenced in the view</td>
<td>
You cannot create a view that is qualified by a schema name other than the schema that is the current default.
<p>
The view owner (containing schema's authorization ID) automatically gets view privileges that match the level of privileges for the objects referenced in the view.</p>

If the view is not logically updateable, the level of privileges the view owner automatically gets may not exceed SELECT privileges.
</td>
</tr>
<tr>
<td>DROP SCHEMA</td>
<td>
Model 204 system manager privileges
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  AND  -</p>
A Model 204 login ID that matches the authorization ID for the schema
</td>
<td>
Ensure the match between login ID and authorization ID by issuing SET USER before DROP SCHEMA.
</td>
</tr>
<tr>
<td>DROP TABLE</td>
<td>
Model 204 system manager privileges
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  AND  -</p>
<p>A Model 204 login ID that matches the authorization ID for the schema containing the table</p>
</td>
<td>The authorization ID of the schema that contains the table must match the Model 204 login ID of the user issuing the DROP TABLE statement.
<p>Ensure the match between login ID and authorization ID by issuing SET USER before DROP TABLE.</p>
</td>
</tr>
<tr>
<td>DROP VIEW</td>
<td>A Model 204 login ID that matches the authorization ID for the schema containing the view</td>
<td />
</tr>
<tr>
<td>ALTER TABLE</td>
<td>
Model 204 system manager privileges
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  OR  -</p>
A Model 204 login ID that matches the authorization ID for the schema containing the table
</td>
<td>Ensure the match between login ID and authorization ID by issuing SET USER before ALTER TABLE.
</td>
</tr>
<tr>
<td>GRANT  <BR>
(for a table)
</td>
<td>
A Model 204 login ID that matches the authorization ID for the schema containing the table on which the privilege is being granted
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  OR  -</p>

By the WITH GRANT OPTION clause of some previous GRANT statement, that specifically granted the right to GRANT privileges of the named type for this table
<td>
You can GRANT privileges for a table that is qualified by a schema name other than the schema that is the current default.  
</td>
</tr>
<tr>
<td>GRANT  <BR>
(for a view)</td>
<td>A Model 204 login ID that matches the authorization ID for the schema containing the view on which the privilege is being granted, and also the authorization ID for the view's schema must have the corresponding privilege with WITH GRANT OPTION on all tables and views referenced in any part of the view definition
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  OR  -</p>
By the WITH GRANT OPTION clause of some previous GRANT statement, that specifically granted the right to GRANT privileges of the named type for this view
</td>
<td>You can GRANT privileges for a view that is qualified by a schema name other than the schema that is the current default.
</td>
</tr>
<tr>
<td>REVOKE</td>
<td>
A Model 204 login ID that matches the authorization ID for the schema containing the object on which the privilege is being revoked
<p>&nbsp;&nbsp;&nbsp;&nbsp;-  OR  -</p>
By the WITH GRANT OPTION clause of some previous GRANT statement, that specifically granted the right to GRANT privileges of the named type for this object
</td>
<td>REVOKE only deletes privileges from the object named in the REVOKE statement. The revoking action does not cascade to views that reference the object.</td>
</tr>
<tr>
<td>SET SCHEMA</td>
<td>Any Model 204 SQL user</td>
<td>The DDL statements you can issue within this schema context are determined at the specific statement level.</td>
</tr>
<tr>
<td>SET USER</td>
<td>Model 204 system manager privileges</td>
<td>
Sets the current SQL authorization ID for the duration of the user session or until the next SET USER.
</td>
</tr>
</table>

===Model 204 SQL view privileges===
<p>
View creation privileges are designed to uphold the security definition of the base tables and columns referenced in the view. These base objects require protection because privileges to use a view are checked when you issue a DML statement against the view, while the privileges for objects referenced by the view are checked when DDL is processed. Model 204 SQL DDL statement security, therefore, prevents you from using a view to circumvent the privileges for the base objects referenced by the view.</p>
<p>
Three of the fundamental principles upheld by Model 204 SQL statement security are:</p>
<ul>
<li>
You can only create views that satisfy the following rule: the authorization ID for the view's schema must have at least SELECT privileges on every object referenced in any part of the view definition. This rule holds whether you are a system manager or the owner of the view. </li>
<li>
You can neither create nor grant privileges for a view that makes the view base objects more accessible than your privileges for the base objects allow. For example, you cannot grant update privileges for a view if you have only the SELECT privilege on the objects referenced by the view.</li>
<li>
You can update a base object through a view only if you are the owner of the object or if you are granted the privilege to update from the owner of the object. </li>
</ul>
<p>
Since only the privilege records for the view and not for the base objects referenced by the view are checked when a DML request is processed, a view definition stands on its own. The view definition does not automatically reflect any changes to its base objects that occur after the view is created. If a base object referenced in a view is deleted, the view definition is not changed. You are responsible for the integrity over time of your view definitions. </p>

===SQL statement security example===
<p>
This section contains an example of a sequence of SQL DDL transactions and CVI utility messages. Following the example are explanatory comments. </p>
<p>
The example shows the effect of some of the basic rules governing DDL statement security, especially for view definition and the granting of view privileges. The example uses the demonstration database files (CLIENTS, VEHICLES and CLAIMS03).</p>
<p>
In the example, an INSURANCE schema is created containing: </p>
<ul>
<li>
Three base tables </li>
<li>
Three views, one per base table</li>
<li>
Three schemas, corresponding to agents </li>
<li>
Privileges for each object</li>
</ul>
<p>
The following SQL objects, contained in the agent schemas, are defined by the schema owners:</p>
<ul>
<li>
Views against the base tables</li>
<li>
Views against other views</li>
<li>
Privileges for each object</li>
</ul>
<p>
MISMAN is the only system manager. MISDEPT and BOB are common users. JOHN and MARY are agents. Transactions are followed by messages with return codes indicating the validity of the transaction. Boldface numbers to the right of the example statements are used in the comments following the example. </p>

====Example====
<p>
User MISDEPT logs in (not a system manager):</p>
<b>1</b>      <p class="code">CREATE SCHEMA INSURANCE AUTHORIZATION MISDEPT)
              SQL Error -551: User MISDEPT does 
              not have the privilege to perform 
              operation CREATE on object SCHEMA.</p>

<p>System manager logs in (user MISMAN): </p>
<b>2</b>      <p class="code">SET USER MISDEPT
              Completion Code: 0</p>

<b>3</b>      <p class="code">CREATE SCHEMA INSURANCE AUTHORIZATION MISDEPT
  CREATE TABLE CLIENTS &#183;&#183;&#183;
   GRANT SELECT ON CLIENTS TO BOB WITH GRANT OPTION 
  CREATE TABLE VEHICLES &#183;&#183;&#183; 
   GRANT SELECT ON VEHICLES TO BOB 
  CREATE TABLE CLAIMS03 &#183;&#183;&#183; 
  CREATE VIEW CLIENTS_V AS SELECT * FROM CLIENTS 
     WHERE AGENT = USER 
   GRANT ALL PRIVILEGES ON CLIENTS_V TO PUBLIC WITH GRANT OPTION 
  CREATE VIEW VEHICLES_V AS SELECT * FROM VEHICLES 
     WHERE AGENT = USER 
   GRANT ALL PRIVILEGES ON VEHICLES_V TO JOHN WITH GRANT OPTION 
  CREATE VIEW CLAIMS03_V AS SELECT * FROM CLAIMS03 
     WHERE AGENT = USER 
   GRANT ALL PRIVILEGES ON CLAIMS03_V TO MARY
               Completion Code: 0</p>

<b>4</b>
<P CLASS="code">SET USER BOB	
               Completion Code: 0</p>

<b>5</b>
<P CLASS="code">CREATE SCHEMA AUTHORIZATION BOB
               Completion Code: 0</p>

<b>6</b>
<P CLASS="code">SET USER JOHN
               Completion Code: 0</p>

<b>7</b>
<P CLASS="code">CREATE SCHEMA AGENT_J16 AUTHORIZATION JOHN     
               Completion Code: 0</p>

<b>8</b>
<P CLASS="code">SET USER MARY
               Completion Code: 0</p>

<b>9</b>
<P CLASS="code">CREATE SCHEMA AGENT_M05 AUTHORIZATION MARY
               Completion Code: 0</p>
<p>
User BOB logs in (not a system manager):</p>

<b>10</b>
<p class="code">SET SCHEMA BOB
               Completion Code: 0</p>

<b>11</b>
<P CLASS="code">CREATE VIEW YOUNG_DRIVERS AS SELECT * 
  FROM INSURANCE.CLIENTS WHERE DATE_OF_BIRTH > 671231
               Completion Code: 0</p>

<b>12</b>
<P CLASS="code">GRANT SELECT ON YOUNG_DRIVERS TO PUBLIC
               Completion Code: 0</p>

<b>13</b>
<P CLASS="code">CREATE VIEW STOLEN_CARS AS SELECT * 
  FROM INSURANCE.VEHICLES WHERE INCIDENT = 'ST'
               Completion Code: 0</p>

<b>14</b>
<P CLASS="code">GRANT SELECT ON STOLEN_CARS TO PUBLIC
               SQL Error -551: User BOB does not 
               have the privilege to perform 
               operation GRANT on object 
               STOLEN_CARS.</p>

<b>15</b>
<P CLASS="code">CREATE VIEW COLLISIONS AS SELECT * 
  FROM INSURANCE.CLAIMS03 WHERE CLAIM_TYPE = 'C'
               SQL Error -551: BOB does not have 
               the privilege to perform operation 
               SELECT on object CLAIMS03.</p>
<p>
User JOHN logs in (not a system manager):</p>

<b>16</b>
<P CLASS="code">SET SCHEMA AGENT_J16
               Completion Code: 0</p>

<b>17</b>
<P CLASS="code">CREATE VIEW MYVEHICLES AS SELECT * 
  FROM INSURANCE.VEHICLES
               SQL Error -551: JOHN does not have 
               the privilege to perform operation 
               SELECT on object VEHICLES. </p>

<b>18</b>
<P CLASS="code">CREATE VIEW MYVEHICLES AS SELECT * 
  FROM INSURANCE.VEHICLES_V
               Completion Code: 0 </p>

<b>19</b>
<P CLASS="code">GRANT SELECT ON MYVEHICLES TO MARY
               Completion Code: 0</p>
<p>
User MARY logs in (not a system manager): </p>

<b>20</b>
<P CLASS="code">SET SCHEMA AGENT_M05
               Completion Code: 0 </p>

<b>21</b>
<P CLASS="code">CREATE VIEW MYCLAIMS03 AS SELECT * FROM INSURANCE.CLAIMS03
               SQL Error -551: MARY does not have 
               the privilege to perform operation 
               SELECT on object CLAIMS03. </p>

<b>22</b>
<P CLASS="code">CREATE VIEW MYCLAIMS03 AS SELECT * 
  FROM INSURANCE.CLAIMS03_V
              Completion Code: 0 </p>

<b>23</b>
<P CLASS="code">GRANT SELECT ON AGENT_J16.MYVEHICLES TO JOHN
               SQL Error -551: MARY does not have 
               the privilege to perform operation 
               GRANT on object MYVEHICLES. </p>

<b>24</b>
<P CLASS="code">CREATE VIEW MYCLIENTS AS SELECT * FROM INSURANCE.CLIENTS_V
               Completion Code: 0</p>
<p>
System manager logs in (user MISMAN): </p>

<b>25</b>
<P CLASS="code">SET USER MISDEPT
               Completion Code: 0 </p>

<b>26</b>
<P CLASS="code">DROP SCHEMA INSURANCE
               Completion Code: 0</p>

<b>27</b>
<P CLASS="code">SET USER BOB
           Completion Code: 0 </p>

<b>28</b>
<P CLASS="code">DROP SCHEMA BOB
              Completion Code: 0 </p>

<b>29</b>
<P CLASS="code">SET USER JOHN
             Completion Code: 0 </p>

<b>30</b>
<P CLASS="code">DROP SCHEMA AGENT_J16
               Completion Code: 0 </p>

<b>31</b>
<P CLASS="code">SET USER MARY
               Completion Code: 0 </p>

<b>32</b>
<P CLASS="code">DROP SCHEMA AGENT_M05
               Completion Code: 0 </p>

===Statement security example comments===
<ul>
<li>
Statement 1 fails because MISDEPT is not a system manager.</li>
<li>
Statement 2 allows the system manager, in effect, to log in as user MISDEPT. This is necessary so the system manager can define the INSURANCE schema to have owner MISDEPT. SQL objects can be created only by their owners. That is, the login ID of the user issuing an SQL CREATE must match the specified or implied authorization ID of the current schema.</li>
<li>
Statement 3 makes MISDEPT the owner of the INSURANCE schema and all the objects in the schema. Note that although system manager MISMAN issued the CREATE SCHEMA for INSURANCE, the privileges to access INSURANCE are automatically granted only to the object's owner MISDEPT. MISMAN cannot access INSURANCE unless the system manager explicitly includes a GRANT of privileges to MISMAN for INSURANCE.</li>
<li>
Statements 4, 6, and 8 allow the system manager to create schemas owned by the specified users. Later in the example, the users define the SQL objects that belong to their schemas.</li>
<li>
Unlike statements 7 and 9, statement 5 does not include a schema name value, so the default name is the authorization ID, BOB.</li>
<li>
Statement 10 is necessary to change the schema context (from MARY to BOB) so that BOB can add objects to his schema. Statements 16 and 20 are similar. </li>
<li>
Statements 11 and 13 are valid, because view owner BOB was granted (by MISMAN) the SELECT privilege for the tables referenced in his views.   BOB cannot create a view that references the CLAIMS03 table, for example, because he does not have any privileges for that table (see statement 15). 

<p>Statements 11 and 13 also show the use of the schema name, INSURANCE, as a qualifier for the CLIENTS and VEHICLES tables. Without the qualifier, CLIENTS is assumed to belong to the default schema, BOB, and the statement fails.</p></li>

<li>
Statement 12 is valid, since BOB was granted the SELECT privilege WITH GRANT OPTION on the referenced table (CLIENTS). The SELECT privilege and WITH GRANT OPTION is implicitly granted to the YOUNG_DRIVERS view owner (BOB). That is, the maximum privileges available for the view are equal to those that the view owner has on the object referenced by the view, and these privileges are also implicitly granted to the view owner for the view.</li>
<li>
Statement 14 fails because the SELECT privilege on the referenced table VEHICLES was granted to BOB not including WITH GRANT OPTION. View STOLEN_CARS is created with only the SELECT privilege (not including WITH GRANT OPTION) implicitly granted to the view owner.
<p>STOLEN_CARS view is, therefore, viewable only by BOB. No one else (including MISMAN) can SELECT this view, and no one (including BOB) can update the view.</p></li>

<li>
Statements 15, 17, and 21 fail, because the view owners-to-be lack the SELECT privilege for objects they want to reference in these views.</li>
<li>
Statement 18 creates MYVEHICLES, a view of a view. All privileges are implicitly granted to the MYVEHICLES owner (JOHN), including WITH GRANT OPTION, because MYVEHICLES is logically updateable and JOHN has all privileges on the referenced view VEHICLES_V. If the view were not logically updateable, the implicit owner privileges would be SELECT WITH GRANT OPTION.    </li>
<li>
Statement 19 succeeds because JOHN's privileges for MYVEHICLES (which equal his privileges for the referenced view VEHICLES_V) include WITH GRANT OPTION.   </li>
<li>
Statement 22 creates MYCLAIMS03, a view of a view. All privileges are implicitly granted to the MYCLAIMS03 owner (MARY), not including WITH GRANT OPTION, because MYCLAIMS03 is logically updateable and MARY has all privileges on the referenced view VEHICLES_V. </li>
<li>
Statement 23 fails because MARY's privileges for MYVEHICLES (granted in statement 19) do not include WITH GRANT OPTION.  </li>
<li>
Statement 24 creates MYCLIENTS, a view of a view. All privileges are implicitly granted to the MYCLIENTS owner (MARY), including WITH GRANT OPTION, because MYCLIENTS is logically updateable and all privileges on the referenced view VEHICLES_V are granted to PUBLIC WITH GRANT OPTION.    </li>
<li>
Statements 25 through 32 show the system manager logging in as various users and then deleting from the SQL catalog (with DROP) the schemas owned by each user. This method is necessary because to drop a schema you must be the schema owner and a system manager. That is, the login ID of the user issuing an SQL DROP SCHEMA must match the specified or implied authorization ID of the current schema; and the user issuing an SQL DROP SCHEMA must be a system manager.</li>
</ul>

==SQL DDL processing==
<p>
Each DDL statement is committed upon successful execution without regard to the SQL Auto Commit setting for the data source.</p>

[[Category: Model 204 SQL processing]]