File: aguide13.htm

package info (click to toggle)
solid-doc 2.2-1
links: PTS
area: non-free
in suites: potato, slink
size: 3,436 kB
ctags: 11,371
sloc: makefile: 58; sh: 2
file content (1565 lines) | stat: -rw-r--r-- 56,612 bytes
parent folder | download | duplicates (2)
<HTML>
<HEAD>
<TITLE></TITLE>
<LINK REL="ToC" HREF="httoc.htm">
<LINK REL="Index" HREF="htindex.htm">
<LINK REL="Next" HREF="aguide14.htm">
<LINK REL="Previous" HREF="aguide12.htm"></HEAD>
<BODY BGCOLOR="#FFFFFF">
<P ALIGN=CENTER>
<A HREF="aguide12.htm" TARGET="_self"><IMG SRC="gaguide/graprev.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Previous Page"></A>
<A HREF="httoc.htm" TARGET="_self"><IMG SRC="gaguide/gratop.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="TOC"></A>
<A HREF="htindex.htm" TARGET="_self"><IMG SRC="gaguide/graindex.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Index"></A>
<A HREF="aguide14.htm" TARGET="_self"><IMG SRC="gaguide/granext.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Next Page"></A>

<A NAME="E9E13"></A>
<H1>
<FONT FACE="Arial"><B>APPENDIX D SOLID SQL SYNTAX</B></FONT></H1>
<BR>
<BLOCKQUOTE>
<P>The SOLID <I>Server</I> SQL syntax is based on the ANSI X3.135-1989 level 2 standard including important ANSI X3.135-1992 (SQL2) extensions. User and role management services missing from previous standards are based on the ANSI SQL3 draft.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>This appendix presents a simplified description of the SQL statements including some examples. The same information is included in the<B> SOLID </B><B><I>Server</I></B><B> Programmer's Guide</B> <B>and Reference.</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The description syntax uses these conversions:
</BLOCKQUOTE>
<UL>
<BLOCKQUOTE>
<LI>SQL keywords appear in all UPPERCASE letters
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>syntax elements are specified in lowercase
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>syntax elements specified in <I>lowercase italics</I> are explained in the end of this appendix
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>the notation ... indicates that elements can be repeated
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>vertical bars | indicates a choice between two or more alternative syntax elements
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>square brackets [ ] indicate an optional syntax element
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>braces { } indicate a choice among required syntax elements
</BLOCKQUOTE></UL>
<A NAME="E10E70"></A>
<P>
<FONT FACE="Arial"><B>ADMIN COMMAND</B></FONT>
<BLOCKQUOTE>
<PRE>ADMIN COMMAND 'command-name'
<BR>command-name ::= EXIT | HELP | SHUTDOWN | OPEN | 
<BR>   CLOSE | THROWOUT | USERLIST | MAKECP | BACKUP | 
<BR>   BACKUPLIST | STATUS | REPORT | MESSAGES | 
<BR>   MONITOR | VERSION | ERRORCODE | HOTSTANDBY</PRE></BLOCKQUOTE>
<H4> Usage</H4>
<BLOCKQUOTE>
<P>This SQL extension executes administrator commands. Syntax for the extension is
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>ADMIN COMMAND 'command-name'</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>where command-name is a SOLID <I>Remote Control</I> (Teletype) command string. The result set contains two columns: RC INTEGER and TEXT VARCHAR(254). Integer column RC is a command return code (0 if success), varchar column TEXT is the command reply. The TEXT field contains same lines that a displayed on SOLID <I>Remote Control</I> (Teletype) screen, one line per one result row.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>ADMIN COMMAND 'USERLIST';</PRE></BLOCKQUOTE>
<A NAME="E10E71"></A>
<P>
<FONT FACE="Arial"><B>ALTER TABLE</B></FONT>
<BLOCKQUOTE>
<PRE>ALTER TABLE base-table-name 
<BR>  {ADD [COLUMN] column-identifier <I>data-type</I> |
<BR>   DROP [COLUMN] column-identifier |
<BR>   RENAME [COLUMN]
<BR>      column-identifier column-identifier |
<BR>   MODIFY [COLUMN]
<BR>      column-identifier <I>data-type</I>} |
<BR>   MODIFY SCHEMA schema-name |
<BR>   SET {OPTIMISTIC | PESSIMISTIC}</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The structure of a table may be modified through the ALTER TABLE statement. Within the context of this statement, columns may be added, modified, or removed.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The owner of a table can be changed using  the
<BR>ALTER TABLE base-table-name MODIFY SCHEMA schema-name statement. This statement gives all rights to the new owner of the table including creator rights. The old owner&#146;s access rights to the table, excluding the creator rights, are preserved.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Individual tables can be set to optimistic or pessimistic with the command 
<BR>ALTER TABLE base-table-name SET {OPTIMISTIC | PESSIMISTIC}. By default, all tables are optimistic. A database-wide default can be set in the General section of the configuration file with the parameter Pessimistic = yes.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>If transaction early validate is used, update and delete operations use locks for the early validation. Read operations do not lock, but update and delete operations lock the updated or deleted row.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>ALTER TABLE TEST ADD X INTEGER;
ALTER TABLE TEST RENAME COLUMN X Y;
ALTER TABLE TEST MODIFY COLUMN X SMALLINT;
ALTER TABLE TEST DROP COLUMN X;</PRE></BLOCKQUOTE>
<A NAME="E10E72"></A>
<P>
<FONT FACE="Arial"><B>ALTER USER</B></FONT>
<BLOCKQUOTE>
<PRE>ALTER USER user-name IDENTIFIED BY password</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The password of a user may be modified through the ALTER USER statement.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>ALTER USER MANAGER IDENTIFIED BY O2CPTG;</PRE></BLOCKQUOTE>
<A NAME="E10E73"></A>
<P>
<FONT FACE="Arial"><B>CALL</B></FONT>
<BLOCKQUOTE>
<PRE>CALL procedure-name [parameter ...]</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Stored procedures are called with statement CALL.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CALL proctest;</PRE></BLOCKQUOTE>
<A NAME="E10E74"></A>
<P>
<FONT FACE="Arial"><B>COMMIT</B></FONT>
<BLOCKQUOTE>
<PRE>COMMIT WORK</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The changes made in the database are made permanent by COMMIT statement. It terminates the transaction.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>COMMIT WORK;</PRE></BLOCKQUOTE>
<A NAME="E10E75"></A>
<P>
<FONT FACE="Arial"><B>CREATE EVENT</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE EVENT event-name
<BR>   [(parameter-definition
<BR>    [, parameter-definition ...])]</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Event alerts are used to signal an event in the database. Events are simple objects with a name. The use of event alerts removes resource consuming database polling from applications.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>An event object is created with the SQL statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>CREATE EVENT event-name [parameter-list]
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The name can be any user-specified alphanumeric string. The parameter list specifies parameter names and parameter types. The parameter types are normal SQL types.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Events are dropped with the SQL statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>DROP EVENT event-name
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Events are triggered and received inside stored procedures. Special stored procedure statements are used to trigger and receive events.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The event is triggered with the stored procedure statement 
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>POST EVENT event-name [parameters]
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Event parameters must be local variables or parameters in the stored procedure where the event is triggered. All clients that are waiting for the posted event will receive the event.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>To make a procedure wait for an event to happen, the WAIT EVENT construct is used in a stored procedure:
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>wait-event-statement ::=
<BR>   WAIT EVENT
<BR>      [event-specification ...]
<BR>   END WAIT
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>event-specification ::=
<BR>   WHEN event-name (parameters) BEGIN
<BR>      statements
<BR>   END EVENT
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Example of a procedure that waits for an event:
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>create procedure &quot;event-wait(i1 integer)
<BR>returns (result varchar)
<BR>begin
<BR>declare i integer;
<BR>declare c char(4);
<BR>
<BR>i := 0;
<BR>
<BR>wait event 
<BR>   when test1 begin
<BR>      result := 'event1';
<BR>      return;
<BR>   end event
<BR>
<BR>   when test2(i) begin
<BR>   end event
<BR>
<BR>   when test3(i, c) begin
<BR>   end event
<BR>end wait
<BR>
<BR>if i &lt;&gt; 0 then
<BR>   result := 'if';
<BR>   post event test1;
<BR>else
<BR>   result := 'else';
<BR>   post event test2(i);
<BR>   post event test3(i, c);
<BR>end if
<BR>end&quot;;
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The creator of an event or the database administrator can grant and revoke access rights. Access rights can be granted to users and roles. The select access right gives waiting access to an event. The insert access right gives triggering access to an event.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE EVENT ALERT1(I INTEGER, C CHAR(4));</PRE></BLOCKQUOTE>
<A NAME="E10E76"></A>
<P>
<FONT FACE="Arial"><B>CREATE INDEX</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE [UNIQUE] INDEX index-name
<BR>   ON base-table-name
<BR>      (column-identifier [ASC | DESC]
<BR>       [, column-identifier [ASC | DESC]] ...)</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Creates an index for a table based on the given columns. Keyword UNIQUE specifies that columns being indexed must contain unique values. Keywords ASC and DESC specify whether the given columns should be indexed in ascending or descending order. If not specified ascending order is used.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE UNIQUE INDEX UX_TEST ON TEST (I);
CREATE INDEX X_TEST ON TEST (I, J);</PRE></BLOCKQUOTE>
<A NAME="E10E77"></A>
<P>
<FONT FACE="Arial"><B>CREATE PROCEDURE</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE PROCEDURE procedure-name
<BR>   [(parameter-definition 
<BR>      [, parameter-definition ...])]
<BR>   [RETURNS (parameter-definition 
<BR>      [, parameter-definition ...])]
<BR>   BEGIN procedure-body END;
parameter-definition ::= parameter-name data-type
procedure-body ::= [declare-statement; ...]
<BR>   procedure-statement; [procedure-statement; ...] 
declare-statement ::= DECLARE variable-name
<BR>   data-type
procedure-statement ::= prepare-statement |
<BR>   exec-statement | fetch-statement | 
<BR>   control-statement | post-statement |
<BR>   wait-event-statement
prepare-statement ::= EXEC SQL PREPARE 
<BR>   cursor-name sql-statement
execute-statement ::=
<BR>   EXEC SQL EXECUTE
<BR>      cursor-name 
<BR>      [USING (variable [, variable ...])]
<BR>      [INTO (variable [, variable ...])] |
<BR>   EXEC SQL {COMMIT | ROLLBACK} WORK |
<BR>   EXEC SQL SET TRANSACTION {READ ONLY | READ WRITE} |
<BR>   EXEC SQL WHENEVER SQLERROR [ROLLBACK [WORK],] ABORT |
<BR>   EXEC SEQUENCE sequence-name.CURRENT INTO variable |
<BR>   EXEC SEQUENCE sequence-name.NEXT INTO variable |
<BR>   EXEC SEQUENCE sequence-name SET VALUE USING variable
fetch-statement ::= EXEC SQL FETCH cursor-name
post-statement ::= POST EVENT event-name [parameters]
wait-event-statement ::= 
<BR>   WAIT EVENT 
<BR>      [event-specification ...]
<BR>   END WAIT
event-specification ::=
<BR>   WHEN event-name (parameters) BEGIN
<BR>      statements
<BR>   END EVENT
control-statement ::=
<BR>   SET variable-name = value |
<BR>   variable-name := value |
<BR>   WHILE expression 
<BR>      LOOP procedure-statement... END LOOP |
<BR>   LEAVE |
<BR>   IF expression THEN procedure-statement ...
<BR>      [ ELSEIF procedure-statement ... THEN] ...
<BR>      ELSE procedure-statement ... END IF |
<BR>   RETURN | RETURN SQLERROR OF cursor-name | RETURN ROW</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Stored procedures are simple programs, or procedures, that are executed in the server. The user can create a procedure that contains several SQL statements or a whole transaction and execute it with a single call statement.  Usage of stored procedures reduces network traffic and allows more strict control to access rights and database operations.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Procedures are created with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>CREATE PROCEDURE name body 
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>and dropped with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>DROP PROCEDURE name
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Procedures are called with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>CALL name [parameter ...]
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Procedures can take several input parameters and return a single row or several rows as a result. The result is built from specified output parameters. Procedures are thus used in ODBC in the same way as the SQL SELECT statement.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Procedures are owned by the creator of the procedure. Specified access rights can be granted to other users. When the procedure is run, it has the creator's access rights to database objects.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The stored procedure syntax is a proprietary syntax modeled from SQL3 specifications and dynamic SQL. Procedures contain control statements and SQL statements.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The following control statements are available in the procedures:
</BLOCKQUOTE>
<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=240 VALIGN=top >
<P><B>Control statement</B>
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E728"></A>
<P>Description</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>set <I>variable</I> = <I>expression</I>
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E729"></A>
<P>Assigns a value to a variable. The value can be either a literal value (e.g., 10 or 'text') or another variable. Parameters are considered as normal variables.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P><I>variable</I> := <I>expression</I>
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E730"></A>
<P>Alternate syntax for assigning values to variables.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>while
<BR>   <I>expr</I>
<BR>loop
<BR>   <I>statement-list</I>
<BR>end loop
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E731"></A>
<P>Loops while expression is true.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>leave
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E732"></A>
<P>Leaves the innermost while loop and continues executing the procedure from the next statement after the keyword end loop.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>if
<BR>   <I>expr</I>
<BR>then
<BR>   <I>statement-list1</I>
<BR>else
<BR>   <I>statement-list2</I>
<BR>end if
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E733"></A>
<P>Executes <I>statements-list1</I> if expression <I>expr</I> is true,;otherwise, executes <I>statement-list2</I>.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>if
<BR>   <I>expr1</I>
<BR>then
<BR>   <I>statement-list1</I>
<BR>elseif
<BR>   <I>expr2</I>
<BR>then
<BR>   <I>statement-list2</I>
<BR>end if
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E734"></A>
<P>If <I>expr1</I> is true, executes <I>statement-list1</I>. If <I>expr2</I> is true, executes <I>statement-list2</I>. The statement can optionally contain multiple <I>elseif</I> statements and also an <I>else</I> statement.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>return
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E735"></A>
<P>Returns the current values of output parameters and exits the procedure. If a procedure has a one <I>return row</I> statement, <I>return</I> behaves like <I>return </I><I>norow</I>.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>return sqlerror of <I>cursor-name</I>
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E736"></A>
<P>Returns the sqlerror associated with the cursor and exits the procedure.</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>return row
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E737"></A>
<P>Returns the current values of output parameters and continues execution. (requires SOLID <I>Server</I> Version 2.2 or later)</TD>
</TR>
<TR>
<TD WIDTH=240 VALIGN=top >
<P>return norow
</TD><TD WIDTH=216 VALIGN=top >
<A NAME="E7E738"></A>
<P>Returns the end of the set and exits the procedure. (requires SOLID <I>Server</I> Version 2.2 or later)</TD></TR>
</TABLE></BLOCKQUOTE></BLOCKQUOTE>

