SQL Commands

• The braces { } and brackets [ ] are shown in standard type size.

• Commands and keywords are shown in BOLD UPPERCASE characters

ADD DBEFILE

  ADD DBEFILE DBEFileName TO DBEFILESET DBEFileSetName

ADD TO GROUP

  ADD {DBEUserID
       GroupName
       ClassName }[,...] TO GROUP TargetGroupName

ADVANCE

  ADVANCE CursorName [USING [SQL] DESCRIPTOR {SQLDA
                                              AreaName}]

ALTER DBEFILE

  ALTER DBEFILE DBEFileName SET TYPE = {TABLE
                                        INDEX
                                        MIXED }

ALTER TABLE

  ALTER TABLE [Owner.]TableName {AddColumnSpecification
                                 AddConstraintSpecification
                                 DropConstraintSpecification
                                 SetTypeSpecification
                                 SetPartitionSpecification    }

AddColumnSpecification

  ADD {(ColumnDefinition [,...])
        ColumnDefinition        }
  [CLUSTERING ON CONSTRAINT [ConstraintID]]

AddConstraintSpecification

  ADD CONSTRAINT ({UniqueConstraint
                   ReferentialConstraint
                   CheckConstraint       }[,...])
  [CLUSTERING ON CONSTRAINT [ConstraintID]]

DropConstraintSpecification

  DROP CONSTRAINT {(ConstraintID [,...])
                    ConstraintID         }

SetTypeSpecification

  SET TYPE {PRIVATE
            PUBLICREAD
            PUBLIC
            PUBLICROW  } [RESET AUTHORITY
                          PRESERVE AUTHORITY]

SetPartitionSpecification

  SET PARTITION {PartitionName
                 DEFAULT
                 NONE         }

Assignment (=)

  {:LocalVariable
   :ProcedureParameter}= Expression;

BEGIN

  BEGIN [Statement;] [...] END;

BEGIN ARCHIVE

  BEGIN ARCHIVE

BEGIN DECLARE SECTION

  BEGIN DECLARE SECTION

BEGIN WORK

  BEGIN WORK [Priority] [RR
                         CS
                         RC
                         RU]
    [LABEL {'LabelString'
            :HostVariable}] [[PARALLEL
                              NO       ] FILL]

CHECKPOINT

  CHECKPOINT [:HostVariable
              :LocalVariable
              :ProcedureParameter]

CLOSE

  CLOSE CursorName [USING {[SQL] DESCRIPTOR {SQLDA
                                             Areaname}
    :HostVariable [[INDICATOR]:Indicator][,...] } ]

COMMIT ARCHIVE

  COMMIT ARCHIVE

COMMIT WORK

  COMMIT WORK [RELEASE]

CONNECT

  CONNECT TO {'DBEnvironmentName'
              :HostVariable1      }[AS {'ConnectionName'
                                        :HostVariable2  }]
  [USER {'UserID'
         :HostVariable3}[USING :HostVariable4]]

CREATE DBEFILE

  CREATE DBEFILE DBEFileName WITH PAGES = DBEFileSize,
    NAME = 'SystemFileName'
    [, INCREMENT = DBEFileIncrSize[, MAXPAGES = DBEFileMaxSize]]
    [, TYPE = {TABLE
             INDEX
             MIXED }]

CREATE DBEFILESET

  CREATE DBEFILESET DBEFileSetName

CREATE GROUP

  CREATE GROUP [Owner.]GroupName

CREATE INDEX

  CREATE [UNIQUE][CLUSTERING]INDEX [Owner.]Indexname ON
  [Owner.]TableName ( {ColumnName [ASC
                                   DESC]}[,...])

CREATE PARTITION

  CREATE PARTITION PartitionName WITH ID = PartitionNumber

CREATE PROCEDURE

  CREATE PROCEDURE [Owner.]ProcedureName [LANG = ProcLangName]
  [(ParameterDeclaration [, ParameterDeclaration][...])]
  [WITH RESULT ResultDeclaration [, ResultDeclaration ][...]]
  AS BEGIN [ProcedureStatement][...] END [IN DBEFileSetName]

