gainsertstm.pas

一个sql语法分析程序

{*******************************************************}
{                                                       }
{       Advanced SQL statement parser                   }
{       Copyright (c) 2001 AS Gaiasoft                  }
{       Created by Gert Kello                           }
{                                                       }
{*******************************************************}

unit gaInsertStm;

interface

uses
  gaAdvancedSQLParser, gaSQLParserHelperClasses;

type
  TInsertStatementState = (issNone, issInsertInto, issInsertTable,
    issColumnList, issAfterColumnList, issInsertValues, issInsertSelect,
    issStatementComplete);
  TInsertStatementStateS = set of TInsertStatementState;

  TgaInsertSQLStatement = class (TgaCustomSQLStatement)
  private
    FInsertFields: TgaSQLFieldList;
    FInsertValues: TgaSQLExpression;
    FSelectStm: TgaCustomSQLStatement;
    FStatementState: TInsertStatementState;
    FStatementTable: TgaSQLTable;
    procedure SetStatementState(Value: TInsertStatementState);
  protected
    procedure DoAfterStatementStateChange; override;
    function GetNewStatementState: TInsertStatementState;
    function GetStatementType: TSQLStatementType; override;
    procedure ModifyStatementInNormalState(Sender: TObject; AToken: 
            TgaSQLTokenObj); override;
  public
    constructor Create(AOwner: TgaAdvancedSQLParser); override;
    constructor CreateFromStatement(AOwner: TgaAdvancedSQLParser; AStatement: 
            TgaNoSQLStatement); override;
    destructor Destroy; override;
    property InsertFields: TgaSQLFieldList read FInsertFields;
    property InsertValues: TgaSQLExpression read FInsertValues;
    property SelectStm: TgaCustomSQLStatement read FSelectStm;
    property StatementState: TInsertStatementState read FStatementState write 
            SetStatementState;
    property StatementTable: TgaSQLTable read FStatementTable;
  end;
  

implementation

uses
  SysUtils, gaBasicSQLParser, gaSQLParserConsts, TypInfo;

const
  InsertAllowedNextState: array[TInsertStatementState] of TInsertStatementStates = (
    {issNone} [issInsertInto],
    {issInsertInto} [issInsertTable],
    {issInsertTable} [issColumnList, issInsertValues, issInsertSelect],
    {issColumnList} [issAfterColumnList],
    {issAfterColumnList} [issInsertValues, issInsertSelect],
    {issInsertValues} [issStatementComplete],
    {issInsertSelect} [issStatementComplete],
    {issStatementComplete} []
    );

{
**************************** TgaInsertSQLStatement *****************************
}
constructor TgaInsertSQLStatement.Create(AOwner: TgaAdvancedSQLParser);
begin
  inherited Create(AOwner);
  FStatementTable := TgaSQLTable.Create(Self);
end;

constructor TgaInsertSQLStatement.CreateFromStatement(AOwner: 
        TgaAdvancedSQLParser; AStatement: TgaNoSQLStatement);
begin
  inherited CreateFromStatement(AOwner, AStatement);
  FStatementTable := TgaSQLTable.Create(Self);
end;

destructor TgaInsertSQLStatement.Destroy;
begin
  FInsertFields.Free;
  FInsertValues.Free;
  FStatementTable.Free;
  inherited Destroy;
end;

procedure TgaInsertSQLStatement.DoAfterStatementStateChange;
begin
  inherited DoAfterStatementStateChange;
  if StatementState = issInsertSelect then
  begin
    FSelectStm := OwnerParser.GetStatementClass.CreateOwned(OwnerParser, Self);
    SelectStm.DoTokenAdded(Self, CurrentToken);
  end;
end;

function TgaInsertSQLStatement.GetNewStatementState: TInsertStatementState;
var
  TokenStr: string;
begin
  (*
  INSERT [TRANSACTION transaction] INTO <object> [( col [, col 匽)]
  {VALUES ( <val> [, <val> 匽) | <select_expr>};
  <object> = tablename | viewname
  <val> = {: variable | <constant> | <expr>
  | <function> | udf ([ <val> [, <val> 匽])
  | NULL | USER | RDB$DB_KEY | ?
  } [COLLATE collation]
  <constant> = num | ' string' | charsetname ' string'
  <function> = CAST ( <val> AS < datatype>)
  | UPPER ( <val>)
  | GEN_ID ( generator, <val>)
  *)
  Result := StatementState;
  TokenStr := UpperCase(OwnerParser.TokenString);
  case OwnerParser.TokenType of
    stSymbol: begin
      if TokenStr = 'INSERT' then
        Result := issInsertInto
      else if TokenStr = 'INTO' then
        Result := issInsertTable
      else if TokenStr = 'VALUES' then
        Result := issInsertValues
      else if TokenStr = 'SELECT' then
        Result := issInsertSelect;
    end;
    stLParen:
      if StatementState = issInsertTable then
        Result := issColumnList;
    stRParen:
      if StatementState = issColumnList then
        Result := issAfterColumnList;
    stEnd:
      Result := issStatementComplete;
  end;
end;

function TgaInsertSQLStatement.GetStatementType: TSQLStatementType;
begin
  Result := sstInsert;
end;

procedure TgaInsertSQLStatement.ModifyStatementInNormalState(Sender: TObject; 
        AToken: TgaSQLTokenObj);
begin
  inherited;
  StatementState := GetNewStatementState;
  if InternalStatementState > 0 then
    case StatementState of
      issNone:
          { the statement starts with comment or whitespace };
      issInsertInto:
          { waiting for 'INTO' keyword }
        if not (AToken.TokenType in [stDelimitier, stComment]) then
          StatusCode := errWrongKeywordSequence;
      issInsertTable:
        StatementTable.ExecuteTokenAdded(Sender, AToken);
      issColumnList: begin
        if InternalStatementState = 1 then
        begin
          FInsertFields := TgaSQLFieldList.Create(Self);
          InternalStatementState := 2;
        end;
        InsertFields.ExecuteTokenAdded(Sender, AToken);
      end;
      issAfterColumnList:
          { Do nothing as select or values should follow};
      issInsertValues: begin
        if InternalStatementState = 1 then
        begin
          FInsertValues := TgaSQLExpression.Create(Self);
          InternalStatementState := 2;
        end;
        InsertValues.ExecuteTokenAdded(Sender, AToken);
      end;
      issInsertSelect:
        SelectStm.DoTokenAdded(Self, AToken);
      issStatementComplete:
        DoStatementComplete;
      else
        raise Exception.CreateFmt(SUnknownStatementState,
          [ClassName, GetEnumName(TypeInfo(TInsertStatementState), Ord(StatementState))]);
    end
  else
    InternalStatementState := 1;
end;

procedure TgaInsertSQLStatement.SetStatementState(Value: TInsertStatementState);
begin
  if StatementState <> Value then
  begin
    if StatusCode = 0 then
      if Value in InsertAllowedNextState[FStatementState] then
      begin
        DoBeforeStatementStateChange(Ord(Value));
        FStatementState := Value;
        InternalStatementState := 0;
        DoAfterStatementStateChange;
      end else
        StatusCode := errWrongKeywordSequence;
    if Value = issStatementComplete then
    begin
      DoBeforeStatementStateChange(Ord(Value));
      FStatementState := Value;
      InternalStatementState := 0;
      DoAfterStatementStateChange;
    end;
  end;
end;

end.