<BLOCKQUOTE>
<P>All SQL DML and DDL statements can be used in procedures. Thus the procedure can, e.g., create tables or commit a transaction. Each SQL statement in the procedure is atomic. 
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Preparing SQL Statements</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The SQL statements are first prepared with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL PREPARE <I>cursor</I> <I>sql-statement</I></PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>The <I>cursor</I> specification is a cursor name that must be given. It can be any unique cursor name inside the transaction. Note that if the procedure is not a complete transaction, other open cursors outside the procedure may have conflicting cursor names.
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Executing Prepared SQL Statements</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The <I>SQL statement</I> is executed with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL EXECUTE <I>cursor </I>[<I>opt-using </I>] [<I>opt-into </I>]</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>The optional <I>opt-using</I> specification has the syntax
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>USING (<I>variable-list</I>)</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>where <I>variable-list</I> contains a list of procedure variables or parameters separated by a comma. These variables are input parameters for the SQL statement. The SQL input parameters are marked with the standard question mark syntax in the prepare statement. If the SQL statement has no input parameters, the USING specification is ignored.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The optional <I>opt-into</I> specification has the syntax
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>INTO (<I>variable-list</I>)</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>where <I>variable-list</I> contains the variables that the column values of the SQL SELECT statement are stored into. The INTO specification is effective only for SQL SELECT statements. 
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Fetching Results</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Rows are fetched with the statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL FETCH <I>cursor</I></PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>If the fetch completed successfully, the column values are stored into the variables defined in the <I>opt-into</I> specification.
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Checking for Errors</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The result of each EXEC SQL statement executed inside a procedure body is stored into the variable SQLSUCCESS. This variable is automatically generated for every procedure. If the previous SQL statement was successful, a value one is stored into SQLSUCCESS. After a failed SQL statement, a value zero is stored into SQLSUCCESS.
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL WHENEVER SQLERROR [ROLLBACK [WORK],] ABORT</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>is used to decrease the need for IF NOT SQLSUCCESS THEN tests after every executed SQL statement in a procedure. When this statement is included in a stored procedure all return values of executed statements are checked for errors. If statement execution returns an error, the procedure is automatically aborted. Optionally the transaction can be rolled back.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>This statement can be used with SOLID <I>Server</I> Version 2.2 or later.
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Using Transactions</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL {COMMIT | ROLLBACK} WORK</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>is used to terminate transactions.
</BLOCKQUOTE>
<BLOCKQUOTE>
<PRE>EXEC SQL SET TRANSACTION {READ ONLY | READ WRITE}</PRE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>is used to control the type of transactions.
</BLOCKQUOTE>
<BLOCKQUOTE>
<H4>
<FONT FACE="Arial"><B>Using Sequencer Objects and Event Alerts</B></FONT></H4>
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Refer to the usage of the CREATE SEQUENCE and CREATE EVENT statements.
</BLOCKQUOTE>
<H4>Example 1</H4>
<BLOCKQUOTE>
<PRE>create procedure &quot;test2(tableid integer) 
<BR>   returns (cnt integer)
<BR>begin
<BR>   exec sql prepare c1 select count(*) from
<BR>      sys_tables where id &gt; ?;
<BR>   exec sql execute c1 using (tableid) into 
<BR>      (cnt);
<BR>   exec sql fetch c1;
<BR>end&quot;;</PRE></BLOCKQUOTE>
<H4>Example 2</H4>
<BLOCKQUOTE>
<PRE>-- This procedure can only be used with SOLID Server    -- version 2.2 or later.
create procedure &quot;return_tables
<BR>returns (name varchar)
<BR>begin
<BR>        exec sql whenever sqlerror rollback, abort;
<BR>        exec sql prepare c1 select table_name 
<BR>             from sys_tables;
<BR>        exec sql execute c1 into (name);
<BR>        while sqlsuccess loop
<BR>            exec sql fetch c1;
<BR>            return row;
<BR>        end loop;
<BR>end&quot;;</PRE></BLOCKQUOTE>
<A NAME="E10E78"></A>
<P>
<FONT FACE="Arial"><B>CREATE ROLE</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE ROLE role-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Creates a new user role.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE ROLE GUEST_USERS;</PRE></BLOCKQUOTE>
<A NAME="E10E79"></A>
<P>
<FONT FACE="Arial"><B>CREATE SEQUENCE</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE [DENSE] SEQUENCE sequence-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Sequencer objects are objects that are used to get sequence numbers.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Using a dense sequence guarantees that there are no holes in the sequence numbers. The sequence number allocation is bound to the current transaction. If the transaction rolls back, also the sequence number allocations are rolled back. The drawback of dense sequences is that the sequence is locked out from other transactions until the current transaction ends.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Using a sparse sequence guarantees uniqueness of the returned values, but they are not bound to the current transaction. If a transaction allocates a sparse sequence number and later rolls back, the sequence number is simply lost.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The advantage of using a sequencer object instead of a separate table is that the sequencer object is specifically fine-tuned for fast execution and requires less overhead than normal update statements.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Sequences are accessed from stored procedures. The current sequence value can be retrieved using the following stored procedure statement:
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>EXEC SEQUENCE sequence-name.CURRENT INTO variable
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The new sequence value can be retrieved using the following stored procedure statement:
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>EXEC SEQUENCE sequence-name.NEXT INTO variable
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Sequence values can be set with the following stored procedure statement:
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>EXEC SEQUENCE sequence-name SET VALUE USING variable
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>Select access rights are required to retrieve the current sequence value. Update access rights are required to allocate new sequence values. These access rights are granted and revoked in the same way as table access rights.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE DENSE SEQUENCE SEQ1;</PRE></BLOCKQUOTE>
<A NAME="E10E80"></A>
<P>
<FONT FACE="Arial"><B>CREATE TABLE</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE TABLE base-table-name
<BR>   (column-element [, column-element] ...)
base-table-name ::= base-table-identifier | 
<BR>   schema-name.base-table-identifier
column-element ::= column-definition |
<BR>   table-constraint-definition
column-definition ::= column-identifier
<BR>   <I>data-type</I>
<BR>      [column-constraint-definition
<BR>         [column-constraint-definition] ...]
column-constraint-definition ::=
<BR>   NOT NULL | NOT NULL UNIQUE |
<BR>   NOT NULL PRIMARY KEY | CHECK (<I>check-condition</I>)
table-constraint-definition ::=
<BR>   UNIQUE (column-identifier
<BR>      [, column-identifier] ...) |
<BR>   PRIMARY KEY (column-identifier
<BR>      [, column-identifier] ...) |
<BR>   CHECK (<I>check-condition</I>) |
<BR>   FOREIGN KEY (column-identifier
<BR>      [, column-identifier] ...)
<BR>      REFERENCES <I>table-name</I>
<BR>       (column-identifier [, column-identifier] ...)</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Tables are created through the CREATE TABLE statement. The CREATE TABLE statement requires a list of the columns created, the data types, and, if applicable, sizes of values within each column, in addition to other related alternatives (such as whether or not null values are permitted).
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE TABLE DEPT (DEPTNO INTEGER NOT NULL, DNAME VARCHAR, PRIMARY KEY(DEPTNO));
CREATE TABLE DEPT2 (DEPTNO INTEGER NOT NULL PRIMARY KEY, DNAME VARCHAR);
CREATE TABLE DEPT3 (DEPTNO INTEGER NOT NULL UNIQUE, DNAME VARCHAR);
CREATE TABLE DEPT4 (DEPTNO INTEGER NOT NULL, DNAME VARCHAR, UNIQUE(DEPTNO));
CREATE TABLE EMP (DEPTNO INTEGER, ENAME VARCHAR, FOREIGN KEY (DEPTNO) REFERENCES DEPT (DEPTNO));
CREATE TABLE EMP2 (DEPTNO INTEGER, ENAME VARCHAR, CHECK (ENAME IS NOT NULL), FOREIGN KEY (DEPTNO) REFERENCES DEPT (DEPTNO));</PRE></BLOCKQUOTE>
<A NAME="E10E81"></A>
<P>
<FONT FACE="Arial"><B>CREATE USER</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE<I> </I>USER user-name IDENTIFIED BY password</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Creates a new user with a given password.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>CREATE USER HOBBES IDENTIFIED BY CALVIN;</PRE></BLOCKQUOTE>
<A NAME="E10E82"></A>
<P>
<FONT FACE="Arial"><B>CREATE VIEW</B></FONT>
<BLOCKQUOTE>
<PRE>CREATE VIEW viewed-table-name
<BR>   [(column-identifier
<BR>      [, column-identifier]... )]
<BR>   AS <I>query-specification</I></PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>A view can be viewed as a virtual table; that is, a table that does not physically exist, but rather is formed by a query specification against one or more tables.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>CREATE VIEW TEST_VIEW
<BR>   (VIEW_I, VIEW_C, VIEW_ID)
<BR>   AS SELECT I, C, ID FROM TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E83"></A>
<P>
<FONT FACE="Arial"><B>DELETE</B></FONT>
<BLOCKQUOTE>
<PRE>DELETE FROM <I>table-name</I>
<BR>   [WHERE <I>search-condition</I>]</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>Depending on your search condition the specified row(s) will be deleted from a given table.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DELETE FROM TEST WHERE ID = 5;
DELETE FROM TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E84"></A>
<P>
<FONT FACE="Arial"><B>DELETE (positioned)</B></FONT>
<BLOCKQUOTE>
<PRE>DELETE FROM <I>table-name</I> WHERE CURRENT OF cursor-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The positioned DELETE statement deletes the current row of the cursor.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>DELETE FROM TEST WHERE CURRENT OF MY_CURSOR;</PRE></BLOCKQUOTE>
<A NAME="E10E85"></A>
<P>
<FONT FACE="Arial"><B>DROP EVENT</B></FONT>
<BLOCKQUOTE>
<PRE>DROP EVENT event-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP EVENT statement removes the specified event from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP EVENT EVENT-TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E86"></A>
<P>
<FONT FACE="Arial"><B>DROP INDEX</B></FONT>
<BLOCKQUOTE>
<PRE>DROP INDEX index-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP INDEX statement removes the specified index from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP INDEX UX_TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E87"></A>
<P>
<FONT FACE="Arial"><B>DROP PROCEDURE</B></FONT>
<BLOCKQUOTE>
<PRE>DROP PROCEDURE procedure-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP PROCEDURE statement removes the specified procedure from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP PROCEDURE PROCTEST;</PRE></BLOCKQUOTE>
<A NAME="E10E88"></A>
<P>
<FONT FACE="Arial"><B>DROP ROLE</B></FONT>
<BLOCKQUOTE>
<PRE>DROP ROLE role-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP ROLE statement removes the specified role from the database.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>DROP ROLE GUEST_USERS;</PRE></BLOCKQUOTE>
<A NAME="E10E89"></A>
<P>
<FONT FACE="Arial"><B>DROP SEQUENCE</B></FONT>
<BLOCKQUOTE>
<PRE>DROP SEQUENCE sequence-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP SEQUENCE statement removes the specified sequence from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP SEQUENCE SEQ1;</PRE></BLOCKQUOTE>
<A NAME="E10E90"></A>
<P>
<FONT FACE="Arial"><B>DROP TABLE</B></FONT>
<BLOCKQUOTE>
<PRE>DROP TABLE base-table-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP TABLE statement removes the specified table from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP TABLE TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E91"></A>
<P>
<FONT FACE="Arial"><B>DROP USER</B></FONT>
<BLOCKQUOTE>
<PRE>DROP USER user-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP USER statement removes the specified user from the database.
</BLOCKQUOTE>
<H4>Example </H4>
<BLOCKQUOTE>
<PRE>DROP USER HOBBES;</PRE></BLOCKQUOTE>
<A NAME="E10E92"></A>
<P>
<FONT FACE="Arial"><B>DROP VIEW</B></FONT>
<BLOCKQUOTE>
<PRE>DROP VIEW viewed-table-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The DROP VIEW statement removes the specified view from the database.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>DROP VIEW TEST_VIEW;</PRE></BLOCKQUOTE>
<A NAME="E10E93"></A>
<P>
<FONT FACE="Arial"><B>EXPLAIN PLAN FOR</B></FONT>
<BLOCKQUOTE>
<PRE>EXPLAIN PLAN FOR sql-statement</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The EXPLAIN PLAN FOR statement shows the selected search plan for the specified SQL statement.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>EXPLAIN PLAN FOR select * from tables;</PRE></BLOCKQUOTE>
<A NAME="E10E94"></A>
<P>
<FONT FACE="Arial"><B>GRANT</B></FONT>
<BLOCKQUOTE>
<PRE>GRANT {ALL | grant-privilege
<BR>   [, grant-privilege]...}
<BR>   ON <I>table-name</I>
<BR>   TO {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }
   [WITH GRANT OPTION]