ParameterDeclaration

  ParameterName ParameterType [LANG = ParameterLanguage]
  [DEFAULT DefaultValue][NOT NULL][OUTPUT[ONLY]]

ResultDeclaration

  ResultType [LANG = ResultLanguage][NOT NULL]

CREATE RULE

  CREATE RULE [Owner.]RuleName
  AFTER StatementType [,...][ON
                             OF
                             FROM
                             INTO} [Owner.]TableName
  [REFERENCING{OLD AS OldCorrellationName
               NEW AS NewCorrelationName}[...]]
                  [WHERE FiringCondition]
  EXECUTE PROCEDURE [OwnerName.]ProcedureName [(ParameterValue
    [,...])]
  [IN DBEFileSetName]

CREATE SCHEMA

  CREATE SCHEMA AUTHORIZATION AuthorizationName [TableDefinition
                                                 ViewDefinition
                                                 IndexDefinition
                                                 ProcedureDefinition
                                                 RuleDefinition
                                                 CreateGroup
                                                 AddToGroup
                                                 GrantStatement  ]
  [...]

CREATE TABLE

  CREATE [PRIVATE
          PUBLICREAD
          PUBLIC
          PUBLICROW ]TABLE [Owner.]TableName
  [LANG = TableLanguageName]
  ({ColumnDefinition
    UniqueConstraint
    ReferentialConstraint
    CheckConstraint       }[,...])
  [UNIQUE HASH ON (HashColumnName [,...]) PAGES = PrimaryPages
   HASH ON CONSTRAINT [ConstraintID] PAGES = PrimaryPages
   CLUSTERING ON CONSTRAINT [ConstraintID]                      ]
  [IN PARTITION {PartitionName
                 DEFAULT
                 NONE          }]
  [IN DBEFileSetName1]

Column Definition

  ColumnName{ColumnDataType
             LongColumnType [IN DBEFileSetName2]}
  [LANG = ColumnLanguageName]
  [[NOT] CASE SENSITIVE]
  [DEFAULT{Constant
           USER
           NULL
           CurrentFunction}]
  [NOT NULL [{UNIQUE
              PRIMARY KEY} [CONSTRAINT ConstraintID]]
   REFERENCES RefTableName [(RefColumnName)][CONSTRAINT ConstraintID]
   [...]

   CHECK (SearchCondition) [CONSTRAINT ConstraintID]
   [IN DBEFileSetName3]                                     ][...]

Unique Constraint (Table Level)

  {UNIQUE
   PRIMARY KEY}(ColumnName [,...]) [CONSTRAINT ConstraintID]

Referential Constraint (Table Level)

  FOREIGN KEY (FKColumnName [,...])
  REFERENCES RefTableName [( RefColumnName [,...])]
    [CONSTRAINT ConstraintID]

Check Constraint (Table Level)

  CHECK (SearchCondition) [CONSTRAINT ConstraintID]
    [IN DBEFileSetName3]

CREATE TEMPSPACE

  CREATE TEMPSPACE TempSpaceName
  WITH [MAXFILEPAGES = MaxTempFileSize,]LOCATION = 'PhysicalLocation'

CREATE VIEW

  CREATE VIEW [Owner.]ViewName [(ColumnName[,...])]
  AS QueryExpression [IN DBEFileSetName]
  [WITH CHECK OPTION [CONSTRAINT ConstraintID]]

DECLARE CURSOR

  DECLARE CursorName [IN DBEFileSetName] CURSOR FOR
  { {QueryExpression
     SelectStatementName}[FOR UPDATE OF {ColumnName}[,...]
                          FOR READ ONLY                   ]
    ExecuteProcedureStatement
    ExecuteStatementName                                  }

DECLARE Variable

  DECLARE { LocalVariable}[,...] VariableType
    {LANG = VariableLangName]
    [DEFAULT {Constant
              NULL
              CurrentFunction}][NOT NULL]

DELETE

  DELETE [WITH AUTOCOMMIT]FROM {[Owner.]TableName
                                [Owner.]ViewName}
                                  [WHERE SearchCondition]

DELETE WHERE CURRENT

  DELETE FROM {[Owner.]TableName
               [Owner.]ViewName} WHERE CURRENT OF CursorName

