xqyacc.y

TxQuery is an SQL engine implemented in a TDataSet descendant component, that can parse SQL syntax,

             { $<string>$ := $<string>1 + ' OR ' + $<string>3;   }
           | RW_NOT where_expr            { $<string>$ := ' NOT ' + $<string>2; }
           | _LPAREN where_expr _RPAREN   { $<string>$ := $<string>1 + $<string>2 + $<string>3; }
           | anyall_subquery              { $<string>$ := Format('(subquery %d)', [CurrentAnalizer.SubqueryList.Count-1]); }
           ;

is_null : define_field RW_IS RW_NULL         { $<string>$ := Format('ISNULL(%s,TRUE)', [$<string>1]); }
        | define_field RW_IS RW_NOT RW_NULL  { $<string>$ := Format('ISNULL(%s,FALSE)', [$<string>1]); }
        ;

in_operator : RW_IN
              { fIsNotInList := False; }
            | RW_NOT RW_IN
              { $<string>$ := $<string>1 + #32 + $<string>2 ; fIsNotInList := True; }
            ;

in_predicate : define_constant
               {fInPredicateList.Add( $<string>1 ); }
             | in_predicate _COMA define_constant
               { fInPredicateList.Add( $<string>3 );}
             ;

define_constant : _UINTEGER
                | _SINTEGER
                | _NUMERIC
                | _STRING
                | RW_TRUE
                  { if CurrentAnalizer.xQuery.WithDummies then
                      $<string>$ := 'DummyBoolean(True)'
                    else
                      $<string>$ := 'True' ;
                  }
                | RW_FALSE
                  { if CurrentAnalizer.xQuery.WithDummies then
                      $<string>$ := 'DummyBoolean(False)'
                    else
                      $<string>$ := 'False';
                  }
                | define_param
                ;

where_list_param : where_expr
                 | where_list_param _COMA where_expr
                   {$<string>$:= $<string>1 + ', ' + $<string>3;}
                 ;

where_clause : /* empty */
             | RW_WHERE where_expr
               { CurrentAnalizer.WhereStr := $<string>2; }
             ;

/*  a user defined range */
userdef_range_clause : /* empty */
                     | RW_SET RW_RANGE RW_FOR RW_FIELDS range_fieldlist RW_FROM from_range_values RW_TO to_range_values RW_USING RW_INDEX _STRING
                       { CurrentAnalizer.UserDefinedRange.UsingIndex:= GetString($<string>12); }
                     ;

range_fieldlist : _STRING
                  { CurrentAnalizer.UserDefinedRange.ForFields.Add(GetString($<string>1)); }
                | range_fieldlist _COMA _STRING
                  { CurrentAnalizer.UserDefinedRange.ForFields.Add(GetString($<string>3)); }
                ;

from_range_values : range_constant
                    { CurrentAnalizer.UserDefinedRange.StartValues.Add( $<string>1 );}
                  | from_range_values _COMA range_constant
                    { CurrentAnalizer.UserDefinedRange.StartValues.Add( $<string>3 );}
                  ;

to_range_values : range_constant
                  { CurrentAnalizer.UserDefinedRange.EndValues.Add( $<string>1 );}
                | to_range_values _COMA range_constant
                  { CurrentAnalizer.UserDefinedRange.EndValues.Add( $<string>3 );}
                ;

range_constant : _STRING
               | _SINTEGER
               | _UINTEGER
               | _NUMERIC
               | define_param
               ;

anyall_subquery : subquery         {CurrentAnalizer.SubQueryKindList.Add( Pointer(skAny) );}
                | RW_ANY subquery  {CurrentAnalizer.SubQueryKindList.Add( Pointer(skAny) );}
                | RW_ALL subquery  {CurrentAnalizer.SubQueryKindList.Add( Pointer(skAll) );}
                ;

subquery : _LPAREN first_subquery end_subquery
         | _LPAREN first_subquery RW_UNION second_select_statement end_subquery
           { TSqlAnalizer( CurrentAnalizer.SubQueryList[0] ).Statement:= ssUnion; }
         ;

first_subquery : subq_select_clause from_clause where_clause
                 userdef_range_clause groupby_clause orderby_clause
               ;

/* start a new subquery */
subq_select_clause : subq_select_case _MULT
                     { CurrentAnalizer.DoSelectAll := True; }
                   | subq_select_case list_expr_field
                   ;

subq_select_case : start_subquery
                 | start_subquery RW_DISTINCT
                   { CurrentAnalizer.IsDistinct := True; }
                 ;

start_subquery : subq_topn_select RW_SELECT subq_topn_groupby
                 { CreateNewSubquery;
                   CurrentAnalizer.TopNInSelect:= FtempTopNInSelect;
                   CurrentAnalizer.TopNInGroupBy:= FtempTopNInGroupBy;
                 }
               ;

subq_topn_select : /* empty */
                   { FtempTopNInSelect:= 0; }
                 | RW_TOP _UINTEGER
                   { FtempTopNInSelect:= StrToInt( $<string>2 ) ; }
                 ;

subq_topn_groupby : /* empty */
                   { FtempTopNInGroupBy:= 0; }
                  | RW_TOP _UINTEGER
                    { FtempTopNInGroupBy:= StrToInt( $<string>2 ) ; }
                  ;

end_subquery : _RPAREN   { Self.fCurrAnalizer := Self.fCurrAnalizer.ParentAnalizer; }
             ;

escape_character : /* empty */        {fEscapeChar := '';}
                 | RW_ESCAPE _STRING  {fEscapeChar := GetString( $<string>2 );}
                 ;

/* GROUP BY clause */

groupby_clause : /* empty */
               | RW_GROUP RW_BY list_fields_group having_predicate
               ;


list_fields_group : define_field_index                         {AddGroupBy( $<string>1 );}
                  | list_fields_group _COMA define_field_index {AddGroupBy( $<string>3 );}
                  ;

define_field_index : _IDENTIFIER      { $<string>$ := Format('\f"%s"', [$<string>1]); }
                   | qualified_field
                   | _UINTEGER        { $<string>$ := $<string>1; }
                   ;

having_predicate : /* empty */
                 | RW_HAVING select_expr
                   { AddHavingColumn( $<string>2 );
                     CurrentAnalizer.HavingCol := CurrentAnalizer.ColumnList.Count-1; }
                 ;

/* ORDER BY clause */

orderby_clause : /* empty */
               | RW_ORDER RW_BY list_fields_order
               ;

list_fields_order : define_fields_order
                  | list_fields_order _COMA define_fields_order
                  ;

define_fields_order : define_field_index           {AddOrderBy( $<string>1, False );}
                    | define_field_index RW_ASC    {AddOrderBy( $<string>1, False );}
                    | define_field_index RW_DESC   {AddOrderBy( $<string>1, True );}
                    ;

/* end of select */
end_statement : /* empty */
              | _SEMICOLON
              ;

/* UPDATE statement */
update_statement : RW_UPDATE table_identifier RW_SET list_update_columns
                     where_clause end_statement
                 | RW_UPDATE table_identifier RW_SET list_update_columns
                     _EQ subquery end_statement
                 ;

list_update_columns : update_column
                    | list_update_columns _COMA update_column
                    ;

update_column : _IDENTIFIER _EQ where_expr {AddUpdateColumn($<string>1,$<string>3);}
              | _IDENTIFIER _EQ RW_NULL {AddUpdateColumn($<string>1,'');}
              ;

/* DELETE statement */
delete_statement : RW_DELETE RW_FROM table_identifier where_clause end_statement
                 ;

/* INSERT statement */
insert_statement : insert_statement_list end_statement
                 ;

insert_statement_list : insert_one_record                        { Inc(fNumInserts); }
                      | insert_satement_list insert_one_record   { Inc(fNumInserts); }
                      ;

insert_one_record : RW_INSERT RW_INTO insert_identifier insert_columns_list optional_values insert_values_list
                      { if fIsFullPath then
                          CurrentInsertItem.TableName := Copy($<string>3,2,Length($<string>3)-2)
                        else
                          CurrentInsertItem.TableName := $<string>3;
                        CurrentInsertItem.IsFullPath  := self.fIsFullPath ;
                      }
                  ;

optional_values : /* empty */
                | RW_VALUES
                ;

insert_identifier : _IDENTIFIER     { fIsFullPath := false; }
                  | _STRING
                    { fIsFullPath := true; }
                  ;


insert_columns_list : _LPAREN columns_list _RPAREN
                    | _LPAREN _MULT _RPAREN
                    ;

/* define the fields to update */
columns_list : _IDENTIFIER                       {CurrentInsertItem.FieldNames.Add($<string>1);}
             | columns_list _COMA _IDENTIFIER    {CurrentInsertItem.FieldNames.Add($<string>3);}
             ;

insert_values_list : _LPAREN values_list _RPAREN
                   | subquery
                   ;

/* define the values to store in fields */
values_list : insert_value                    {CurrentInsertItem.ExprList.Add( $<string>1 );}
            | values_list _COMA insert_value  {CurrentInsertItem.ExprList.Add( $<string>3 );}
            ;

insert_value : RW_NULL
             | where_expr
             ;


/* ALTER TABLE STATEMENT */

altertable_statement : altertable_list end_statement

altertable_list : alterone_table
                | altertable_list alterone_table
                ;

alterone_table : RW_ALTER RW_TABLE _STRING alter_list
                 {SetAlterTableName( GetString( $<string>3 ) ); }
               ;

alter_list : alter_onefield
           | alter_list _COMA alter_onefield
           ;

alter_onefield : RW_ADD alter_column _IDENTIFIER field_type {AddAlterField($<string>3,false);}
               | RW_DROP alter_column _IDENTIFIER           {AddAlterField($<string>3,true);}
               ;

alter_column : /* empty */
             | RW_COLUMN
             ;


/* CREATE TABLE STATEMENT */
createtable_statement : createtable_list end_statement
                      ;

createtable_list : createone_table                   {Inc(FNumTables);}
                 | createtable_list createone_table  {Inc(FNumTables);}
                 ;

createone_table : RW_CREATE RW_TABLE _STRING _LPAREN create_list primary_key _RPAREN
                  {SetTableName( GetString( $<string>3 ) );}
                ;

/* the type of fields that can be created */
field_type : RW_CHAR _LPAREN _UINTEGER _RPAREN   {SetFieldParams(RW_CHAR,0,0,StrToInt($<string>3),0);}
           | RW_INTEGER                         {SetFieldParams(RW_INTEGER,0,0,0,0);}
           | RW_SMALLINT                        {SetFieldParams(RW_SMALLINT,0,0,0,0);}
           | RW_BOOLEAN                         {SetFieldParams(RW_BOOLEAN,0,0,0,0);}
           | RW_DATE                            {SetFieldParams(RW_DATE,0,0,0,0);}
           | RW_TIME                            {SetFieldParams(RW_TIME,0,0,0,0);}
           | RW_DATETIME                        {SetFieldParams(RW_DATETIME,0,0,0,0);}
           | RW_MONEY                           {SetFieldParams(RW_MONEY,0,0,0,0);}
           | RW_FLOAT                           {SetFieldParams(RW_FLOAT,0,0,0,0);}
           | RW_FLOAT _LPAREN _UINTEGER _RPAREN {SetFieldParams(RW_FLOAT,StrToInt($<string>3),0,0,0);}
           | RW_FLOAT _LPAREN _UINTEGER _COMA _UINTEGER _RPAREN {SetFieldParams(RW_FLOAT,StrToInt($<string>3),StrToInt($<string>5),0,0);}
           | RW_AUTOINC                         {SetFieldParams(RW_AUTOINC,0,0,0,0);}
           | RW_BLOB _LPAREN _UINTEGER _RPAREN  {SetFieldParams(RW_BLOB,0,0,0,StrToInt($<string>3));}
           ;

create_list : _IDENTIFIER field_type                     {AddCreateField($<string>1);}
            | create_list _COMA _IDENTIFIER field_type   {AddCreateField($<string>3);}
            ;

primary_key : /* empty */
            | RW_PRIMARY RW_KEY _LPAREN create_field_list _RPAREN
            ;

create_field_list : _IDENTIFIER                           { AddPrimaryKeyField( $<string>1 ); }
                  | create_field_list _COMA _IDENTIFIER   { AddPrimaryKeyField( $<string>3 ); }
                  ;

/* CREATE INDEX statement */
createindex_statement : RW_CREATE index_unique index_order RW_INDEX _IDENTIFIER RW_ON _STRING _LPAREN index_field_list _RPAREN end_statement
                        { CurrentAnalizer.IndexName  := $<string>5;
                          CurrentAnalizer.IndexTable := GetString( $<string>7 ); }
                      ;

index_unique : /* empty */
             | RW_UNIQUE  { CurrentAnalizer.IndexUnique := True; }
             ;

index_order : /* empty */
            | RW_ASC
            | RW_DESC      { CurrentAnalizer.IndexDescending := True; }
            ;

index_field_list : _IDENTIFIER   {CurrentAnalizer.IndexColumnList.Add($<string>1);}
                 | index_field_list _COMA _IDENTIFIER  {CurrentAnalizer.IndexColumnList.Add($<string>3);}
                 ;

/* DROP TABLE statement */
droptable_statement : RW_DROP RW_TABLE _STRING end_statement
                      {CurrentAnalizer.IndexTable:= GetString( $<string>3 );}
                    ;

/* DROP INDEX statement */
dropindex_statement : RW_DROP RW_INDEX _STRING _IDENTIFIER end_statement
                     { CurrentAnalizer.IndexTable:= GetString( $<string>3 );
                       CurrentAnalizer.IndexName := $<string>4; }
                    ;

/* TRANSFORM...PIVOT statement */
transform_statement : RW_TRANSFORM transf_aggregate_list select_statement RW_PIVOT select_expr pivot_in_predicate end_statement
                      { CurrentAnalizer.PivotStr := $<string>5; }
                    ;

/* this is needed in order to reduce this column first */
transf_aggregate : select_expr  { AddColumn( $<string>1, True ); }
                 | RW_CAST _LPAREN select_expr RW_AS data_type _RPAREN { AddColumn( $<string>3, True ); }
                 ;

transf_aggregate_list : transf_aggregate
                      | transf_aggregate_list _COMA transf_aggregate
                      ;

pivot_in_predicate : /* empty */
                   | RW_IN _LPAREN pivot_in_list _RPAREN
                   | RW_IN subquery    { CurrentAnalizer.SubqueryInPivotPredicate:= true ;}
                   ;

pivot_in_list : define_constant
                {CurrentAnalizer.PivotInList.Add( RemoveStrDelim( $<string>1));}
              | pivot_in_list _COMA define_constant
                {CurrentAnalizer.PivotInList.Add( RemoveStrDelim( $<string>3));}
               ;

/* this second select clause is for the UNION statement */

second_select_statement : second_select_clause from_clause where_clause
                          userdef_range_clause groupby_clause orderby_clause
                        ;

/* start a new select statement */
second_select_clause : second_select_case _MULT              {CurrentAnalizer.DoSelectAll := True;}
                     | second_select_case list_expr_field
                     ;

second_select_case : second_select
                   | second_select RW_DISTINCT
                     { CurrentAnalizer.IsDistinct := True; }
                   ;

/* create the second select */
second_select : RW_SELECT
                { CurrentAnalizer.UnionAnalizer :=
                    TSqlAnalizer.Create( CurrentAnalizer.ParentAnalizer, fAnalizer.xQuery );
                  Self.fCurrAnalizer := CurrentAnalizer.UnionAnalizer; }
              ;

packtable_statement : RW_PACK RW_TABLE list_tables
                    ;

zaptable_statement : RW_ZAP RW_TABLE list_tables
                   ;

reindextable_statement : RW_REINDEX RW_TABLE list_tables

%%