GRANT role-name TO user-name
grant-privilege<I> </I>::= DELETE | INSERT | SELECT |
<BR>   UPDATE [( column-identifier
<BR><I>      </I>[, column-identifier]...<I> </I>)] |
<BR>   REFERENCES [( column-identifier
<BR><I>      </I>[, column-identifier]...<I> </I>)]
GRANT EXECUTE ON procedure-name 
<BR>   TO {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }
GRANT {SELECT | INSERT} ON event-name
<BR>   TO {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }
GRANT {SELECT | UPDATE} ON sequence-name
<BR>   TO {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The GRANT statement is 
</BLOCKQUOTE>
<UL>
<BLOCKQUOTE>
<LI>1. used to grant privileges to the specified user or role.
</BLOCKQUOTE>
<BLOCKQUOTE>
<LI>2. used to grant privileges to the specified user by giving 
<BR>the user the privileges of the specified role.
</BLOCKQUOTE></UL>
<BLOCKQUOTE>
<P>If you do use the optional WITH GRANT OPTION, you give permission for the user(s) to whom you are granting the privilege to pass it on to other users.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>GRANT GUEST_USERS TO CALVIN;
GRANT INSERT, DELETE ON TEST TO GUEST_USERS;</PRE></BLOCKQUOTE>
<A NAME="E10E95"></A>
<P>
<FONT FACE="Arial"><B>INSERT</B></FONT>
<BLOCKQUOTE>
<PRE>INSERT INTO <I>table-name</I> [(column-identifier
<BR>      [, column-identifier]...)]
<BR>   VALUES (insert-value[, insert-value]... )</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>There are several variations of the INSERT statement. In the simplest instance, a value is provided for each column of the new row in the order specified at the time the table was defined (or altered). In the preferable form of the INSERT statement the columns are specified as part of the statement and they needn&#146;t to be in any specific order as long as the orders of the column and value lists match with one another.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>INSERT INTO TEST (C, ID) VALUES (0.22, 5);
INSERT INTO TEST VALUES (0.35, 9);</PRE></BLOCKQUOTE>
<A NAME="E10E96"></A>
<P>
<FONT FACE="Arial"><B>INSERT (Using Query)</B></FONT>
<BLOCKQUOTE>
<PRE>INSERT INTO <I>table-name</I> [( column-identifier
<BR>   [, column-identifier]... )]
<BR>   <I>query-specification</I></PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The query specification creates a virtual table. Using the INSERT statement the rows of created virtual table are inserted into the specified table (the degree and data types of the virtual table and inserted columns must match).
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>INSERT INTO TEST (C, ID) SELECT A, B FROM INPUT_TO_TEST;</PRE></BLOCKQUOTE>
<A NAME="E10E97"></A>
<P>
<FONT FACE="Arial"><B>REVOKE (Role from User)</B></FONT>
<BLOCKQUOTE>
<PRE>REVOKE {role-name [, role-name]... }
<BR>   FROM {PUBLIC | user-name [, user-name]... }</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The REVOKE statement is used to take a role away from users.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>REVOKE GUEST_USERS FROM HOBBES;</PRE></BLOCKQUOTE>
<A NAME="E10E98"></A>
<P>
<FONT FACE="Arial"><B>REVOKE (Privilege from Role or User)</B></FONT>
<BLOCKQUOTE>
<PRE>REVOKE
<BR>   {revoke-privilege [, revoke-privilege]... }
<BR>   ON <I>table-name</I>
<BR>   FROM {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }
revoke-privilege ::= DELETE | INSERT |
<BR>   SELECT | UPDATE | REFERENCES
REVOKE EXECUTE ON procedure-name
<BR>   FROM {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }
REVOKE {SELECT | INSERT} ON event-name FROM
<BR>   {PUBLIC | user-name [, user-name]... |
<BR>       role-name [, role-name]... }
REVOKE {SELECT | INSERT} ON sequence-name
<BR>   FROM {PUBLIC | user-name [, user-name]... |
<BR>      role-name [, role-name]... }</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The REVOKE statement is used to take privileges away from users and roles.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>REVOKE INSERT ON TEST FROM GUEST_USERS;</PRE></BLOCKQUOTE>
<A NAME="E10E99"></A>
<P>
<FONT FACE="Arial"><B>ROLLBACK</B></FONT>
<BLOCKQUOTE>
<PRE>ROLLBACK WORK</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The changes made in the database are discarded by ROLLBACK statement. It terminates the transaction.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>ROLLBACK WORK;</PRE></BLOCKQUOTE>
<A NAME="E10E100"></A>
<P>
<FONT FACE="Arial"><B>SELECT</B></FONT>
<BLOCKQUOTE>
<PRE>SELECT [ALL | DISTINCT] <I>select-list</I>
<BR>   FROM <I>table-reference-list</I>
<BR>   [WHERE <I>search-condition</I>]
<BR>   [GROUP BY column-name [, column-name]... ]
<BR>   [HAVING <I>search-condition</I>]
<BR>   [[UNION | INTERSECT | EXCEPT] [ALL] 
<BR>      select-statement]...
<BR>   [ORDER BY {unsigned integer | column-name}
<BR>      [ASC|DESC]]</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The SELECT statement is used to retrieve information.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>SELECT ID FROM TEST;
SELECT DISTINCT ID, C FROM TEST WHERE ID = 5;
SELECT DISTINCT ID FROM TEST ORDER BY ID ASC;
SELECT NAME, ADDRESS FROM CUSTOMERS UNION SELECT NAME, DEP FROM PERSONNEL;</PRE></BLOCKQUOTE>
<A NAME="E10E101"></A>
<P>
<FONT FACE="Arial"><B>SET</B></FONT>
<BLOCKQUOTE>
<PRE>SET SQL INFO {ON | OFF} [FILE {file-name |
<BR>      &quot;file-name&quot; | 'file-name'}]
<BR>   [LEVEL info-level]
SET SQL SORTARRAYSIZE {array-size | DEFAULT}
SET SQL JOINPATHSPAN {path-span | DEFAULT}
SET SQL CONVERTORSTOUNIONS
<BR>   {YES [COUNT value] | NO | DEFAULT}
SET LOCK TIMEOUT timeout-in-seconds
SET STATEMENT MAXTIME minutes
SET TRANSACTION READ ONLY
SET TRANSACTION READ WRITE
SET TRANSACTION CHECK WRITESET
SET TRANSACTION CHECK READSET
SET TRANSACTION ISOLATION LEVEL READ COMMITTED
SET TRANSACTION ISOLATION LEVEL
<BR>   REPEATABLE READ
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>All the settings a re per user settings unlike the settings in the solid.ini file.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>In SQL INFO the default file is a global soltrace.out shared by all users. If the file name is given, all future INFO ON settings will use that file unless a new file is set. It is recommended that the file name is given in single quotes, because otherwise the file name is converted to uppercase. The info output is appended to the file and the file is never truncated, so after the info file is not needed anymore, the user must manually delete the file. If the file open fails, the info output is silently discarded.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The default SQL INFO LEVEL is 4. A good way to generate useful info output is to set info on with a new file name and then execute the SQL statement using EXPLAIN PLAN FOR syntax. This method gives all necessary estimator information but does not generate output from the fetches which may generate a huge output file.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The sort array is used for in memory sorts in the SQL interpreter. The minimum value for SORTARRAYSIZE is 100. If a smaller value is given, minimum value 100 will be used. If large sorts are needed, it is recommended that the external sorter facility is used (in Sorter section in solid.ini) instead on using very large SORTARRAYSIZE.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The COUNT parameter in SQL CONVERTORSTOUNIONS tells how many ors are converted to unions. The default is 10 which should be enough in most cases.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>SET STATEMENT MAXTIME sets connection specific maximum execution time in minutes. Setting is effective until a new maximum time if set. Zero time means no maximum time, which is also the default.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The SET TRANSACTION settings are borrowed from ANSI SQL. It sets the transaction isolation level.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>SET SQL INFO ON FILE 'sqlinfo.txt' LEVEL 5</PRE></BLOCKQUOTE>
<A NAME="E10E102"></A>
<P>
<FONT FACE="Arial"><B>SET SCHEMA</B></FONT>
<BLOCKQUOTE>
<PRE>SET SCHEMA {USER | 'user-name'}</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>From version 2.2 SOLID <I>Server</I> supports SQL89 style schemas for database entity name qualifying.  All created database entities belong to a schema, and different schemas may contain entities with same name.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The default schema can be changed with the SET SCHEMA statement. Schema can be change to the current user name by using the SET SCHEMA USER statement. Alternatively schema can be set to &#145;user-name&#146; which must be a valid user name in the database. 
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The algorithm to resolve entity names [schema-name.]table-identifier is the following:
<BR>
<BR>1. If schema-name is given then table-identifier is searched only from that schema.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>2. If schema-name is not given, then
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>a. First table-identifier is searched from default schema. Default schema is initially the same as user name, but can be changed with SET SCHEMA statement
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>b. Then table-identifier is searched from all schemas in the database. If more than one entity with same table-identifier and type (table, procedure, ...) is found, a new error code 13110 (Ambiguous entity name table-identifier ) is returned.
</BLOCKQUOTE>
<BLOCKQUOTE>
<P>The SET SCHEMA statement effects only to default entity name resolution and it does not change any access rights to database entities. It sets the default schema name for unqualified names in statements that are prepared in the current session by an execute immediate statement or a prepare statement.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>SET SCHEMA 'CUSTOMERS'</PRE></BLOCKQUOTE>
<A NAME="E10E103"></A>
<P>
<FONT FACE="Arial"><B>UPDATE (Positioned)</B></FONT>
<BLOCKQUOTE>
<PRE>UPDATE <I>table-name</I>
<BR>   SET [<I>table-name.</I>]column-identifier = {<I>expression</I> | 
<BR>      NULL}
<BR>   [, [<I>table-name.</I>]column-identifier = {<I>expression</I> |
<BR>      NULL}]...
<BR>   WHERE CURRENT OF cursor-name</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The positioned UPDATE statement updates the current row of the cursor. The name of the cursor is defined using ODBC API function named SQLSetCursorName.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>UPDATE TEST SET C = 0.33
<BR>WHERE CURRENT OF MYCURSOR</PRE></BLOCKQUOTE>
<A NAME="E10E104"></A>
<P>
<FONT FACE="Arial"><B>UPDATE (Searched)</B></FONT>
<BLOCKQUOTE>
<PRE>UPDATE <I>table-name</I>
<BR>   SET [<I>table-name.</I>]column-identifier = {<I>expression</I> |
<BR>      NULL}
<BR>   [, [<I>table-name.</I>]column-identifier = {<I>expression</I> |
<BR>      NULL}]...
<BR>   [WHERE <I>search-condition</I>]</PRE></BLOCKQUOTE>
<H4>Usage</H4>
<BLOCKQUOTE>
<P>The UPDATE statement is used to modify the values of one or more columns in one or more rows, according the search conditions.
</BLOCKQUOTE>
<H4>Example</H4>
<BLOCKQUOTE>
<PRE>UPDATE TEST SET C = 0.44 WHERE ID = 5</PRE></BLOCKQUOTE>
<A NAME="E10E105"></A>
<P>
<FONT FACE="Arial"><B>Table-reference</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Table-reference</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>table-reference-list
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E739"></A>
<P>::= table-reference [ , table-reference &#133; ] </TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>table-reference
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E740"></A>
<P>::= table-name [[AS] correlation-name] | outer-join
<BR><I>( A SELECT statement can contain only one </I>
<BR><I>table-reference that is an outer-join.)</I></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>table-name
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E741"></A>
<P>::= table-identifier | schema-name.table-identifier</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>outer-join
</TD><TD WIDTH=300 VALIGN=top >
<P>::= table-name LEFT [OUTER] JOIN 
<BR><!--{-->table-name<!-- | outer-join} --> ON search-condition</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E106"></A>
<P>
<FONT FACE="Arial"><B>Query-specification</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Query-specification</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>query-specification
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E742"></A>
<P>::= SELECT [DISTINCT | ALL] select-list 
<BR>table-expression</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>select-list
</TD><TD WIDTH=300 VALIGN=top >
<P>::= * | select-sublist 
<BR>[ {, select-sublist} ... ]</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>select-sublist
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E743"></A>
<P>::= derived-column | 
<BR>[table-name | table-identifier].*</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>derived-column
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E744"></A>
<P>::= expression [ [AS] column-alias] ]  </TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>table-expression
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E745"></A>
<P>::= FROM table-reference-list 
<BR>[WHERE search-condition]
<BR>[GROUP BY column-name [, column-name] ...]
<BR>[[UNION | INTERSECT | EXCEPT] [ALL] 
<BR>query-specification]
<BR>[HAVING search-condition]</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E107"></A>
<P>
<FONT FACE="Arial"><B>Search-condition</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Search-condition</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>search-condition 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E746"></A>
<P>::= search-item | search-item { AND | OR } 
<BR>search-item</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>search-item 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E747"></A>
<P>::= [NOT] { search-test | 
<BR>(search-condition) }</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>search-test 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E748"></A>
<P>::= comparison-test | between-test | 
<BR>like-test | null-test | set-test | 
<BR>quantified-test | existence-test</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>comparison-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E749"></A>
<P>::= expression { = | &lt;&gt; | &lt; | &lt;= | &gt; | &gt;= }
<BR>{ expression | subquery }</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>between-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E750"></A>
<P>::= column-identifier [NOT] BETWEEN 
<BR>expression  AND expression</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>like-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E751"></A>
<P>::= column-identifier [NOT] LIKE value 
<BR>[ESCAPE value]</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>null-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E752"></A>
<P>::= column-identifier IS [NOT] NULL</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>set-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E753"></A>
<P>::= expression [NOT] IN ( { value 
<BR>[,value]... | subquery } )</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>quantified-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E754"></A>
<P>::= expression { = | &lt;&gt; | &lt; | &lt;= | &gt; | &gt;= } 
<BR>[ALL | ANY | SOME] subquery</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>existence-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E755"></A>
<P>::= EXISTS subquery</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>subquery
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E756"></A>
<P>::= (query-specification)</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E108"></A>
<P>
<FONT FACE="Arial"><B>Check-condition</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Check-condition</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>check-condition 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E757"></A>
<P>::= check-item | check-item { AND | OR } 
<BR>check-item</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>check-item 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E758"></A>
<P>::= [NOT] { check-test | 
<BR>(check-condition) }</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>check-test 
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E759"></A>
<P>::= comparison-test | between-test | 
<BR>like-test | null-test | list-test</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>comparison-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E760"></A>
<P>::= expression { = | &lt;&gt; | &lt; | &lt;= | &gt; | &gt;= }
<BR>{ expression | <I>subquery</I> }</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>between-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E761"></A>
<P>::= column-identifier [NOT] BETWEEN 
<BR>expression  AND expression</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>like-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E762"></A>
<P>::= column-identifier [NOT] LIKE value 
<BR>[ESCAPE value]</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>null-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E763"></A>
<P>::= column-identifier IS [NOT] NULL</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>list-test
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E764"></A>
<P>::= expression [NOT] IN ( { value 
<BR>[,value]...} )</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E109"></A>
<P>
<FONT FACE="Arial"><B>Expression</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Expression</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>expression
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E765"></A>
<P>::= expression-item | expression-item 
<BR>{ + | - | * | / } expression-item</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>expression-item
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E766"></A>
<P>::= [ + | - ] { value | column-identifier | function |
<BR>( expression ) }</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>value
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E767"></A>
<P>::= literal | USER | variable</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E768"></A>
<P>::= COUNT(*) | distinct-function | all-function | 
<BR>null-function | scalar-function | case-expression</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>distinct-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E769"></A>
<P>::= { AVG | MAX | MIN | SUM | COUNT } 
<BR>( DISTINCT column-identifier )</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>all-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E770"></A>
<P>::= { AVG | MAX | MIN | SUM | COUNT } 
<BR>( [ ALL ] expression )</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>null-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E771"></A>
<P>::= { NULLVAL_CHAR( ) | NULLVAL_INT( ) } </TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>scalar-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E772"></A>
<P>::= string-function | numeric-function |
<BR>timedate-function | system-function | datatypeconversion-function</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>string-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E773"></A>
<P>::= ASCII(str-exp) | CHAR(ascii-code) |
<BR>CONCAT(str-exp1, str-exp2) | 
<BR>str-exp1 { + | || } str-exp2 |
<BR>{FN INSERT(str-exp1, start, length, str-exp2)} | LCASE(str-exp) | {FN LEFT(str-exp)} | 
<BR>LENGTH(str-exp) | 
<BR>LOCATE(str-exp1, strexp2 [, start]) | LTRIM(str-exp) | REPEAT(str-exp, count) | RIGHT(str-exp, count) | REPLACE(str-exp1, str-exp2, str-exp3) | 
<BR>RTRIM(str-exp) | SPACE(count) |
<BR>SUBSTRING(str-exp, start, length) | UCASE(str-exp)</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>numeric-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E774"></A>
<P>::= ABS(num-exp) | ACOS(float-exp) | 
<BR>ASIN(float-exp) | ATAN(float-exp) | 
<BR>ATAN2(float-exp1, float-exp2) | CEILING(num-exp) | COS(float-exp) | COT(float-exp) | DEGREES(num-exp) | EXP(float-exp) | FLOOR(num-exp) | 
<BR>LOG(float-exp) | LOG10(float-exp) | 
<BR>MOD(int-exp1, int-exp2) | PI() | 
<BR>POWER(num-exp, int-exp) | RADIANS(num-exp) | ROUND(num-exp, int-exp) | SIGN(num-exp) | SQRT(float-exp) | TAN(float-exp) |
<BR>TRUNCATE(num-exp, int-exp)</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>datetime-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E775"></A>
<P>::= CURDATE() | CURTIME() | 
<BR>DAYNAME(date-exp) | DAYOFMONTH(date-exp) | DAYOFWEEK(date-exp) | DAYOFYEAR(date-exp) | HOUR(time-exp) | MINUTE(time-exp) | MONTH(date-exp) | MONTHNAME(date-exp) | NOW() | QUARTER(date-exp) | SECOND(time-exp) | TIMESTAMPADD(interval, int-exp, timestamp-exp) |
<BR>TIMESTAMPDIFF(interval, timestamp-exp1, timestamp-exp2) | WEEK(date_exp) |YEAR(date_exp)</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>system-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E776"></A>
<P>::= IFNULL(exp, value) | {FN USER()}</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>datatypeconversion-function
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E777"></A>
<P>::= CONVERT_CHAR(value-exp) | CONVERT_DATE(value-exp) | CONVERT_DECIMAL(value-exp) | CONVERT_DOUBLE(value-exp) | CONVERT_FLOAT(value-exp) | CONVERT_INTEGER(value_exp) | CONVERT_LONGVARCHAR(value-exp) | CONVERT_NUMERIC(value-exp) | CONVERT_REAL(value-exp) | CONVERT_SMALLINT(value-exp) | CONVERT_TIME(value-exp) | CONVERT_TIMESTAMP(value-exp) | CONVERT_TINYINT(value-exp) | CONVERT_VARCHAR(value-exp)</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>case-expression
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E778"></A>
<P>CASE value-exp 
<BR>    WHEN value-exp
<BR>      THEN {value-exp}
<BR>   [WHEN value-exp
<BR>      THEN {value-exp} &#133;]
<BR>    ELSE {value-exp}</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E110"></A>
<P>
<FONT FACE="Arial"><B>Data-type</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Data-type</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>data-type
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E779"></A>
<P>::= {BINARY |
<BR> CHAR [ length ] |
<BR> DATE |
<BR> DECIMAL [ ( precision [ , scale ] ) ] |
<BR> DOUBLE PRECISION |
<BR> FLOAT [ ( precision ) ] |
<BR> INTEGER |
<BR> LONG VARBINARY |
<BR> LONG VARCHAR |
<BR> NUMERIC [ ( precision [ , scale ] ) ] |
<BR> REAL |
<BR> SMALLINT |
<BR> TIME |
<BR> TIMESTAMP [ ( timestamp precision ) ] |
<BR> TINYINT |
<BR> VARBINARY |
<BR> VARCHAR [ ( length ) ] }</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E111"></A>
<P>
<FONT FACE="Arial"><B>Dat</B><B>e and Time Literal</B><B>s</B></FONT>

<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Date/time literal</B>
</TD><TD WIDTH=300 VALIGN=top ><BR></TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>date-literal
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E780"></A>
<P>&#180;YYYY-MM-DD&#180;</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>time-literal
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E781"></A>
<P>&#180;HH:MM:SS&#180;</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>timestamp-literal
</TD><TD WIDTH=300 VALIGN=top >
<A NAME="E7E782"></A>
<P>&#180;YYYY-MM-DD HH:MM:SS&#180;</TD></TR></TABLE></BLOCKQUOTE><A NAME="E10E112"></A>
<P>
<FONT FACE="Arial"><B>Pseudo Columns</B></FONT>
<BLOCKQUOTE>
<P>The following pseudo columns may also be used in the select-list of a SELECT statement:
</BLOCKQUOTE>
<BLOCKQUOTE><TABLE>
<TR>
<TD WIDTH=156 VALIGN=top >
<P><B>Pseudo column</B>
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E783"></A>
<P>Type
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E783"></A>
<P>Explanation</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>ROWVER
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E784"></A>
<P>VARBINARY(254)
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E784"></A>
<P>Version of the row in a table. </TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>ROWID 
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E785"></A>
<P>VARBINARY(10)
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E785"></A>
<P>Persistent id for a row in a table.</TD>
</TR>
<TR>
<TD WIDTH=156 VALIGN=top >
<P>ROWNUM
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E786"></A>
<P>DECIMAL(16,2)
</TD><TD WIDTH=150 VALIGN=top >
<A NAME="E7E786"></A>
<P>Row number indicates the sequence in which a row was selected from a table or set of joined rows. The first row selected has a ROWNUM of 1, the second row has 2, etc. ROWNUM is chiefly useful for limiting the number of rows returned by a query (e.g., WHERE ROWNUM &lt; 10).</TD></TR></TABLE></BLOCKQUOTE>
<BLOCKQUOTE>
<P>NOTE! Since ROWID and ROWVER refer to a single row, they may only be used with queries that return rows from a single table.
</BLOCKQUOTE><P ALIGN=CENTER>
<A HREF="aguide12.htm" TARGET="_self"><IMG SRC="gaguide/graprev.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Previous Page"></A>
<A HREF="httoc.htm" TARGET="_self"><IMG SRC="gaguide/gratop.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="TOC"></A>
<A HREF="htindex.htm" TARGET="_self"><IMG SRC="gaguide/graindex.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Index"></A>
<A HREF="aguide14.htm" TARGET="_self"><IMG SRC="gaguide/granext.gif" WIDTH = 32 HEIGHT = 32 BORDER = 0 ALT="Next Page"></A>

<center><p><font SIZE=-2>Copyright &copy; 1992-1997 Solid Information Technology Ltd All rights reserved.</font></p></center>
</BODY></HTML>