DESCRIBE

  DESCRIBE [OUTPUT
            INPUT
            RESULT] StatementName {INTO [[SQL] DESCRIPTOR]
                                   USING [SQL] DESCRIPTOR}{SQLDA
                                                           AreaName}

DISABLE AUDIT LOGGING

  DISABLE AUDIT LOGGING

DISABLE RULES

  DISABLE RULES

DISCONNECT

  DISCONNECT {'ConnectionName'
              'DBEnvironmentName'
              :HostVariable
              ALL
              CURRENT              }

DROP DBEFILE

  DROP DBEFILE DBEFileName

DROP DBEFILESET

  DROP DBEFILESET DBEFileSetName

DROP GROUP

  DROP GROUP GroupName

DROP INDEX

  DROP INDEX [Owner.]IndexName [FROM [Owner.]TableName]

DROP MODULE

  DROP MODULE [Owner.]ModuleName [PRESERVE]

DROP PARTITION

  DROP PARTITION PartitionName

DROP PROCEDURE

  DROP PROCEDURE [Owner.]ProcedureName [PRESERVE]

DROP RULE

  DROP RULE [Owner.]RuleName [FROM TABLE [Owner.]TableName]

DROP TABLE

  DROP TABLE [Owner.] TableName

DROP TEMPSPACE

  DROP TEMPSPACE TempSpaceName

DROP VIEW

  DROP VIEW [Owner.] ViewName

ENABLE AUDIT LOGGING

  ENABLE AUDIT LOGGING

ENABLE RULES

  ENABLE RULES

END DECLARE SECTION

  END DECLARE SECTION

EXECUTE

  EXECUTE {StatementName
          [Owner.]ModuleName [(SectionNumber)]}
  [USING{[SQL] DESCRIPTOR{[INPUT]{SQLDA
                                  AreaName1}
                          [AND OUTPUT {SQLDA
                                       AreaName2}]
                          OUTPUT {SQLDA
                                  AreaName}}
         [INPUT]HostVariableSpecification1
         [AND OUTPUT HostVariableSpecification2]
         OUTPUT HostVariableSpecification
         :Buffer [,:StartIndex[,:NumberOfRows]]         }]

HostVariableSpecification

  :HostVariableName [[INDICATOR]:IndicatorVariable ] [,...]

EXECUTE IMMEDIATE

  EXECUTE IMMEDIATE {'String'
                     :HostVariable}

EXECUTE PROCEDURE

  EXECUTE PROCEDURE [:ReturnStatusVariable = ][Owner.]ProcedureName
  [([ActualParameter][,[ActualParameter]][...]) ]

ActualParameter

  [ParameterName = ]ParameterValue [OUTPUT[ONLY]]

FETCH

  [BULK] FETCH CursorName{INTO HostVariableSpecification
                          USING { [SQL] DESCRIPTOR {SQLDA
                                                    AreaName}
                                 HostVariableSpecification} }

BULK HostVariableSpecification

  :Buffer [,:StartIndex [,:NumberOfRows]]

Non-BULK HostVariableSpecification

  {:HostVariable [[INDICATOR]:Indicator ] } [,...]

GENPLAN

  GENPLAN [WITH (HostVariableDefinition)] FOR
  {SQLStatement
   MODULE SECTION [Owner.]ModuleName(Section Number)
   PROCEDURE SECTION [Owner.]ProcedureName(Section Number)}

GOTO

  {GOTO
   GO TO}{Label
          Integer}

GRANT

  GRANT {ALL [PRIVILEGES]
         {SELECT
          INSERT
          DELETE
          ALTER
          INDEX
          UPDATE [({ColumnName}[,...])]
          REFERENCES [({ColumnName}[,...])]} [,...]}
  ON {[Owner.]TableName
      [Owner.]ViewName}TO {DBEUserID
                           GroupName
                           ClassName
                           PUBLIC    } [,...][WITH GRANT OPTION]
  [BY {DBEUserID
       ClassName}]

Grant RUN or EXECUTE Authority

  GRANT {RUN ON [Owner.]ModuleName
         EXECUTE ON PROCEDURE [Owner.]ProcedureName} TO
  {{DBEUserID
    GroupName
    ClassName} [,...]
    PUBLIC            }

