ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLCreateTable


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLDropTable
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBDDLDropTable = class (TMYLDBDDLTableManipulation)
  protected
   // Drop Table
   procedure DropTable(query: TDataSet);
  public
   // parses query
   procedure Parse; override;
   // executes query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLDropTable



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLTruncateTable
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBDDLTruncateTable = class (TMYLDBDDLTableManipulation)
  protected
   // Truncate Table
   procedure TruncateTable(query: TDataSet);
  public
   // parses query
   procedure Parse; override;
   // executes query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLTruncateTable



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLAlterTable
//
////////////////////////////////////////////////////////////////////////////////


 // Types of alter table
 TAlterType = (atAdd, atDrop, atModify, atRenameColumn, atRenameTable);

 TMYLDBDDLAlterTable = class (TMYLDBDDLTableManipulation)
  protected
   // AlterType token
   AlterType:         TAlterType;
   NewPassword:       String;
   NewEncrypted:      Boolean;
   DropColumnNamesList:       TStringList;
   RenameColumnOldNamesList:  TStringList;
   RenameColumnNewNamesList:  TStringList;
   NewTableName:              String;

   // parse AlterType token
   procedure ParseAlterTypeToken;
   // parse NewPassword token
   procedure ParseNewPasswordToken;
   // Parse RenameColumnList
   procedure ParseRenameColumnsList;
   // Alter Table
   procedure DropColumn(T: TDataSet);
   procedure AddColumn(T: TDataSet);
   procedure Modify(T: TDataSet);
   procedure RenameColumn(T: TDataSet);
  public
   // creates object
   constructor Create(Lexer: TMYLDBLexer; Query: TDataSet);
   // destroy
   destructor Destroy; override;
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLAlterTable


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLRenameTable
//
////////////////////////////////////////////////////////////////////////////////

 TMYLDBDDLRenameTable = class (TMYLDBDDLAlterTable)
   // parse query
   procedure Parse; override;
 end;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLCreateIndex
//
////////////////////////////////////////////////////////////////////////////////

 TMYLDBDDLCreateIndex = class (TMYLDBSQLCommand)
  protected
   Unique:          boolean;
   IndexName:       String;
   DatabaseFileName:String;
   TableName:       String;
   TableAlias:      String;
   Password:        String;
   InMemory:        Boolean;
   MYLDBIndexFields:  array of TMYLDBIndexField; // Index Fields
  public
   // creates object
   constructor Create(Lexer: TMYLDBLexer; Query: TDataSet);
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLCreateIndex



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDDLDropIndex
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBDDLDropIndex = class (TMYLDBSQLCommand)
  protected
   IndexName: String;
   DatabaseFileName:String;
   TableName:       String;
   TableAlias:      String;
   Password:        String;
   InMemory:        Boolean;
  public
   // creates object
   constructor Create(Lexer: TMYLDBLexer; Query: TDataSet);
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBDDLDropIndex


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSQLStartTransaction
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBSQLStartTransaction = class (TMYLDBSQLCommand)
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBSQLStartTransaction



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSQLCommit
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBSQLCommit = class (TMYLDBSQLCommand)
  private
   FFlush: Boolean;
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBSQLCommit



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSQLRollback
//
////////////////////////////////////////////////////////////////////////////////


 TMYLDBSQLRollback = class (TMYLDBSQLCommand)
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TMYLDBAO = nil;
                      ParentCursor: TMYLDBCursor = nil
                     ); override;
 end;//TMYLDBSQLRollback




 // set field value from MYLDBVariant
 procedure SetMYLDBVariantIntoField(Value: TMYLDBVariant; Field: TField);



implementation


uses MYLDBMain, MYLDBBaseEngine;





////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSQLProcessor
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
constructor TMYLDBSQLProcessor.Create(Query: TDataSet);
begin
  FSQLParams := TMYLDBSQLParams.Create;
  MYLDBQuery := Query;
  FCursor := nil;
  FSqlText := '';
  SetLength(queries, 0);
  FLex := nil;
end;//Create


//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
destructor TMYLDBSQLProcessor.Destroy;
begin
  FSQLParams.Free;
  if (FLex <> nil) then
    FLex.Free;
  ClearQueries;
end;//Destroy


//------------------------------------------------------------------------------
// PrepareStatement
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.PrepareStatement(SQLText: PChar);
begin
  FSqlText := SQLText;
end;//PrepareStatement


//------------------------------------------------------------------------------
// OpenQuery
//------------------------------------------------------------------------------
function TMYLDBSQLProcessor.OpenQuery: TMYLDBCursor;
begin
  FRowsAffected := 0;
  Result := nil;
  ClearQueries;

  if (FLex <> nil) then
    FLex.Free;
  FLex := TMYLDBLexer.Create(FSqlText, FSQLParams);
  while ParseNextCommand(FLex) do
    begin
      Queries[0].ExecSQL(MYLDBQuery, True, FRequestLive, FReadonly);
      FRowsAffected := RowsAffected + Queries[0].RowsAffected;
    end;//if
  if (Queries[0] <> nil) then
    begin
      Result := Queries[0].GetResultCursor;
      if (Result <> nil) then
        Result.InternalFirst;
    end;

end;//OpenQuery


//------------------------------------------------------------------------------
// ExecuteQuery
//------------------------------------------------------------------------------
procedure TMYLDBSQLProcessor.ExecuteQuery;
begin
  OpenQuery;
end;//ExecuteQuery


//------------------------------------------------------------------------------
// parse SQL script and fullfill SQL command objects
//------------------------------------------------------------------------------
function TMYLDBSQLProcessor.ParseNextCommand(Lexer: TMYLDBLexer): Boolean;
var
  Token: TToken;
begin

 if (Lexer.NumCommands = 0) then
  raise EMYLDBException.Create(30145, ErrorGBlankSqlCommand);

 if Lexer.GetNextCommand then
  begin
   Result := True;

   // free prior query object
   if (Length(Queries) > 0) then
     begin
        Queries[0].Free;
        Queries[0] := nil;
        SetLength(Queries, 0);
     end;

   // look at first token
   if (not Lexer.GetCurrentToken(Token)) then
    raise EMYLDBException.Create(30146, ErrorGBlankSqlCommand);

   if (Token.TokenType = tktReservedWord) then
     case Token.ReservedWord of
     rwSELECT:  // SELECT