AddSelectQuery(Lexer);
     rwINSERT:  // INSERT
                AddInsertQuery(Lexer);
     rwUPDATE:  // UPDATE
                AddUpdateQuery(Lexer);
     rwDELETE:  // DELETE
                AddDeleteQuery(Lexer);
     rwTRUNCATE:// TRUNCATE TABLE
                AddTruncateTableQuery(Lexer);
     rwCREATE:  // CREATE
                begin
                  if Lexer.GetNextToken(Token) then
                    case Token.ReservedWord of
                      rwTABLE:  // CREATE TABLE
                                AddCreateTableQuery(Lexer);
                      rwINDEX,
                      rwUNIQUE: // CREATE INDEX or UNIQUE INDEX
                                AddCreateIndex(Lexer);
                      else raise EMYLDBException.Create(30147, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);
                    end
                  else raise EMYLDBException.Create(30148, ErrorGUnexpectedEndOfCommand,
                            [Token.LineNum, Token.ColumnNum]);
                end;
      rwDROP:   // DROP
                begin
                  if Lexer.GetNextToken(Token) then
                    case Token.ReservedWord of
                      rwTABLE:  // DROP TABLE
                                AddDropTableQuery(Lexer);
                      rwINDEX:  // DROP INDEX
                                AddDropIndexQuery(Lexer);
                      else raise EMYLDBException.Create(30149, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);
                    end
                  else raise EMYLDBException.Create(30150, ErrorGUnexpectedEndOfCommand,
                            [Token.LineNum, Token.ColumnNum]);
                end;
      rwALTER:   // ALTER
                begin
                  if Lexer.GetNextToken(Token) then
                    case Token.ReservedWord of
                      rwTable:  // ALTER TABLE
                                AddAlterTableQuery(Lexer);
                      else raise EMYLDBException.Create(30151, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);

                    end
                  else raise EMYLDBException.Create(30152, ErrorGUnexpectedEndOfCommand,
                            [Token.LineNum, Token.ColumnNum]);
                end;
      rwRENAME:   // RENAME
                begin
                  if (not Lexer.GetNextToken(Token)) then
                    raise EMYLDBException.Create(30353, ErrorGUnexpectedEndOfCommand,
                                               [Token.LineNum, Token.ColumnNum]);
                  if IsReservedWord(Token, rwTABLE) then
                    Lexer.GetNextToken(Token);
                  // RENAME TABLE
                  AddRenameTableQuery(Lexer)
                end;
      rwSTART:    // START TRANSACTION
                  AddStartTransaction(Lexer);
      rwCOMMIT:   // COMMIT
                  AddCommit(Lexer);
      rwROLLBACK: // ROLLBACK
                  AddRollback(Lexer);

     else       // unsupported SQL or unexpected token
        raise EMYLDBException.Create(30153, ErrorGSQLCommandExpected,
                                 [Token.Text, Token.LineNum, Token.ColumnNum]);
     end
   else
    // '( SELECT ...) ' ?
    if (Token.TokenType = tktLeftParenthesis) then
     AddSelectQuery(Lexer)
    else
     raise EMYLDBException.Create(30154, ErrorGSQLCommandExpected,
                         [Token.Text, Token.LineNum, Token.ColumnNum]);
  end
 else
   Result := False;
end;// Parse


//------------------------------------------------------------------------------
// adds SELECT query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddSelectQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLUnion.Create(Lexer, MYLDBQuery);
  if (Queries[OldQueryCount].GetCurrentToken) then
    raise EMYLDBException.Create(20260, ErrorAEndOfCommandExpected,
                                 [Queries[OldQueryCount].Token.Text, Queries[OldQueryCount].Token.LineNum, Queries[OldQueryCount].Token.ColumnNum]);
end;// AddSelectQuery


//------------------------------------------------------------------------------
// adds INSERT query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddInsertQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLInsert.Create(Lexer, MYLDBQuery);
end;//AddInsertQuery


//------------------------------------------------------------------------------
// adds UPDATE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddUpdateQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLUpdate.Create(Lexer, MYLDBQuery);
end;//AddUpdateQuery


//------------------------------------------------------------------------------
// adds DELETE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddDeleteQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLDelete.Create(Lexer, MYLDBQuery);
end;//AddDeleteQuery


//------------------------------------------------------------------------------
// adds TRUNCATE TABLE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddTruncateTableQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLTruncateTable.Create(Lexer, MYLDBQuery);
end;//AddTruncateTableQuery


//------------------------------------------------------------------------------
// adds CREATE TABLE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddCreateTableQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLCreateTable.Create(Lexer, MYLDBQuery);
  //if (FLex.GetNextToken(Token)) then
  // // unexpected token
  // raise ETblException.Create(02003,
  //                 [Token.Text, Token.LineNum, Token.ColumnNum]);
  //