Grant CONNECT, DBA, INSTALL, MONITOR, or RESOURCE Authority

  GRANT {CONNECT
         DBA
         INSTALL [AS OwnerID]
         MONITOR
         RESOURCE            } TO {DBEUserID
                                   GroupName
                                   ClassName } [,...]

Grant DBEFileSet Authority

  GRANT {SECTIONSPACE
         TABLESPACE   } [,...] ON DBEFILESET DBEFileSetName TO
  {DBEUserID
   GroupName
   ClassName
   PUBLIC    } [,...]

IF

  IF Condition THEN [Statement; [...]]
  [ELSEIF Condition THEN [Statement; [...]]]
  [ELSE [Statement; [...]]] ENDIF;

INCLUDE

  INCLUDE {SQLCA [[IS]EXTERNAL]
           SQLDA                }

INSERT - 1

  [BULK]INSERT INTO { [Owner.]TableName
                      [Owner.]ViewName}
  [({ColumnName}[,...])]

  VALUES ({SingleRowValues
           BulkValues
           ?               })

SingleRowValues

  {NULL
   USER
   :HostVariable [ [INDICATOR]:IndicatorVariable]
   ?
   :LocalVariable
   :ProcedureParameter
   ::Built-inVariable
   ConversionFunction
   CurrentFunction
   [+ -]{Integer
         Float
         Decimal }
   'CharacterString'
   OxHexadeciamalString
   'LongColumnIOString'  }[,...]

LongColumnIOString

  <{[PathName/]FileName
    %SharedMemoryAddress}
  [{>
    >>
    >!}[PathName/]{FileName
                   CharSting$
                   CharString$ CharString}
    >%{SharedMemoryAddress
       $                   }                ]

BulkValues

  :Buffer [ ,:StartIndex [, :NumberOfRows]]

Dynamic Parameter Substitution

  (? [,...] )

INSERT - 2

  INSERT INTO {[Owner.]TableName
               [Owner.]ViewName}[(ColumnName [,...])] QueryExpression

Labeled Statement

  Label: Statement

LOCK TABLE

  LOCK TABLE [Owner.]TableName IN {SHARE [UPDATE]
                                   EXCLUSIVE      } MODE

LOG COMMENT

  LOG COMMENT {'String'
               :HostVariable
               :ProcedureParameter
               :ProcedureLocalVariable
               ?                        }

OPEN

  OPEN CursorName [KEEP CURSOR [WITH LOCKS
                                WITH NOLOCKS]]
  [USING { [SQL]DESCRIPTOR {SQLDA
                            AreaName}
            HostVariableName[[INDICATOR]:IndicatorVariable][,...]} ]

PREPARE

  PREPARE [REPEAT]{StatementName
                   [Owner.]ModuleName [(SectionNumber)]}
  [IN DBEFileSetName] FROM {'String'
                           :HostVariable}

PRINT

  PRINT {'Constant'
         :LocalVariable
         :Parameter
         ::Built-inVariable};

RAISE ERROR

  RAISE ERROR [ErrorNumber] [MESSAGE ErrorText]

REFETCH

  REFETCH CursorName INTO {:HostVariable [[INDICATOR] :Indicator]}
    [,...]

RELEASE

  RELEASE

REMOVE DBEFILE

  REMOVE DBEFILE DBEFileName FROM DBEFILESET DBEFileSetName

REMOVE FROM GROUP

  REMOVE {DBEuserID
          GroupName
          ClassName}[,...] FROM GROUP [Owner.]TargetGroupName

RENAME COLUMN

  RENAME COLUMN [Owner.]TableName.ColumnName TO NewColumnName

RENAME TABLE

  RENAME TABLE [Owner.]TableName TO NewTableName

RESET

  RESET {SYSTEM.ACCOUNT [FOR USER {*
                                   DBEUserID}]
         SYSTEM.COUNTER                         }

RETURN

  RETURN [ReturnStatus];

REVOKE

