SQL Grammar

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

DMLStatement ::= 
        DELETE FROM TableName [ WHERE Condition ]
        | InsertStatement
        | SelectStatement 
        | UpdateStatement

DCLStatement ::=
        CONNECT DatabaseName
        | DISCONNECT DatabaseName

AlterTableStatement ::=
        ALTER TABLE TableName ADD ForeignKey
        | ALTER TABLE TableName DROP ForeignKeyName

AnyAllOp ::=
        CompOp ANY
        | CompOp ALL

ColumnDef  ::=
        ColumnName DataType [ NOT NULL ]

ColumnSpec ::=
        [ TableName .] ColumnName

Condition ::=
        Predicate
        | Predicate OR Predicate
        | Predicate AND Predicate
        | ( Condition )
        | NOT ( Condition )

ConditionWithoutSubquery ::=
        PredicateWithoutSubquery
        | PredicateWithoutSubquery OR PredicateWithoutSubquery
        | PredicateWithoutSubquery AND PredicateWithoutSubquery
        | (ConditionWithoutSubquery)
        | NOT (ConditionWithoutSubquery)

CompOp ::=
        = | < | > | <= | <> | >=

CreateIndexStatement ::=
        CREATE [ UNIQUE ] INDEX IndexName 
        ON TableName ( SortSpecList )

CreateTableStatement ::=
        CREATE TABLE TableName ( TableSchema )

CreateViewStatement ::=
        CREATE VIEW ViewName[ ( ColumnName {, ColumnName} ) ]
        AS QueryExpr

DataType ::=
        INTEGER | BOOLEAN | VARCHAR( length ) 

DeleteOptions ::=
        CASCADE | SET NULL | NO ACTION

Expr ::=
        NumericExpr
        | ForeignKey ::=
        FOREIGN KEY ( ColumnName {, ColumnName} )
        REFERENCES  TableName
        ON DELETE   DeleteOptions

InsertStatement ::=
        INSERT INTO TableName [ ( ColumnName {, ColumnName} ) ]
        VALUES ( Expr {, Expr } )
        | INSERT INTO TableName SelectStatement

MathOp ::=
        + | * | - | / 

NumericExpr ::=
        Integer
        | NULL
        | ColumnSpec
        | StatisticalFun
        | - NumericExpr
        | ( NumericExpr )
        | NumericExpr MathOp NumericExpr

OrderSpec::=
        ASC | DESC

Predicate ::=
        Expr AnyAllOp  Subquery
        | [ NOT ] EXISTS  Subquery  
        | Expr [ NOT ] IN  Subquery  
        | Expr CompOp Subquery 
        | PredicateWithoutSubquery

PredicateWithoutSubquery ::=
        Expr [ NOT ] IN ( Expr {, Expr} )
        | Expr BETWEEN  Expr AND Expr}  
        | Expr IS [ NOT ] NULL
        | Expr CompOp Expr  
        | ColumnSpec
        | TRUE
        | FALSE 

QueryExpr ::=
        SelectBlock
        | QueryExpr SetOperator QueryExpr
        | ( QueryExpr )  

SelectStatement ::=
        QueryExp [ ORDER BY SortSpecList ]

SelectBlock ::=
        SELECT [ DISTINCT ] SelectElements
        FROM    TableName [ CorrelationName ] 
                       {, TableName [ CorrelationName ] }  
        [ WHERE Condition ]
        [ GROUP BY ColumnSpec  {, ColumnSpec}   
        [ HAVING Condition ] ]

SelectElements ::=
        * | SelectElement {, SelectElement }  

SelectElement ::=
        Expr
        | ( Expr )
        | ConditionWithoutSubquery
        | TableName.ColumnName
        | CorrelationName.ColumnName
        | SelectElement AS ColumnName

SetOperator ::=
        UNION | UNION ALL | INTERSECT | EXCEPT 

SortSpecList ::=
        ColumnName [ OrderSpec ] {, ColumnName [ OrderSpec ]} 

StatisticalFun ::= 
        COUNT ( [ DISTINCT ] ColumnName )
        | MIN (  ColumnName )
        | MAX (  ColumnName ) 
        | SUM ( [ DISTINCT ] ColumnName )
        | AVG ( [ DISTINCT ] ColumnName )  

StringExpr ::=
        '[ string ]'
        | NULL
        | ColumnSpec
        | MIN (  ColumnName )
        | MAX (  ColumnName ) 
        | ( StringExpr )  
        | StringExpr + StringExpr 

Subquery ::=
         ( QueryExp ) 

TableSchema ::=
        ColumnDef {, ColumnDef}
        [, PRIMARY KEY ( ColumnName {, ColumnName} )]   
        [, UniqueKey {, UniqueKey} ]
        [, ForeignKey {, ForeignKey} ]

UniqueKey ::=
        UNIQUE  ( ColumnName {, ColumnName} )

UpdateStatement ::=
        UPDATE TableName 
        SET    ColumnName = Expr {, ColumnName = Expr }
        [ WHERE Condition ]

 
Index Page