end;//AddCreateTableQuery


//------------------------------------------------------------------------------
// adds DROP TABLE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddDropTableQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLDropTable.Create(Lexer, MYLDBQuery);
end;//AddDropTableQuery


//------------------------------------------------------------------------------
// add ALTER TABLE query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddAlterTableQuery;
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLAlterTable.Create(Lexer, MYLDBQuery);
end;//AddAlterTableQuery


//------------------------------------------------------------------------------
// add RENAME TABLE
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddRenameTableQuery(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLRenameTable.Create(Lexer, MYLDBQuery);
end;//AddRenameTableQuery


//------------------------------------------------------------------------------
// add CREATE INDEX query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddCreateIndex;
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLCreateIndex.Create(Lexer, MYLDBQuery);
end;//AddCreateIndex


//------------------------------------------------------------------------------
// add DROP INDEX query object
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddDropIndexQuery;
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBDDLDropIndex.Create(Lexer, MYLDBQuery);
end;//AddDropIndexQuery


//------------------------------------------------------------------------------
// add START TRANSACTION
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddStartTransaction(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLStartTransaction.Create(Lexer, MYLDBQuery);
end;//AddStartTransaction



//------------------------------------------------------------------------------
// add COMMIT
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddCommit(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLCommit.Create(Lexer, MYLDBQuery);
end;//AddStartTransaction



//------------------------------------------------------------------------------
// add ROLLBACK
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.AddRollback(Lexer: TMYLDBLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TMYLDBSQLRollback.Create(Lexer, MYLDBQuery);
end;//AddStartTransaction


//------------------------------------------------------------------------------
// ClearQueries
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.ClearQueries;
var i: integer;
begin
  for i := 0 to Length(Queries)-1 do
   if (Queries[i] <> nil) then
     FreeAndNil(Queries[i]);
  SetLength(Queries, 0);
end;//ClearQueries


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSQLSelect
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
constructor TMYLDBSQLSelect.Create(Lexer: TMYLDBLexer; Query: TDataSet);
begin
  SelectListCount := 0;
  SetLength(SelectList, 0);
  FromTablesCount := 0;
  SetLength(FromTables, 0);
  OrderBySpecsCount := 0;
  SetLength(OrderBySpecs, 0);
  SearchCondition := nil;
  HavingCondition := nil;
  GroupByFields := TMYLDBFields.Create;
  inherited Create(Lexer, Query);
end;// Create


//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
destructor TMYLDBSQLSelect.Destroy;
var
  i: integer;
begin
  for i := 0 to SelectListCount-1 do
    if (SelectList[i].ValueExpr <> nil) then
     begin
      SelectList[i].ValueExpr.Free;
      SelectList[i].ValueExpr := nil;
     end;

  if (SearchCondition <> nil) then
   SearchCondition.Free;
  if (GroupByFields <> nil) then
   GroupByFields.Free;
  if (HavingCondition <> nil) then
   HavingCondition.Free;

  for i := 0 to FromTablesCount-1 do
   FromTables[i].Free;

  inherited;
end;// Destroy


//------------------------------------------------------------------------------
// check if correlated subquery apllied
//------------------------------------------------------------------------------
function TMYLDBSQLSelect.AllConditionsApplied: Boolean;
begin
  Result := not FSubqueryHasNotAppliedConditions;

  if (SearchCondition <> nil) then
    begin
     if (not SearchCondition.IsEmpty) then
       Result := False;
    end;
  if (HavingCondition <> nil) then
    begin
      if (not HavingCondition.IsEmpty) then
        Result := False;
    end;
end;// AllConditionsApplied


//------------------------------------------------------------------------------
// builds AO tree
//------------------------------------------------------------------------------
function TMYLDBSQLSelect.BuildAOTree(query: TDataset; RequestLive: Boolean; ParentQueryAO: TMYLDBAO;
          ParentCursor: TMYLDBCursor; AllowNotAppliedConditions: Boolean): TMYLDBAO;
var
  i, j: integer;
  bAnyExpressions: Boolean;
  bGroupBy: Boolean;
  GroupByAO: TMYLDBAO;
  bAddTempTableAO: Boolean;

begin
  ResultDataset := query;
  FSubqueryHasNotAppliedConditions := False;

  // live result with 1 table?
  if ((FromTablesCount = 1) and (FromTables[0].TableType = attTable)) then
    Result := BuildOneTableTree(RequestLive, ParentQueryAO, ParentCursor, AllowNotAppliedConditions)
  else
    Result := BuildMultiTablesTree(RequestLive, ParentQueryAO, ParentCursor, AllowNotAppliedConditions);