Revoke Table or View Authority

  REVOKE {ALL [PRIVILEGES]
          [SELECT
           INSERT
           DELETE
           ALTER
           INDEX
           UPDATE [({ColumnName}[,...])]
           REFERENCES [({ColumnName}[,...])]] [,...]}
  ON {[Owner.]TableName
      [Owner.]ViewName  } FROM {DBEUserID
                                GroupName
                                ClassName
                                PUBLIC    }[,...][CASCADE]

Revoke RUN or EXECUTE Authority

  REVOKE [RUN ON [Owner.]ModuleName
          EXECUTE ON PROCEDURE [Owner.] ProcedureName] FROM
  {{DBEUserID
    GroupName
    ClassName}[,...]
   PUBLIC            }

Revoke CONNECT, DBA, INSTALL, MONITOR, or RESOURCE Authority

  REVOKE {CONNECT
          DBA
          INSTALL [AS OwnerID]
          MONITOR
          RESOURCE             } FROM {DBEUserID
                                      GroupName
                                      ClassName}[,...]

SQL Syntax—Revoke DBEFileSet Authority

  REVOKE {SECTIONSPACE
          TABLESPACE} [,...] ON DBEFILESET DBEFileSetName FROM
  { {DBEUserID
     GroupName
     ClassName}[,...]
     PUBLIC            }

ROLLBACK WORK

  ROLLBACK WORK [TO {SavePointNumber
                     :HostVariable
                     :LocalVariable
                     :ProcedureParameter}
                 RELEASE                  ]

SAVEPOINT

  SAVEPOINT [:HostVariable
             :LocalVariable
             :ProcedureParameter]

SELECT

Select Statement Level

  [BULK]QueryExpression [ORDER BY {ColumnID [ASC
                                             DESC]}[,...]]

Subquery Level

  (QueryExpression)

Query Expression Level

  {QueryBlock
   (QueryExpression)}[UNION [ALL]{QueryBlock
                                  (QueryExpreession)}] [...]

Query Block Level

  SELECT [ALL
          DISTINCT] SelectList [INTO HostVariableSpecification]
  FROM FromSpec [,...]
   [WHERE SearchCondition1]
   [GROUP BY GroupColumnList]
   [HAVING SearchCondition2]

SelectList

  {*
   [Owner.]Table.*
   CorrelationName.*
   Expression
   [[Owner.]Table.]ColumnName
   CorrelationName.ColumnName} [,...]

HostVariableSpecification--With BULK Option

  :Buffer [,:StartIndex [,:NumberOfRows]]

HostVariableSpecification--Without BULK Option

  { :HostVariable [ [INDICATOR] :Indicator] ) [,...]

FromSpec

  {TableSpec
   (FromSpec)
   FromSpec NATURAL [INNER
                     LEFT [OUTER]
                     RIGHT [OUTER]] JOIN {TableSpec
                                          (FromSpec) }
   FromSpec [INNER
             LEFT [OUTER]
             RIGHT [OUTER]] JOIN {TableSpec
                                  (FromSpec)}{ON SearchCondition3
                                              USING (ColumnList) } }

TableSpec

  [Owner.] TableName [CorrelationName]

SET CONNECTION

  SET CONNECTION {'ConnectionName'
                  :HostVariable   }

SET CONSTRAINTS

  SET ConstraintType [,...] CONSTRAINTS {DEFERRED
                                         IMMEDIATE}

SET DEFAULT DBEFILESET

  SET DEFAULT {SECTIONSPACE
               TABLESPACE   } TO DBEFILESET DBEFileSetName FOR PUBLIC

SET DML ATOMICITY

  SET DML ATOMICITY AT {ROW
                        STATEMENT} LEVEL

SET MULTITRANSACTION

  SET MULTITRANSACTION {ON
                        OFF}

SETOPT

  SETOPT {CLEAR
          GENERAL {ScanAccess
                   JoinAlgorithm} [,...]
          BEGIN {GENERAL {ScanAccess
                          JoinAlgorithm} } [,...] END }

Scan Access

  [NO]{SERIALSCAN
       INDEXSCAN
       HASHSCAN
       SORTINDEX }

Join Algorithm

  [NO] {NESTEDLOOP
        NLJ
        SORTMERGE
        SMJ       }

SET PRINTRULES

  SET PRINTRULES [ON
                  OFF]

