abssqlprocessor.pas

Absolute Database 是来替代BDE[Borland数据库引擎]的用于Delphi 和 C++ Builder 开发用的数据库引擎. 它小巧, 高速, 健壮, 易于使用. 它能直接编译进

//
////////////////////////////////////////////////////////////////////////////////


 TABSDDLDropTable = class (TABSDDLTableManipulation)
  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: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSDDLDropTable



////////////////////////////////////////////////////////////////////////////////
//
// TABSDDLTruncateTable
//
////////////////////////////////////////////////////////////////////////////////


 TABSDDLTruncateTable = class (TABSDDLTableManipulation)
  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: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSDDLTruncateTable



////////////////////////////////////////////////////////////////////////////////
//
// TABSDDLAlterTable
//
////////////////////////////////////////////////////////////////////////////////


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

 TABSDDLAlterTable = class (TABSDDLTableManipulation)
  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: TABSLexer; Query: TDataSet);
   // destroy
   destructor Destroy; override;
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSDDLAlterTable


////////////////////////////////////////////////////////////////////////////////
//
// TABSDDLRenameTable
//
////////////////////////////////////////////////////////////////////////////////

 TABSDDLRenameTable = class (TABSDDLAlterTable)
   // parse query
   procedure Parse; override;
 end;

////////////////////////////////////////////////////////////////////////////////
//
// TABSDDLCreateIndex
//
////////////////////////////////////////////////////////////////////////////////

 TABSDDLCreateIndex = class (TABSSQLCommand)
  protected
   Unique:          boolean;
   IndexName:       String;
   DatabaseFileName:String;
   TableName:       String;
   TableAlias:      String;
   Password:        String;
   InMemory:        Boolean;
   ABSIndexFields:  array of TABSIndexField; // Index Fields
  public
   // creates object
   constructor Create(Lexer: TABSLexer; Query: TDataSet);
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSDDLCreateIndex



////////////////////////////////////////////////////////////////////////////////
//
// TABSDDLDropIndex
//
////////////////////////////////////////////////////////////////////////////////


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


////////////////////////////////////////////////////////////////////////////////
//
// TABSSQLStartTransaction
//
////////////////////////////////////////////////////////////////////////////////


 TABSSQLStartTransaction = class (TABSSQLCommand)
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSSQLStartTransaction



////////////////////////////////////////////////////////////////////////////////
//
// TABSSQLCommit
//
////////////////////////////////////////////////////////////////////////////////


 TABSSQLCommit = class (TABSSQLCommand)
  private
   FFlush: Boolean;
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSSQLCommit



////////////////////////////////////////////////////////////////////////////////
//
// TABSSQLRollback
//
////////////////////////////////////////////////////////////////////////////////


 TABSSQLRollback = class (TABSSQLCommand)
  public
   // parse query
   procedure Parse; override;
   // execute query
   procedure ExecSQL(
                      query: TDataset;
                      IsRoot,
                      RequestLive: boolean;
                      var ReadOnly: boolean;
                      ParentQueryAO: TABSAO = nil;
                      ParentCursor: TABSCursor = nil
                     ); override;
 end;//TABSSQLRollback




 // set field value from ABSVariant
 procedure SetABSVariantIntoField(Value: TABSVariant; Field: TField);



implementation


uses ABSMain, ABSBaseEngine;





////////////////////////////////////////////////////////////////////////////////
//
// TABSSQLProcessor
//
////////////////////////////////////////////////////////////////////////////////


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


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


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


//------------------------------------------------------------------------------
// OpenQuery
//------------------------------------------------------------------------------
function TABSSQLProcessor.OpenQuery: TABSCursor;
begin
  FRowsAffected := 0;
  Result := nil;
  ClearQueries;

  if (FLex <> nil) then
    FLex.Free;
  FLex := TABSLexer.Create(FSqlText, FSQLParams);
  while ParseNextCommand(FLex) do
    begin
      Queries[0].ExecSQL(ABSQuery, 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 TABSSQLProcessor.ExecuteQuery;
begin
  OpenQuery;
end;//ExecuteQuery


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

 if (Lexer.NumCommands = 0) then
  raise EABSException.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 EABSException.Create(30146, ErrorGBlankSqlCommand);

   if (Token.TokenType = tktReservedWord) then
     case Token.ReservedWord of
     rwSELECT:  // SELECT
                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