absexpressions.pas

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

unit ABSExpressions;

interface

{$I ABSVer.inc}

uses Classes, SysUtils, DB,
{$IFDEF D6H}
     Variants,
     DateUtils,
{$ELSE}
     ABSD4Routines,
{$ENDIF}

     {$IFDEF DEBUG_LOG}
     ABSDebug,
     {$ENDIF}

     ABSBase,
     ABSVariant,
     ABSLexer,
     ABSExcept,
     ABSConst,
     ABSTypes,
     ABSConverts,
     ABSRelationalAlgebra,
     ABSDateFormat;


type

 TABSExprNodeType = (entField, entConst, entOperator, entSet, entNull);
 TSign = (sgnUndefined, sgnPlus, sgnMinus);

 TABSQuantifier = (qUNDEFINED, qALL, qANY);


  // forward declarations
  TABSExprNode = class;
  TABSExprNodeComparison = class;
  TABSExprNodeArray = array of TABSExprNode;

////////////////////////////////////////////////////////////////////////////////
//
// TABSExpression
//
////////////////////////////////////////////////////////////////////////////////


  TABSExpression = class (TObject)
   private
    LLex: TABSLexer;   // lexer with expression to parse
    Token: TToken;     // current token
    LCursor: TABSCursor;
    LDataset: TDataset;
    FRootExprNode: TABSExprNode;
    FCaseInsensitive: Boolean;
    FPartialKey: Boolean;
    F3ValueLogic: Boolean;
    FInMemory:    Boolean;
    FDatabaseName: String;
    FSessionName: String;
   private
    // gets current token
    function GetCurrentToken: Boolean;
    // gets next token
    function GetNextToken: Boolean; overload;
    // gets next token
    //function GetNextToken(NativeErrorCode: integer): Boolean; overload;
    // gets token and lokks at next token with check for token type restrictions
    function GetNextToken(PermittedTypes: TTokenTypes;
                          RaiseExceptions: Boolean = False): Boolean; overload;

   private
    // saves internal state (to restore in case of not successful forward parsing)
    procedure SaveState(var SavedTokenNo: integer);// var SavedRootNode: TABSExprNode);
    // restores internal state (in case of not successful forward parsing)
    procedure RestoreState(SavedTokenNo: integer);// SavedRootNode: TABSExprNode);

    // parses <,>,=,<>,>=,<=
    function ParseCompOp: TABSDataOperator;
    // parses ALL, ANY, SOME
    function ParseQuantifier: TABSQuantifier;
    // parses <row value constructor element>
    function ParseRowValueConstructorElement: TABSExprNode;
    // parses <row subquery>
    function ParseRowSubquery(MustHaveOneRow: Boolean; MustHaveOneField: Boolean=True): TABSExprNode;
    // parses <row value constructor element> | <row subquery>
    function ParseRowValueConstructor: TABSExprNode;
    // parses <row value constructor> <comp op> <quantifier> <row value constructor>
    function ParseQuantifiedComparisonPredicate: TABSExprNode;
    // parses <row value constructor> <comp op> <row value constructor>
    function ParseComparisonPredicate: TABSExprNode;
    // parses <match value> [ NOT ] LIKE <pattern> [ ESCAPE <escape character> ]
    function ParseLikePredicate: TABSExprNode;
    // parses <row value constructor> IS [ NOT ] NULL
    function ParseNullPredicate: TABSExprNode;
    // parses <between predicate>
    function ParseBetweenPredicate: TABSExprNode;
    // parses <in predicate>
    function ParseInPredicate: TABSExprNode;
    // parses <exists predicate>
    function ParseExistsPredicate: TABSExprNode;
    // parses <true/false>
    function ParseTrueFalseConst: TABSExprNode;
    // parses <NULL> const
    function ParseNullConst: TABSExprNode;
    // parses <comparison predicate> | <between predicate> | <in predicate>  |
    // <like predicate>  | <null predicate> | <quantified comparison predicate> |
    // <exists predicate> | <unique predicate> | <match predicate> | <overlaps predicate>
    function ParsePredicate: TABSExprNode;
    // parses <predicate>  | <left paren> <search condition> <right paren> | <row value constructor>
    function ParseBooleanPrimary: TABSExprNode;
    // parses <boolean primary> [ IS [ NOT ] <truth value> ]
    function ParseBooleanTest: TABSExprNode;
    // parses [ NOT ] <boolean test>
    function ParseBooleanFactor: TABSExprNode;
    // parses <boolean factor> | <boolean term> AND <boolean factor>
    function ParseBooleanTerm: TABSExprNode;
    // parses <boolean term> | <search condition> OR <boolean term>
    function ParseSearchCondition: TABSExprNode;

    // parses <value expression>
    function ParseValueExpression: TABSExprNode;
    // parses <numeric value expression>
    function ParseNumericValueExpression: TABSExprNode;
    // parses <term>
    function ParseTerm: TABSExprNode;
    // parses <factor>
    function ParseFactor: TABSExprNode;
    // parses <sign> ('+' or '-')
    function ParseSign: TSign;
    // parses <numeric primary>
    function ParseNumericPrimary: TABSExprNode;
    // parses <value expression primary>
    function ParseValueExpressionPrimary: TABSExprNode;
    // parses <unsigned value specification>
    function ParseUnsignedValueSpecification: TABSExprNode;
    // parses <unsigned literal>
    function ParseUnsignedLiteral: TABSExprNode;
    // parses <unsigned numeric literal>
    function ParseUnsignedNumericLiteral: TABSExprNode;
    // parses <column reference>
    function ParseColumnReference: TABSExprNode;
    // parses <set function specification>
    function ParseSetFunctionSpecification: TABSExprNode;
    // parses <general set function>
    function ParseGeneralSetFunction: TABSExprNode;
    // parses <cast specification>
    function ParseCastSpecification: TABSExprNode;
    // parses <cast operand>
    function ParseCastOperand: TABSExprNode;

    // parses <numeric value function>
    function ParseNumericValueFunction: TABSExprNode;
    // parses <position expression>
    function ParsePositionExpression: TABSExprNode;
    // parses <extract expression>
    function ParseExtractExpression: TABSExprNode;
    // parses <length expression>
    function ParseLengthExpression: TABSExprNode;
    // parses <LastAutoInc expression>
    function ParseLastAutoIncExpression: TABSExprNode;
    // parses <RowNum expression>
    function ParseRowNumExpression: TABSExprNode;
    // parses <x(y) expression>
    function ParseSingleArgMathExpression(rw: TReservedWord;
                            op: TABSDataOperator; OpText: String): TABSExprNode;
    // parses <ABS expression>
    function ParseABSExpression: TABSExprNode;
    // parses <ACOS expression>
    function ParseACOSExpression: TABSExprNode;
    // parses <ASIN expression>
    function ParseASINExpression: TABSExprNode;
    // parses <ATAN expression>
    function ParseATANExpression: TABSExprNode;
    // parses <CEIL expression>
    function ParseCEILExpression: TABSExprNode;
    // parses <COS expression>
    function ParseCOSExpression: TABSExprNode;
    // parses <EXP expression>
    function ParseEXPExpression: TABSExprNode;
    // parses <FLOOR expression>
    function ParseFLOORExpression: TABSExprNode;
    // parses <LOG expression>
    function ParseLOGExpression: TABSExprNode;
    // parses <POWER expression>
    function ParsePOWERExpression: TABSExprNode;
    // parses <RAND expression>
    function ParseRANDExpression: TABSExprNode;
    // parses <ROUND expression>
    function ParseROUNDExpression: TABSExprNode;
    // parses <SIGN expression>
    function ParseSIGNExpression: TABSExprNode;
    // parses <SIN expression>
    function ParseSINExpression: TABSExprNode;
    // parses <SQR expression>
    function ParseSQRExpression: TABSExprNode;
    // parses <SQRT expression>
    function ParseSQRTExpression: TABSExprNode;
    // parses <math expression>
    function ParseMathExpression: TABSExprNode;

    // parses <string value expression>
    function ParseStringValueExpression: TABSExprNode;
    // parses <character value expression>
    function ParseCharacterValueExpression: TABSExprNode;
    // parses <concatenation>
    function ParseConcatination: TABSExprNode;
    // parses <character factor>
    function ParseCharacterFactor: TABSExprNode;
    // parses <character primary>
    function ParseCharacterPrimary: TABSExprNode;
    // parses <general literal>
    function ParseGeneralLiteral: TABSExprNode;
    // parses <character string literal>
    function ParseCharacterStringLiteral: TABSExprNode;
    // parses <datetime literal>
    function ParseDateTimeLiteral: TABSExprNode;
    // parses <date literal>
    function ParseDateLiteral: TABSExprNode;
    // parses <date string>
    function ParseDateString: TABSExprNode;
    // parses <time literal>
    function ParseTimeLiteral: TABSExprNode;
    // parses <time string>
    function ParseTimeString: TABSExprNode;
    // parses <timestamp literal>
    function ParseTimeStampLiteral: TABSExprNode;
    // parses <timestamp string>
    function ParseTimeStampString: TABSExprNode;
    // parses <string value function>
    function ParseStringValueFunction: TABSExprNode;
    // parses <character value function>
    function ParseCharacterValueFunction: TABSExprNode;

    // parse <datetime value expression>
    function ParseDatetimeValueExpression: TABSExprNode;
    // parse <datetime sysdate function>
    function ParseSysdateFunction: TABSExprNode;
    // parse <datetime CURRENT_TIME function>
    function ParseCurrentTimeFunction: TABSExprNode;
    // parse <datetime CURRENT_DATE function>
    function ParseCurrentDateFunction: TABSExprNode;
    // parse <datetime TODATE function>
    function ParseToDateFunction: TABSExprNode;

    // parse <interval value expression>
    function ParseIntervalValueExpression: TABSExprNode;

    // parse <case expression>
    function ParseCaseExpression: TABSExprNode;
    // parse <case abbreviation>
    function ParseCaseAbbreviation: TABSExprNode;
    // parse <coalesce>
    function ParseCoalesce: TABSExprNode;
    // parse <case specification>
    function ParseCaseSpecification: TABSExprNode;
    // parse <simple case>
    function ParseSimpleCase: TABSExprNode;
    // parse <searched case>
    function ParseSearchedCase: TABSExprNode;

    // parse Blob Expression
    function ParseBlobExpression: TABSExprNode;
    // parse MimeToBin Function
    function ParseMimeToBinFunction: TABSExprNode;



   private
    procedure Clear;
   public
    // Constructors
    constructor Create; overload;
    // creates
    constructor Create(RootNode: TABSExprNode); overload;
    //constructor Create(Lexer: TABSLexer); overload;
    // Destructor
    destructor Destroy; override;
   public
    // Parsing for Locate
    procedure ParseForLocate(
                              Cursor: TABSCursor;
                              FieldNames: String;
                              KeyValues: Variant;
                              CaseInsensitive: boolean = true;
                              PartialKey: boolean = false
                            );
    // Parsing for Filter
    procedure ParseForFilter(
                              Cursor: TABSCursor;
                              Filter: String;
                              CaseInsensitive: boolean = true;
                              PartialKey: boolean = false
                            );
    // parse for IsAnyRecordMatchCondition (for quantified subquery comparison)
    procedure ParseForIsAnyRecordMatchCondition(
                                           Cursor: TABSCursor;
                                           const FieldName: string;
                                           const Operator: TABSDataOperator;
                                           const Value: TABSVariant
                                           );
    // Parse For Boolean Expression (Filter, Where-Clause)
    procedure ParseForBooleanExpression(
                                        Dataset: TDataset;
                                        Lexer: TABSLexer
                                        //CaseInsensitive: boolean = true;
                                        //PartialKey: boolean = false
                                       );
    // Parse ValueExpression
    procedure ParseForValueExpression(
                                        Dataset: TDataset;
                                        Lexer: TABSLexer
                                        //CaseInsensitive: boolean = true;
                                        //PartialKey: boolean = false
                                       );
    // default value: const or function
    function  ParseForDefaultValueExpression(DefaultValue: String): Boolean;
    // Parse RowSubqueryExpression
    procedure ParseForRowSubqueryExpression(
                                        Dataset: TDataset;
                                        Lexer: TABSLexer
                                       );
    // Return Variant
    function GetValue(TrueFalseNullLogic: boolean = true): TABSVariant;
    // Get Boolean result
    function GetResult: Boolean;
    // calc subquery field values again
    procedure ResetSubqueryFieldValues;
    // Return subquery field value
    function GetSubqueryFieldValue(FieldNo: Integer): TABSVariant;


    // is expression contains aggregated function
    function IsAggregated: Boolean;
    function IsAggregatedCountAll: Boolean;
    // Init for aggregated functions
    procedure Init;
    // Accumulate for group functions
    procedure Accumulate;
    procedure SetCountAll(RecordCount: Integer);
    // process assign AO
    procedure AssignAO(AO, ParentQueryAO: TABSAO; ParentCursor: TABSCursor);
    // process assign Cursor and its RecordBuffer
    procedure AssignCursor(Cursor: TABSCursor; ParentQueryAO: TABSAO; ParentCursor: TABSCursor);
    // process assign New Cursor Buffer
    procedure AssignCursorBuffer(Buffer: TABSRecordBuffer; ApplyToParentQueryFields: Boolean);
    // return Type of Data
    function GetDataType: TABSAdvancedFieldType;
    // return Size of Data (for strings and arrays)
    function GetDataSize: Integer;