unit MYLDBExpressions;

interface

{$I MYLDBVer.inc}

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

     {$IFDEF DEBUG_LOG}
     MYLDBDebug,
     {$ENDIF}

     MYLDBBase,
     MYLDBVariant,
     MYLDBLexer,
     MYLDBExcept,
     MYLDBConst,
     MYLDBTypes,
     MYLDBConverts,
     MYLDBRelationalAlgebra,
     MYLDBDateFormat;


type

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

 TMYLDBQuantifier = (qUNDEFINED, qALL, qANY);


  // forward declarations
  TMYLDBExprNode = class;
  TMYLDBExprNodeComparison = class;
  TMYLDBExprNodeArray = array of TMYLDBExprNode;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBExpression
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBExpression = class (TObject)
   private
    LLex: TMYLDBLexer;   // lexer with expression to parse
    Token: TToken;     // current token
    LCursor: TMYLDBCursor;
    LDataset: TDataset;
    FRootExprNode: TMYLDBExprNode;
    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: TMYLDBExprNode);
    // restores internal state (in case of not successful forward parsing)
    procedure RestoreState(SavedTokenNo: integer);// SavedRootNode: TMYLDBExprNode);

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

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

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

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

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

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

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

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



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


    // 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: TMYLDBAO; ParentCursor: TMYLDBCursor);
    // process assign Cursor and its RecordBuffer
    procedure AssignCursor(Cursor: TMYLDBCursor; ParentQueryAO: TMYLDBAO; ParentCursor: TMYLDBCursor);