SET SESSION

  SET SESSION {ISOLATION LEVEL {RR
                                CS
                                RC
                                RU
                                REPEATABLE READ
                                SERIALIZABLE
                                CURSOR STABILITY
                                READ COMMITTED
                                READ UNCOMMITTED
                                :HostVariable1    }
               PRIORITY {Priority
                         :HostVariable2}
               LABEL {'LabelString'
                      :HostVariable3}
               ConstraintType [,...] CONSTRAINTS {DEFERRED
                                                 IMMEDIATE}
               DML ATOMICITY AT {STATEMENT
                                 ROW      } LEVEL
               ON {TIMEOUT
                   DEADLOCK} ROLLBACK {QUERY
                                      TRANSACTION}
               USER TIMEOUT [TO] {DEFAULT
                                  MAXIMUM
                                  TimeoutValue[{SECONDS
                                                MINUTES}]
                                  :HostVariable4[{SECONDS
                                                  MINUTES} ] }
               TERMINATION AT {SESSION
                               TRANSACTION
                               QUERY
                               RESTRICTED   } LEVEL
               [{PARALLEL
                 NO       }] FILL                         }[,...]

SET TRANSACTION

  SET TRANSACTION {ISOLATION LEVEL {RR
                                    CS
                                    RC
                                    RU
                                    REPEATABLE READ
                                    SERIALIZABLE
                                    CURSOR STABILITY
                                    READ COMMITTED
                                    READ UNCOMMITTED
                                    :HostVariable1   }
                   PRIORITY {Priority
                             :HostVariable2}
                   LABEL {'LabelString'
                          :HostVariable3}
                   ConstraintType [,...] CONSTRAINTS {DEFERRED
                                                     IMMEDIATE}
                   DML ATOMICITY AT {STATEMENT
                                     ROW       } LEVEL
                   ON {TIMEOUT
                       DEADLOCK} ROLLBACK {QUERY
                                          TRANSACTION}
                   USER TIMEOUT [TO] {DEFAULT
                                      MAXIMUM
                                      TimeoutValue[{SECONDS
                                                    MINUTES}]
                                      :HostVariable4[{SECONDS
                                                      MINUTES}]
                   TERMINATION AT {SESSION
                                   TRANSACTION
                                   QUERY
                                   RESTRICTED  } LEVEL       }[,...]

SET USER TIMEOUT

  SET USER TIMEOUT [TO] {{TimeoutValue
                          :HostVariable} [SECONDS
                                          MINUTES]
                         DEFAULT
                         MAXIMUM                   }

SQLEXPLAIN

  SQLEXPLAIN :HostVariable

START DBE

  START DBE 'DBEnvironmentName' [AS 'ConnectionName'][MULTI]
  [BUFFER = (DataBufferPages, LogBufferPages)
   TRANSACTION = MaxTransactions
   MAXIMUM TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      NONE                  }
   DEFAULT TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      MAXIMUM               }
   RUN BLOCK = ControlBlockPages             ] [,...]

START DBE NEW

  START DBE 'DBEnvironmentName' [AS 'ConnectionName'][MULTI]NEW
  [{DUAL
    AUDIT}[...] LOG
   BUFFER = (DataBufferPages, LogBufferPages)
   LANG = LanguageName
   TRANSACTION = MaxTransactions
   MAXIMUM TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      NONE                   }
   DEFAULT TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      MAXIMUM                }
   RUN BLOCK = ControlBlockPages
   DEFAULT PARTITION = {DefaultPartitionNumber
                        NONE                   }
   COMMENT PARTITION = {CommentPartitionNumber
                        DEFAULT
                       NONE                   }
   MAXPARTITIONS = MaximumNumberOfPartitions
   AUDIT NAME = 'AuditName'
   {COMMENT
    DATA
    DEFINITION
    STORAGE
    AUTHORIZATION
    SECTION
    ALL             }[...] AUDIT ELEMENTS
   DBEFile0Definition
   DBELogDefinition                                ] [,...]

DBEFile0Definition

  DBEFILE0 DBEFILE DBEDile0ID
  WITH PAGES = DBEFile0Size
  NAME = 'SystemFileName1'

