abssqlprocessor.pas

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

                    case Token.ReservedWord of
                      rwTABLE:  // CREATE TABLE
                                AddCreateTableQuery(Lexer);
                      rwINDEX,
                      rwUNIQUE: // CREATE INDEX or UNIQUE INDEX
                                AddCreateIndex(Lexer);
                      else raise EABSException.Create(30147, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);
                    end
                  else raise EABSException.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 EABSException.Create(30149, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);
                    end
                  else raise EABSException.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 EABSException.Create(30151, ErorrGObjectTypeKeywordExpected,
                             [Token.Text, Token.LineNum, Token.ColumnNum]);

                    end
                  else raise EABSException.Create(30152, ErrorGUnexpectedEndOfCommand,
                            [Token.LineNum, Token.ColumnNum]);
                end;
      rwRENAME:   // RENAME
                begin
                  if (not Lexer.GetNextToken(Token)) then
                    raise EABSException.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 EABSException.Create(30153, ErrorGSQLCommandExpected,
                                 [Token.Text, Token.LineNum, Token.ColumnNum]);
     end
   else
    // '( SELECT ...) ' ?
    if (Token.TokenType = tktLeftParenthesis) then
     AddSelectQuery(Lexer)
    else
     raise EABSException.Create(30154, ErrorGSQLCommandExpected,
                         [Token.Text, Token.LineNum, Token.ColumnNum]);
  end
 else
   Result := False;
end;// Parse


//------------------------------------------------------------------------------
// adds SELECT query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddSelectQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLUnion.Create(Lexer, ABSQuery);
  if (Queries[OldQueryCount].GetCurrentToken) then
    raise EABSException.Create(20260, ErrorAEndOfCommandExpected,
                                 [Queries[OldQueryCount].Token.Text, Queries[OldQueryCount].Token.LineNum, Queries[OldQueryCount].Token.ColumnNum]);
end;// AddSelectQuery


//------------------------------------------------------------------------------
// adds INSERT query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddInsertQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLInsert.Create(Lexer, ABSQuery);
end;//AddInsertQuery


//------------------------------------------------------------------------------
// adds UPDATE query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddUpdateQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLUpdate.Create(Lexer, ABSQuery);
end;//AddUpdateQuery


//------------------------------------------------------------------------------
// adds DELETE query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddDeleteQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLDelete.Create(Lexer, ABSQuery);
end;//AddDeleteQuery


//------------------------------------------------------------------------------
// adds TRUNCATE TABLE query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddTruncateTableQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSDDLTruncateTable.Create(Lexer, ABSQuery);
end;//AddTruncateTableQuery


//------------------------------------------------------------------------------
// adds CREATE TABLE query object
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddCreateTableQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSDDLCreateTable.Create(Lexer, ABSQuery);
  //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 TABSSQLProcessor.AddDropTableQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSDDLDropTable.Create(Lexer, ABSQuery);
end;//AddDropTableQuery


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


//------------------------------------------------------------------------------
// add RENAME TABLE
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddRenameTableQuery(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSDDLRenameTable.Create(Lexer, ABSQuery);
end;//AddRenameTableQuery


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


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


//------------------------------------------------------------------------------
// add START TRANSACTION
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddStartTransaction(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLStartTransaction.Create(Lexer, ABSQuery);
end;//AddStartTransaction



//------------------------------------------------------------------------------
// add COMMIT
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddCommit(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLCommit.Create(Lexer, ABSQuery);
end;//AddStartTransaction



//------------------------------------------------------------------------------
// add ROLLBACK
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.AddRollback(Lexer: TABSLexer);
var
  OldQueryCount: Integer;
begin
  OldQueryCount := Length(Queries);
  SetLength(Queries, OldQueryCount+1);
  Queries[OldQueryCount] := TABSSQLRollback.Create(Lexer, ABSQuery);
end;//AddStartTransaction


//------------------------------------------------------------------------------
// ClearQueries
//------------------------------------------------------------------------------
procedure TABSSQLProcessor.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


////////////////////////////////////////////////////////////////////////////////
//
// TABSSQLSelect
//
////////////////////////////////////////////////////////////////////////////////


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


//------------------------------------------------------------------------------
// Destructor
//------------------------------------------------------------------------------
destructor TABSSQLSelect.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 TABSSQLSelect.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 TABSSQLSelect.BuildAOTree(query: TDataset; RequestLive: Boolean; ParentQueryAO: TABSAO;
          ParentCursor: TABSCursor; AllowNotAppliedConditions: Boolean): TABSAO;
var
  i, j: integer;
  bAnyExpressions: Boolean;
  bGroupBy: Boolean;
  GroupByAO: TABSAO;
  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);

 try
  // create group by AO?
  bGroupBy := (GroupByFields.ItemCount > 0);
  // check for aggregates in select list
  if (not bGroupBy) then
   if (not AllFields) then
    begin
     for i := 0 to SelectListCount-1 do
      if (SelectList[i].ValueExpr <> nil) then
       if (TABSExpression(SelectList[i].ValueExpr).IsAggregated) then
        begin
         bGroupBy := True;
         break;
        end;
    end;