SqlStatement ::=

DDLStatement ;

| DMLStatement ;

| DCLStatement ;

 

 

 

DDLStatement ::=

AlterTableStatement

| CreateIndexStatement

| CREATE DATABASE DbName IN DirectoryName

| CreateTableStatement

| CreateViewStatement

| DROP INDEX IndexName

| DROP DATABASE DbName

| DROP TABLE TableName

| DROP VIEW ViewName

 

Top
 
DMLStatement ::= 
BEGIN TRANSACTION
| COMMIT
| DELETE FROM TableName [ WHERE Condition ]
| InsertStatement
| ROLLBACK
| SelectStatement 
| UpdateStatement
Top
 
DCLStatement ::=
 
        CONNECT DatabaseName
        |       DISCONNECT DatabaseName
 
Top
        
AlterTableStatement ::=

ALTER TABLE TableName ADD ForeignKey

| ALTER TABLE TableName DROP ForeignKeyName

Top
 
AnyAllOp ::=
  CompOp ANY
  |       CompOp ALL
Top
 
ColumnDef  ::=
  ColumnName DataType [ NOT NULL ]
 
Top
 
ColumnSpec ::=
[ TableName .] ColumnName
Top
 
Condition ::=
  Predicate
  | Predicate OR Predicate
  | Predicate AND Predicate
  | ( Condition )
  | NOT ( Condition )
Top
ConditionWithoutSubquery ::=
  PredicateWithoutSubquery
  | PredicateWithoutSubquery OR PredicateWithoutSubquery
  | PredicateWithoutSubquery AND PredicateWithoutSubquery
  | (ConditionWithoutSubquery)
  | NOT (ConditionWithoutSubquery)
Top
 
CompOp ::=
  = | < | > | <= | <> | >=
Top
 
CreateIndexStatement ::=
CREATE [ UNIQUE ] INDEX IndexName 
  ON TableName ( SortSpecList )
 
Top
 
CreateTableStatement ::=
 
        CREATE TABLE TableName ( TableSchema )
Top
 
        
CreateViewStatement ::=
CREATE VIEW ViewName[ ( ColumnName {, ColumnName} ) ]
AS QueryExpr
Top      
 
DataType ::=
 
        INTEGER | BOOLEAN | VARCHAR( length ) 
Top
   
 
DeleteOptions ::=
 
        CASCADE | SET NULL | NO ACTION
Top
 
Expr ::=
 
        NumericExpr
        | StringExpr 
 
Top
 
ForeignKey ::=
 
        FOREIGN KEY ( ColumnName {, ColumnName} )
        REFERENCES  TableName
        ON DELETE   DeleteOptions
 
 Top
 
InsertStatement ::=

INSERT INTO TableName [ ( ColumnName {, ColumnName} ) ]

VALUES ( Expr {, Expr } )

| INSERT INTO TableName SelectStatement

 
Top
 
MathOp ::=
 
        + | * | - | / 
 
Top
 
NumericExpr ::=
 
        Integer
        | NULL
        | ColumnSpec
        | StatisticalFun
        | - NumericExpr
        | ( NumericExpr )
        | NumericExpr MathOp   NumericExpr
Top
 
OrderSpec::=
  ASC | DESC
Top
 
Predicate ::=
  Expr AnyAllOp  Subquery
  | [ NOT ] EXISTS  Subquery  
  | Expr [ NOT ] IN  Subquery  
  | Expr CompOp Subquery 
  | PredicateWithoutSubquery 
Top
 
PredicateWithoutSubquery ::=
  Expr [ NOT ] IN ( Expr {, Expr} )
  | Expr BETWEEN  Expr AND Expr}  
  | Expr IS [ NOT ] NULL
  | Expr CompOp Expr  
  | ColumnSpec
  | TRUE
  | FALSE 
Top
 
QueryExpr ::=
SelectBlock
| QueryExpr SetOperator QueryExpr
| ( QueryExpr )
Top
 
SelectStatement ::=

QueryExp [ ORDER BY SortSpecList ]

Top
 
SelectBlock ::=
 
        SELECT [ DISTINCT ] SelectElements 
        FROM    TableName [ CorrelationName ] 
                       {, TableName [ CorrelationName ] }  
        [ WHERE Condition ]
        [ GROUP BY ColumnSpec  {, ColumnSpec}   
         [ HAVING Condition ] ]
Top
 
SelectElements ::=
 
        * | SelectElement {, SelectElement }  
Top
 
SelectElement ::=
 
        Expr
        | ( Expr )
        | ConditionWithoutSubquery
        | TableName.ColumnName
        | CorrelationName.ColumnName
        | SelectElement AS ColumnName
Top      
 
SetOperator ::=
 
        UNION | UNION ALL | INTERSECT |EXCEPT
Top      
 
SortSpecList ::=
 
        ColumnName [ OrderSpec ] {, ColumnName [ OrderSpec ]} 
Top
 
StatisticalFun ::= 
 
        COUNT ( [ DISTINCT ] ColumnName )
        | MIN (  ColumnName )
        | MAX (  ColumnName ) 
        | SUM ( [ DISTINCT ] ColumnName )
        | AVG ( [ DISTINCT ] ColumnName )  
Top 
 
 
StringExpr ::=
 
        '[ string ]'
        | NULL
        | ColumnSpec 
        | MIN (  ColumnName )
        | MAX (  ColumnName ) 
        | ( StringExpr )  
        | StringExpr + StringExpr 
        
Top      
 
Subquery ::=
 
         ( QueryExp ) 
 
Top
 
TableSchema ::=
 
        ColumnDef {, ColumnDef}
        [, PRIMARY KEY ( ColumnName {, ColumnName} )]   
        [, UniqueKey {, UniqueKey} ]
        [, ForeignKey {, ForeignKey} ]
 
Top
 
UniqueKey ::=
 
        UNIQUE  ( ColumnName {, ColumnName} )
 
Top
 
UpdateStatement ::=
 
        UPDATE TableName 
        SET    ColumnName = Expr {, ColumnName = Expr }
        [ WHERE Condition ]
 
 
Top
 
Index Page