DBELogDefinition

  LOG DBEFILE DBELog1ID [AND DBELog2ID]
  WITH PAGES = DBELogSize,
  NAME = 'SystemFileName2' [AND 'SystemFileName3']

START DBE NEWLOG

  START DBE 'DBEnvironmentName' [AS 'ConnectionName'][MULTI]NEWLOG
  [{ARCHIVE
    DUAL
    AUDIT}[...] LOG
   BUFFER = (DataBufferPages, LogBufferPages)
   TRANSACTION = MaxTransactions
   MAXIMUM TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      NONE                  }
   DEFAULT TIMEOUT = {TimeoutValue [SECONDS
                                    MINUTES]
                      MAXIMUM               }
   RUN BLOCK = ControlBlockPages
   DEFAULT PARTITION = {DefaultPartitionNumber
                        NONE                   }
   COMMENT PARTITION = {CommentPartitionNumber
                        DEFAULT
                        NONE                   }
   MAXPARTITIONS = MaximumNumberOfPartitions
   AUDIT NAME = 'AuditName'
   {COMMENT
    DATA
    DEFINITION
    STORAGE
    AUTHORIZATION
    SECTION
    ALL           }[...] AUDIT ELEMENTS      ][,...] NewLogDefinition

NewLogDefinition

  LOG DBEFILE DBELog1ID [AND DBELog2ID]
  WITH PAGES = DBELogSize,
  NAME = 'SystemFileName1' [AND 'SystemFileName2']

STOP DBE

  STOP DBE

TERMINATE QUERY

  TERMINATE QUERY FOR {CID ConnectionID
                       XID TransactionID}

TERMINATE TRANSACTION

  TERMINATE TRANSACTION FOR {CID ConnectionID
                             XID TransactionID}

TERMINATE USER

  TERMINATE USER {DBEUserID
                  SessionID
                  CID ConnectionID}

TRANSFER OWNERSHIP

  TRANSFER OWNERSHIP OF {[TABLE][Owner.]TableName
                         [VIEW][Owner.]ViewName
                         PROCEDURE [Owner.]ProcedureName
                         GROUP GroupName          } TO NewOwnerName

TRUNCATE TABLE

  TRUNCATE TABLE [Owner.]TableName

UPDATE

  UPDATE {[Owner.]TableName
          [Owner.]ViewName  }
  SET { ColumnName = { Expression
                       'LongColumnIOString'
                       NULL                } } [,...]
  [WHERE SearchCondition ]

LongColumnIOString

  { [<{[PathName/]FileName
       %SharedMemoryAddress}]
    [{>
     >>
      >!}[PathName/]{FileName
                     CharString$
                     CharString$ CharString}
     >% {SharedMemoryAddress
         $                                  } ] } [...]

UPDATE STATISTICS

  UPDATE STATISTICS FOR TABLE {[Owner.]TableName
                                SYSTEM.SystemViewName}

UPDATE WHERE CURRENT

  UPDATE {[Owner.]TableName
          [Owner.]ViewName}
  SET { ColumnName = {Expression
                      'LongColumnIOString'
                      NULL                 }}[,...]
  WHERE CURRENT OF CursorName

LongColumnIOString

  { [<{[PathName/]FileName
       %SharedMemoryAddress}]
    [{>
      >>
      >!}[PathName/]{FileName
                     CharString$
                     CharString$ CharString}
     >% {SharedMemoryAddress
         $                                  } ] } [...]

VALIDATE

  VALIDATE [FORCE
            DROP SETOPTINFO]
  {MODULE { {[Owner.]ModuleName} [,...]
            {SECTION [Owner.]ModuleName (SectionNumber)} [,...] }
   PROCEDURE { {[Owner.]ProcedureName} [,...]
               {SECTION [Owner.]ProcedureName (SectionNumber)}[,...]}
                ALL{MODULES PROCEDURES} [WITH AUTOCOMMIT]           }

WHENEVER

  WHENEVER {SQLERROR
            SQLWARNING
            NOT FOUND   } {STOP
                           CONTINUE
                           GOTO [:]Label
                           GO TO [:]Label}

WHILE

  WHILE Condition DO [Statement; [...]] ENDWHILE;