if scop^.GetAsRawUTF8('match',match) and fHasFTS then begin
    if scop^.GetAsDouble('lastrank',rank) then
      whereClause := 'and rank<? ';
    whereClause := 'join (select docid,rank(matchinfo(ArticleSearch),1) as rank '+
      'from ArticleSearch where ArticleSearch match ? '+whereClause+
      'order by rank desc'+ARTICLE_DEFAULT_LIMIT+')as r on (r.docid=Article.id)';
    articles := RestModel.RetrieveDocVariantArray(
      TSQLArticle,'',pointer(whereClause),[match,rank],
      'id,title,tags,author,authorname,createdat,abstract,contenthtml,rank');
    with DocVariantDataSafe(articles)^do
      if (Kind=dvArray) and (Count>0) then
        rank := Values[Count-1].rank else
        rank := 0;
    scope := _ObjFast(['Articles',articles,'lastrank',rank,'match',match]);
    exit;
................................................................................
      // uses custom function to search in BLOB
      whereClause := whereClause+' and IntegerDynArrayContains(Tags,?)';
  end;
  SetVariantNull(Scope);
  if (lastID=0) and (tag=0) then begin // use simple cache if no parameters
    if not fDefaultData.AddExistingProp('Articles',Scope) then
      fDefaultData.AddNewProp('Articles',RestModel.RetrieveDocVariantArray(
        TSQLArticle,'',pointer(ARTICLE_DEFAULT_ORDER),[],
        ARTICLE_FIELDS,nil,@fDefaultLastID),Scope);
    lastID := fDefaultLastID;
  end else // use more complex request using lastID + tag parameters
    scope := _ObjFast(['Articles',RestModel.RetrieveDocVariantArray(
        TSQLArticle,'',Pointer(whereClause+ARTICLE_DEFAULT_ORDER),[lastID,tag],
        ARTICLE_FIELDS,nil,@lastID)]);
  if lastID>1 then begin
    _ObjAddProps(['lastID',lastID],Scope);
    _ObjAddProps(['tag',tag],Scope); // should be there for a valid Scope object 
  end;
end;

  if scop^.GetAsRawUTF8('match',match) and fHasFTS then begin
    if scop^.GetAsDouble('lastrank',rank) then
      whereClause := 'and rank<? ';
    whereClause := 'join (select docid,rank(matchinfo(ArticleSearch),1) as rank '+
      'from ArticleSearch where ArticleSearch match ? '+whereClause+
      'order by rank desc'+ARTICLE_DEFAULT_LIMIT+')as r on (r.docid=Article.id)';
    articles := RestModel.RetrieveDocVariantArray(
      TSQLArticle,'',whereClause,[match,rank],
      'id,title,tags,author,authorname,createdat,abstract,contenthtml,rank');
    with DocVariantDataSafe(articles)^do
      if (Kind=dvArray) and (Count>0) then
        rank := Values[Count-1].rank else
        rank := 0;
    scope := _ObjFast(['Articles',articles,'lastrank',rank,'match',match]);
    exit;
................................................................................
      // uses custom function to search in BLOB
      whereClause := whereClause+' and IntegerDynArrayContains(Tags,?)';
  end;
  SetVariantNull(Scope);
  if (lastID=0) and (tag=0) then begin // use simple cache if no parameters
    if not fDefaultData.AddExistingProp('Articles',Scope) then
      fDefaultData.AddNewProp('Articles',RestModel.RetrieveDocVariantArray(
        TSQLArticle,'',ARTICLE_DEFAULT_ORDER,[],
        ARTICLE_FIELDS,nil,@fDefaultLastID),Scope);
    lastID := fDefaultLastID;
  end else // use more complex request using lastID + tag parameters
    scope := _ObjFast(['Articles',RestModel.RetrieveDocVariantArray(
        TSQLArticle,'',whereClause+ARTICLE_DEFAULT_ORDER,[lastID,tag],
        ARTICLE_FIELDS,nil,@lastID)]);
  if lastID>1 then begin
    _ObjAddProps(['lastID',lastID],Scope);
    _ObjAddProps(['tag',tag],Scope); // should be there for a valid Scope object 
  end;
end;

    - BREAKING CHANGE with newly added reSQLSelectWithoutTable security policy
      flags in TSQLAccessRight.AllowRemoteExecute - older applications which
      expected any SELECT statement to be executed on the server may break:
      you need to explicitely set this flag for the User's TSQLAuthGroup - note
      that SELECT with a simple table name in its FROM clause will now be
      checked againsts TSQLAccessRight.GET[] access rights
    - BREAKING CHANGE: added aSentData parameter to TNotifySQLEvent/OnUpdateEvent


    - remove some unused TPropInfo methods, which were duplicates of the
      TSQLPropInfo cleaner class hierarchy: SetValue/GetValue/GetValueVar
      GetBinary/SetBinary GetVariant/SetVariant NormalizeValue/SameValue GetHash
      IsSimpleField AppendName GetCaption GetSQLFromFieldValue SetFieldAddr
    - following the Liskov substitution principle, Execute/ExecuteFmt and
      protected EngineExecute() are defined for TSQLRest, replacing ExecuteAll()
    - TSQLRestServerRemoteDB will now redirect into any TSQLRest instance
................................................................................

/// will serialize any TObject into a TDocVariant document
// - just a wrapper around _JsonFast(ObjectToJSONDebug()) with an optional
// "Context":"..." text message
// - if the supplied context format matches '{....}' then it will be added
// as a corresponding TDocVariant JSON object
function ObjectToVariantDebug(Value: TObject;
  ContextFormat: PUTF8Char; const ContextArgs: array of const;
  const ContextName: RawUTF8='context'): variant; overload;

/// will serialize any TObject into a TDocVariant document
// - just a wrapper around _JsonFast(ObjectToJSONDebug()) 
function ObjectToVariantDebug(Value: TObject): variant; overload;

/// encode supplied parameters to be compatible with URI encoding
................................................................................
    // supplied error text
    // - if no ErrorMessage is specified, will return a default text
    // corresponding to the Status code
    procedure Error(const ErrorMessage: RawUTF8='';
      Status: integer=HTML_BADREQUEST); overload;
    /// use this method to send back an error to the caller
    // - implementation is just a wrapper over Error(FormatUTF8(Format,Args))
    procedure Error(Format: PUTF8Char; const Args: array of const;
      Status: integer=HTML_BADREQUEST); overload;
    /// use this method to send back an error to the caller
    // - will serialize the supplied exception, with an optional error message
    procedure Error(E: Exception; Format: PUTF8Char; const Args: array of const;
      Status: integer=HTML_BADREQUEST); overload;
    /// at Client Side, compute URI and BODY according to the routing scheme
    // - abstract implementation which is to be overridden
    // - as input, method should be the method name to be executed,
    // params should contain the incoming parameters as JSON CSV (without []),
    // and clientDriven ID should contain the optional Client ID value 
    // - at output, should update the HTTP uri corresponding to the proper
................................................................................
      identified as '?' in the FormatSQLWhere statement, which is expected to
      follow the order of values supplied in BoundsSQLWhere open array - use
      DateToSQL/DateTimeToSQL for TDateTime, or directly any integer / double /
      currency / RawUTF8 values to be bound to the request as parameters
    - note that this method prototype changed with revision 1.17 of the
      framework: array of const used to be ParamsSQLWhere and '%' in the
      FormatSQLWhere statement, whereas it now expects bound parameters as '?' }
    constructor Create(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const); overload;
    {/ this constructor initializes the object as above, and fills its content
      from a client or server connection, using a specified WHERE clause
      with parameters
      - the FormatSQLWhere clause will replace all '%' chars with the supplied
      ParamsSQLWhere[] values, and all '?' chars with BoundsSQLWhere[] values,
      as :(...): inlined parameters - you should either call:
................................................................................
      or (letting the inlined parameters being computed by FormatUTF8)
      !  Rec := TSQLMyRecord.Create(aClient,'Count=?',[],[aCount]);
      or even better, using the other Create overloaded constructor:
      !  Rec := TSQLMyRecord.Create(aClient,'Count=?',[aCount]);
      - using '?' and BoundsSQLWhere[] is perhaps more readable in your code, and
      will in all case create a request with :(..): inline parameters, with
      automatic RawUTF8 quoting if necessary }
    constructor Create(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const ParamsSQLWhere, BoundsSQLWhere: array of const); overload;

    {/ this constructor initializes the object as above, and prepares itself to
      loop through a statement using a specified WHERE clause
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the WHERE clause, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
................................................................................
        you may need  to access only one or several fields, and will save remote
        bandwidth by specifying the needed fields
      - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs
      - note that you should not use this aCustomFieldsCSV optional parameter if
        you want to Update the retrieved record content later, since any
        missing fields will be left with previous values - but BatchUpdate() can be
        safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    constructor CreateAndFillPrepare(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''); overload;
    {/ this constructor initializes the object as above, and prepares itself to
      loop through a statement using a specified WHERE clause
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the WHERE clause, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
      - you should then loop for all rows using 'while Rec.FillOne do ...'
................................................................................
        you may need  to access only one or several fields, and will save remote
        bandwidth by specifying the needed fields
      - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs
      - note that you should not use this aCustomFieldsCSV optional parameter if
        you want to Update the retrieved record content later, since any
        missing fields will be left with previous values - but BatchUpdate() can be
        safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    constructor CreateAndFillPrepare(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const ParamsSQLWhere, BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''); overload;
    {/ this constructor initializes the object as above, and prepares itself to
      loop through a given list of IDs
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the specified IDs, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
................................................................................
        $  p.Owner='mark' and c.Name='for boy' and (s.Name='small' or s.Name='medium')
      - you SHALL call explicitely the FillClose method before using any
        methods of nested TSQLRecordMany instances which may override the Dest
        instance content (e.g. ManySelect) to avoid any GPF
      - the aFormatSQLJoin clause will replace all '%' chars with the supplied
        aParamsSQLJoin[] supplied values, and bind all '?' chars as bound
        parameters with aBoundsSQLJoin[] values }
    constructor CreateAndFillPrepareMany(aClient: TSQLRest; aFormatSQLJoin: PUTF8Char;
      const aParamsSQLJoin, aBoundsSQLJoin: array of const);

    {/ this method create a clone of the current record, with same ID and properties
      - copy all COPIABLE_FIELDS, i.e. all fields excluding tftMany (because
        those fields don't contain any data, but a TSQLRecordMany instance
        which allow to access to the pivot table data)
      - you can override this method to allow custom copy of the object,
................................................................................
       you may need  to access only one or several fields, and will save remote
       bandwidth by specifying the needed fields
     - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs 
     - note that you should not use this aCustomFieldsCSV optional parameter if
       you want to Update the retrieved record content later, since any
       missing fields will be left with previous values - but BatchUpdate() can be
       safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    function FillPrepare(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''): boolean; overload;
    {/ prepare to get values using a specified WHERE clause with '%' and '?' parameters
     - returns true in case of success, false in case of an error during SQL request
     - then call FillRow(1..Table.RowCount) to get any row value
     - or you can also loop through all rows with
     ! while Rec.FillOne do
     !   dosomethingwith(Rec);
................................................................................
       you may need  to access only one or several fields, and will save remote
       bandwidth by specifying the needed fields
     - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs 
     - note that you should not use this aCustomFieldsCSV optional parameter if
       you want to Update the retrieved record content later, since any
       missing fields will be left with previous values - but BatchUpdate() can be
       safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    function FillPrepare(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
      const ParamsSQLWhere, BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): boolean; overload;
    {/ prepare to get values from a list of IDs
     - returns true in case of success, false in case of an error during SQL request
     - then call FillRow(1..Table.RowCount) to get any row value
     - or you can also loop through all rows with
     ! while Rec.FillOne do
................................................................................
     - the FormatSQLWhere clause will replace all '%' chars with the supplied
       ParamsSQLWhere[] supplied values, and bind all '?' chars as parameters
       with BoundsSQLWhere[] values
     - you SHALL call explicitely the FillClose method before using any
       methods of nested TSQLRecordMany instances which may override the Dest
       instance content (e.g. ManySelect) to avoid any GPF
     - is used by TSQLRecord.CreateAndFillPrepareMany constructor }
    function FillPrepareMany(aClient: TSQLRest; aFormatSQLJoin: PUTF8Char;
      const aParamsSQLJoin, aBoundsSQLJoin: array of const): boolean;
    {/ fill all published properties of an object from a TSQLTable prepared row
      - FillPrepare() must have been called before
      - if Dest is nil, this object values are filled
      - if Dest is not nil, this object values will be filled, but it won't
        work with TSQLRecordMany properties (i.e. after FillPrepareMany call)
      - ID field is updated if first Field Name is 'ID'
................................................................................
  public
    /// constructor of one parameters marshalling instance
    constructor Create(aSender: TInterfaceStub; aMethod: PServiceMethod;
      const aParams,aEventParams: RawUTF8); virtual;
    /// call this method if the callback implementation failed
    procedure Error(const aErrorMessage: RawUTF8); overload;
    /// call this method if the callback implementation failed
    procedure Error(Format: PUTF8Char; const Args: array of const); overload;
    /// the stubbing / mocking generator
    property Sender: TInterfaceStub read fSender;
    /// the mocking generator associated test case
    // - will raise an exception if the associated Sender generator is not
    // a TInterfaceMock
    property TestCase: TSynTestCase read GetSenderAsMockTestCase;
    /// pointer to the method which is to be executed
................................................................................
    fLogs: TInterfaceStubLogDynArray;
    fLog: TDynArray;
    fLogCount: integer;
    fInterfaceExpectedTraceHash: cardinal;
    function TryResolve(aInterface: PTypeInfo; out Obj): boolean; override;
    procedure InternalGetInstance(out aStubbedInterface); virtual;
    function InternalCheck(aValid,aExpectationFailed: boolean;
      aErrorMsgFmt: PUTF8Char; const aErrorMsgArgs: array of const): boolean; virtual;
    // match TOnFakeInstanceInvoke callback signature
    function Invoke(const aMethod: TServiceMethod;
      const aParams: RawUTF8; aResult, aErrorMsg: PRawUTF8;
      aClientDrivenID: PCardinal; aServiceCustomAnswer: PServiceCustomAnswer): boolean;
    // will launch InternalCheck() process if some expectations defined by
    // ExpectsCount() are not met, i.e. raise an exception for TInterfaceStub
    // or notify the associated test case for TInterfaceMock
................................................................................
  // are defined before running the test, and verification is performed
  // when the instance is released - use TInterfaceMockSpy if you prefer the
  // more explicit run-verify pattern
  TInterfaceMock = class(TInterfaceStub)
  protected
    fTestCase: TSynTestCase;
    function InternalCheck(aValid,aExpectationFailed: boolean;
      aErrorMsgFmt: PUTF8Char; const aErrorMsgArgs: array of const): boolean; override;
  public
    /// initialize an interface mock from TypeInfo(IMyInterface)
    // - aTestCase.Check() will be called in case of mocking failure
    // ! procedure TMyTestCase.OneTestCaseMethod;
    // ! var Persist: IPersistence;
    // ! ...
    // !   TInterfaceMock.Create(TypeInfo(IPersistence),Persist,self).
................................................................................
    fLogFamily: TSynLogFamily; // =SQLite3Log.Family by default
    procedure SetLogClass(aClass: TSynLogClass); virtual;
    function GetLogClass: TSynLogClass;
    {$endif}
    /// log the corresponding text (if logging is enabled)
    procedure InternalLog(const Text: RawUTF8; Level: TSynLogInfo); overload;
      {$ifdef HASINLINE}inline;{$endif}
    procedure InternalLog(Format: PWinAnsiChar; const Args: array of const;
      Level: TSynLogInfo); overload;
    /// internal method used by Delete(Table,SQLWhere) method
    function InternalDeleteNotifyAndGetIDs(Table: TSQLRecordClass; const SQLWhere: RawUTF8;
      var IDs: TIDDynArray): boolean; 
    /// retrieve the server time stamp
    // - default implementation will use fServerTimeStampOffset to compute
    // the value from PC time (i.e. NowUTC+fServerTimeStampOffset as TTimeLog)
................................................................................
    // - example of use:
    // ! aClient.OneFieldValue(TSQLRecord,'Name','ID=?',[aID])
    // - call internaly ExecuteList() to get the value
    // - note that this method prototype changed with revision 1.17 of the
    // framework: array of const used to be Args and '%' in the FormatSQLWhere
    // statement, whereas it now expects bound parameters as '?'
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const): RawUTF8; overload;
    /// get the UTF-8 encoded value of an unique field with a Where Clause
    // - this overloaded function will call FormatUTF8 to create the Where Clause
    // from supplied parameters, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! OneFieldValue(TSQLRecord,'Name','%=?',['ID'],[aID])
    // - call internaly ExecuteList() to get the value
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      WhereClauseFmt: PUTF8Char; const Args, Bounds: array of const): RawUTF8; overload;
    /// get one integer value of an unique field with a Where Clause
    // - this overloaded function will return the field value as integer
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      WhereClauseFmt: PUTF8Char; const Args, Bounds: array of const;
      out Data: Int64): boolean; overload;
    /// get the UTF-8 encoded value of an unique field from its ID
    // - example of use: OneFieldValue(TSQLRecord,'Name',23)
    // - call internaly ExecuteList() to get the value
    function OneFieldValue(Table: TSQLRecordClass;
      const FieldName: RawUTF8; WhereID: TID): RawUTF8; overload;
    /// get the UTF-8 encoded value of some fields with a Where Clause
................................................................................
    // - example of use:
    // ! aList := aClient.MultiFieldValues(TSQLRecord,'Name,FirstName','Salary>=?',[aMinSalary]);
    // - call overloaded MultiFieldValues() / ExecuteList() to get the list
    // - note that this method prototype changed with revision 1.17 of the
    // framework: array of const used to be Args and '%' in the WhereClauseFormat
    // statement, whereas it now expects bound parameters as '?'
    function MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
      WhereClauseFormat: PUTF8Char; const BoundsSQLWhere: array of const): TSQLTableJSON; overload;
    /// Execute directly a SQL statement, expecting a list of results
    // - return a result table on success, nil on failure
    // - FieldNames can be the CSV list of field names to be retrieved
    // - if FieldNames is '', will get all simple fields, excluding BLOBs
    // - if FieldNames is '*', will get ALL fields, including ID and BLOBs
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! Table := MultiFieldValues(TSQLRecord,'Name','%=?',['ID'],[aID]);
    // - call overloaded MultiFieldValues() / ExecuteList() to get the list
    function MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
      WhereClauseFormat: PUTF8Char; const Args, Bounds: array of const): TSQLTableJSON; overload;
    /// retrieve the main field (mostly 'Name') value of the specified record
    // - use GetMainFieldName() method to get the main field name
    // - use OneFieldValue() method to get the field value
    // - return '' if no such field or record exists
    // - if ReturnFirstIfNoUnique is TRUE and no unique property is found,
    // the first RawUTF8 property is returned anyway
    function MainFieldValue(Table: TSQLRecordClass; ID: TID;
................................................................................
    /// get a member from a SQL statement
    // - implements REST GET collection
    // - return true on success
    // - same as Retrieve(const SQLWhere: RawUTF8; Value: TSQLRecord) method, but
    // this overloaded function will call FormatUTF8 to create the Where Clause
    // from supplied parameters, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    function Retrieve(WhereClauseFmt: PUTF8Char; const Args,Bounds: array of const;
      Value: TSQLRecord): boolean; overload;
    /// get a member from its ID
    // - return true on success
    // - Execute 'SELECT * FROM TableName WHERE ID=:(aID): LIMIT 1' SQL Statememt
    // - if ForUpdate is true, the REST method is LOCK and not GET: it tries to lock
    // the corresponding record, then retrieve its content; caller has to call
    // UnLock() method after Value usage, to release the record
................................................................................
    // - aCustomFieldsCSV can be the CSV list of field names to be retrieved
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - return a TObjectList on success (possibly with Count=0) - caller is
    // responsible of freeing the instance
    // - this TObjectList will contain a list of all matching records
    // - return nil on error
    function RetrieveList(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): TObjectList; overload;
    /// get a list of members from a SQL statement as RawJSON
    // - implements REST GET collection
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
................................................................................
    // our expanded / not expanded JSON format - so can be used with SOA methods
    // and RawJSON results, for direct process from the client side
    // - returns '' on error
    // - the data is directly retrieved from raw JSON as returned by the database
    // without any conversion, so this method would be the fastest, but complex
    // types like dynamic array would be returned as Base64-encoded blob value -
    // if you need proper JSON access to those, see RetrieveDocVariantArray()
    function RetrieveListJSON(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): RawJSON;
    {$ifndef NOVARIANTS}
    /// get a list of all members from a SQL statement as a TDocVariant
    // - implements REST GET collection
    // - if ObjectName='', it will return a TDocVariant of dvArray kind
    // - if ObjectName is set, it will return a TDocVariant of dvObject kind,
................................................................................
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - the data will be converted to variants and TDocVariant following the
    // TSQLRecord layout, so complex types like dynamic array would be returned
    // as a true array of values (in contrast to the RetrieveListJSON method)
    function RetrieveDocVariantArray(Table: TSQLRecordClass;
      const ObjectName: RawUTF8;
      FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
      const CustomFieldsCSV: RawUTF8; FirstRecordID: PID=nil;
      LastRecordID: PID=nil): variant; overload;
    /// get one member from a SQL statement as a TDocVariant
    // - implements REST GET collection
    // - the data will be converted to a TDocVariant variant following the
    // TSQLRecord layout, so complex types like dynamic array would be returned
    // as a true array of values 
    function RetrieveDocVariant(Table: TSQLRecordClass;
      FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
      const CustomFieldsCSV: RawUTF8): variant; 
    {$endif NOVARIANTS}
    /// get a list of members from a SQL statement as T*ObjArray
    // - implements REST GET collection
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
................................................................................
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - set the T*ObjArray variable with all items on success - so that it can
    // be used with SOA methods
    // - it is up to the caller to ensure that ObjClear(ObjArray) is called
    // when the T*ObjArray list is not needed any more 
    // - returns true on success, false on error
    function RetrieveListObjArray(var ObjArray; Table: TSQLRecordClass;
      FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): boolean;
    /// Execute directly a SQL statement, expecting a list of results
    // - return a result table on success, nil on failure
    // - will call EngineList() abstract method to retrieve its JSON content
    function ExecuteList(const Tables: array of TSQLRecordClass; const SQL: RawUTF8): TSQLTableJSON; virtual;
    /// Execute directly a SQL statement, without any expected result
    // - implements POST SQL on ModelRoot URI
................................................................................
    // - return true on success
    // - will call EngineExecute() abstract method to run the SQL statement
    function Execute(const aSQL: RawUTF8): boolean; virtual;
    /// Execute directly a SQL statement with supplied parameters, with no result
    // - expect the same format as FormatUTF8() function, replacing all '%' chars
    // with Args[] values
    // - return true on success
    function ExecuteFmt(SQLFormat: PUTF8Char; const Args: array of const): boolean; overload;
    /// Execute directly a SQL statement with supplied parameters, with no result
    // - expect the same format as FormatUTF8() function, replacing all '%' chars
    // with Args[] values, and all '?' chars with Bounds[] (inlining them
    // with :(...): and auto-quoting strings)
    // - return true on success
    function ExecuteFmt(SQLFormat: PUTF8Char; const Args, Bounds: array of const): boolean; overload;
    /// unlock the corresponding record
    // - record should have been locked previously e.g. with Retrieve() and
    // forupdate=true, i.e. retrieved not via GET with LOCK REST-like verb
    // - use our custom UNLOCK REST-like verb
    // - returns true on success
    function UnLock(Table: TSQLRecordClass; aID: TID): boolean; overload; virtual; abstract;
    /// unlock the corresponding record
................................................................................
    // TSQLRecordMany kind (i.e. only so called "simple fields")
    // - the aSimpleFields must have exactly the same count of parameters as
    // there are "simple fields" in the published properties
    // - if ForcedID is set to non null, client sends this ID to be used
    // when adding the record (instead of a database-generated ID)
    // - on success, returns the new RowID value; on error, returns 0
    // - call internaly the Add virtual method above
    function Add(aTable: TSQLRecordClass; const aSimpleFields: array of const; ForcedID: TID=0): TID; overload;

    /// update a member from Value simple fields content
    // - implements REST PUT collection
    // - return true on success
    // - the TSQLRawBlob(BLOB) fields values are not updated by this method, to
    // preserve bandwidth: use the UpdateBlob() methods for handling BLOB fields
    // - the TSQLRecordMany fields are not set either: they are separate
    // instances created by TSQLRecordMany.Create, with dedicated methods to
................................................................................
    /// update a member from a supplied list of simple field values
    // - implements REST PUT collection
    // - the aSimpleFields parameters MUST follow explicitely both count and
    // order of published properties of the supplied aTable class, excepting the
    // TSQLRawBlob and TSQLRecordMany kind (i.e. only so called "simple fields")
    // - return true on success
    // - call internaly the Update() / EngineUpdate() virtual methods 

    function Update(aTable: TSQLRecordClass; aID: TID; const aSimpleFields: array of const): boolean; overload;
    /// create or update a member, depending if the Value has already an ID
    // - implements REST POST if Value.ID=0 or PUT collection on Value.ID
    // - will return the created or updated ID
    function AddOrUpdate(Value: TSQLRecord): TID;
    /// update one field/column value a given member
    // - implements REST PUT collection with one field value
    // - only one single field shall be specified in FieldValue, but could
................................................................................
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
    // DateToSQL/DateTimeToSQL for TDateTime, or directly any integer / double /
    // currency / RawUTF8 values to be bound to the request as parameters
    // - is a simple wrapper around:
    // ! Delete(Table,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere))
    function Delete(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const): boolean; overload;

    /// access the internal caching parameters for a given TSQLRecord
    // - purpose of this caching mechanism is to speed up retrieval of some
    // common values at either Client or Server level (like configuration settings)
    // - by default, this CRUD level per-ID cache is disabled
    // - use Cache.SetCache() and Cache.SetTimeOut() methods to set the appropriate
................................................................................
    // double, currency, RawUTF8 values to be bound to the request as parameters
    // - aCustomFieldsCSV can be the CSV list of field names to be retrieved
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - return a TObjectList<T> on success (possibly with Count=0) - caller is
    // responsible of freeing the instance
    // - return nil on error
    function RetrieveList<T: TSQLRecord>(FormatSQLWhere: PUTF8Char;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): TObjectList<T>; overload;
    {$endif}

    /// you can call this method in TThread.Execute to ensure that
    // the thread will be taken in account during process
    // - this abstract method won't do anything, but TSQLRestServer's will
................................................................................
    Where: PAnsiChar;
    /// returned JSON field value of optional total row counts
    // - default value is nil, i.e. no total row counts field
    // - computing total row counts can be very expensive, depending on the
    // database back-end used (especially for external databases)
    // - can be set e.g. to ',"totalRows":%' value (note that the initial "," is
    // expected by the produced JSON content, and % will be set with the value)
    SendTotalRowsCountFmt: PUTF8Char;
  end;

  /// used for statistics update in TSQLRestServer.URI()
  TSQLRestServerStats = class(TPersistent)
  private
    /// used to determine if something changed
    fLastIncomingBytes: QWord;
................................................................................
    fTrackChangesHistoryTableIndex: TIntegerDynArray;
    fTrackChangesHistory: array of record
      CurrentRow: integer;
      MaxSentDataJsonRow: integer;
      MaxRevisionJSON: integer;
      MaxUncompressedBlobSize: integer;
    end;
    function CreateBackgroundThread(Format: PUTF8Char; const Args: array of const): TSynBackgroundThreadMethod;
    function GetAuthenticationSchemesCount: integer;
    /// fast get the associated static server, if any
    function GetStaticDataServer(aClass: TSQLRecordClass): TSQLRest;
    /// retrieve a TSQLRestStorage instance associated to a Virtual Table
    // - is e.g. TSQLRestStorageInMemory instance associated to a
    // TSQLVirtualTableBinary or TSQLVirtualTableJSON class
    // - may be a TSQLRestStorageExternal (as defined in mORMotDB unit)
................................................................................
    /// retrieve a list of members as a TSQLTable
    // - implements REST GET collection
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[] values
    // - using inlined parameters via :(...): in SQLWhereFormat is always a good idea
    // - for one TClass, you should better use TSQLRest.MultiFieldValues()
    // - will call the List virtual method internaly
    function ListFmt(const Tables: array of TSQLRecordClass; const SQLSelect: RawUTF8;
      SQLWhereFormat: PUTF8Char; const Args: array of const): TSQLTableJSON; overload;
    /// retrieve a list of members as a TSQLTable
    // - implements REST GET collection
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! Table := ListFmt([TSQLRecord],'Name','ID=?',[],[aID]);
    // - for one TClass, you should better use TSQLRest.MultiFieldValues()
    // - will call the List virtual method internaly
    function ListFmt(const Tables: array of TSQLRecordClass; const SQLSelect: RawUTF8;
      SQLWhereFormat: PUTF8Char; const Args, Bounds: array of const): TSQLTableJSON; overload;
    /// dedicated method used to retrieve matching IDs using a fast R-Tree index
    // - a TSQLRecordRTree is associated to a TSQLRecord with a specified BLOB
    // field, and will call TSQLRecordRTree BlobToCoord and ContainedIn virtual
    // class methods to execute an optimized SQL query
    // - will return all matching DataTable IDs in DataID[]
    // - will generate e.g. the following statement
    // $ SELECT MapData.ID From MapData, MapBox WHERE MapData.ID=MapBox.ID
................................................................................
  PAGINGPARAMETERS_YAHOO: TSQLRestServerURIPagingParameters = (
    Sort: 'SORT=';
    Dir: 'DIR=';
    StartIndex: 'STARTINDEX=';
    Results: 'RESULTS=';
    Select: 'SELECT=';
    Where: 'WHERE=';
    SendTotalRowsCountFmt: nil);

  /// options to specify no index createon for TSQLRestServer.CreateMissingTables
  // and TSQLRecord.InitializeTable methods
  INITIALIZETABLE_NOINDEX: TSQLInitializeTableOptions =
    [itoNoIndex4ID..itoNoIndex4RecordReference];


................................................................................
  SetString(fPrivateCopy,PAnsiChar(pointer(aJSON)),len);
  CreateWithColumnTypes(ColumnTypes,aSQL,pointer(fPrivateCopy),len);
end;


{ TINIWriter }

const
  sWriteObject1: PWinAnsiChar = #13'[%]'#13;
  sWriteObject2: PWinAnsiChar = '%%=%'#13;
  
procedure TINIWriter.WriteObject(Value: TObject; const SubCompName: RawUTF8='';
  WithSection: boolean=true);
var P: PPropInfo;
    i, V: integer;
    VT: shortstring; // for str()
    Obj: TObject;
    WS: WideString;
................................................................................
    VV: Variant;
    {$endif}
begin
  if Value<>nil then begin
    if WithSection then
      // new TObject.ClassName is UnicodeString (Delphi 20009) -> inline code with
      // vmtClassName = UTF-8 encoded text stored in a shortstring = -44
      Add(sWriteObject1,[PShortString(PPointer(PPtrInt(Value)^+vmtClassName)^)^]);
    for i := 1 to InternalClassPropInfo(PPointer(Value)^,P) do begin
      case P^.PropType^.Kind of
        tkInt64{$ifdef FPC}, tkQWord{$endif}:
          Add(sWriteObject2,[SubCompName,P^.Name,P^.GetInt64Prop(Value)]);
        {$ifdef FPC}tkBool,{$endif}
        tkEnumeration, tkInteger, tkSet: begin
          V := P^.GetOrdProp(Value);
          if V<>P^.Default then
            Add(sWriteObject2,[SubCompName,P^.Name,V]);
        end;
        {$ifdef FPC}tkAString,{$endif} tkLString:
          Add(sWriteObject2,[SubCompName,P^.Name,P^.GetLongStrValue(Value)]);
        tkFloat: begin
          VT[0] := AnsiChar(ExtendedToString(VT,P^.GetFloatProp(Value),DOUBLE_PRECISION));
          Add(sWriteObject2,[SubCompName,P^.Name,VT]);
        end;
        tkWString: begin
          P^.GetWideStrProp(Value,WS);
          Add(sWriteObject2,[SubCompName,P^.Name,WS]);
        end;
        {$ifdef UNICODE}
        tkUString: // write converted to UTF-8
          Add(sWriteObject2,[SubCompName,P^.Name,P^.GetUnicodeStrProp(Value)]);
        {$endif}
        tkDynArray: begin
          Add(sWriteObject2,[SubCompName,P^.Name]);
          AddDynArrayJSON(P^.GetDynArray(Value));
          Add(#13);
        end;
        {$ifdef PUBLISHRECORD}
        tkRecord{$ifdef FPC},tkObject{$endif}:
          Add(sWriteObject2,[SubCompName,P^.Name,BinToBase64WithMagic(
            RecordSave(P^.GetFieldAddr(Value)^,P^.PropType^))]);
        {$endif}
        tkClass: begin
          Obj := P^.GetObjProp(Value); 
          if (Obj<>nil) and Obj.InheritsFrom(TPersistent) then
             WriteObject(Obj,SubCompName+RawUTF8(P^.Name)+'.',false);
        end;
        {$ifndef NOVARIANTS}
        tkVariant: begin // stored as JSON, e.g. '1.234' or '"text"'
          P^.GetVariantProp(Value,VV);
          Add(sWriteObject2,[SubCompName,P^.Name,VariantSaveJSON(VV)]);
        end;
        {$endif}
      end; // tkString (shortstring) is not handled
      P := P^.Next;
    end;
  end;
end;
................................................................................
constructor TSQLRecord.Create(aClient: TSQLRest; const aSQLWhere: RawUTF8);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(aSQLWhere,self);
end;

constructor TSQLRecord.Create(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),self);
end;

constructor TSQLRecord.Create(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
  const ParamsSQLWhere, BoundsSQLWhere: array of const);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),self);
end;

................................................................................
  if T=nil then
    exit;
  T.OwnerMustFree := true;
  FillPrepare(T,aCheckTableName);
  result := true;
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest; FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''): boolean;
begin
  if (FormatSQLWhere=nil) or (high(BoundsSQLWhere)<0) then
    result := false else
    result := FillPrepare(aClient,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),
      aCustomFieldsCSV);
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest;
  FormatSQLWhere: PUTF8Char; const ParamsSQLWhere, BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8): boolean;
begin
  if (FormatSQLWhere=nil) or ((high(ParamsSQLWhere)<0)and(high(BoundsSQLWhere)<0)) then
    result := false else
    result := FillPrepare(aClient,
      FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),aCustomFieldsCSV);
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest; const aIDs: array of Int64;
  const aCustomFieldsCSV: RawUTF8=''): boolean;
................................................................................
  if aTable=nil then
    exit;
  aTable.OwnerMustFree := true;
  FillPrepare(aTable);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
  FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8='');
begin
  CreateAndFillPrepare(aClient,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),
    aCustomFieldsCSV);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
  FormatSQLWhere: PUTF8Char; const ParamsSQLWhere,
  BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8);
begin
  CreateAndFillPrepare(aClient,
    FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),aCustomFieldsCSV);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
................................................................................
begin
  Create;
  props := aClient.Model.Props[PSQLRecordClass(Self)^];
  if props.props.JoinedFields=nil then
    raise EORMException.CreateUTF8('No nested TSQLRecord to JOIN in %',[self]);
  SQL := props.SQL.SelectAllJoined;
  if aFormatSQLJoin<>'' then
    SQL := SQL+FormatUTF8(pointer(SQLFromWhere(aFormatSQLJoin)),
      aParamsSQLJoin,aBoundsSQLJoin);
  T := aClient.ExecuteList(props.props.JoinedFieldsTable,SQL);
  if T=nil then
    exit;
  fFill := TSQLRecordFill.Create;
  fFill.fJoinedFields := True;
  fFill.fTable := T;
................................................................................
constructor TSQLRecord.CreateJoined(aClient: TSQLRest; aID: TID);
begin
  CreateAndFillPrepareJoined(aClient,'%.RowID=?',[RecordProps.SQLTableName],[aID]);
  FillOne;
end;

constructor TSQLRecord.CreateAndFillPrepareMany(aClient: TSQLRest;
  aFormatSQLJoin: PUTF8Char; const aParamsSQLJoin, aBoundsSQLJoin: array of const);
begin
  Create;
  if Length(RecordProps.ManyFields)=0 then
    raise EModelException.CreateUTF8(
      '%.CreateAndFillPrepareMany() with no many-to-many fields',[self]);
  if not FillPrepareMany(aClient,aFormatSQLJoin,aParamsSQLJoin,aBoundsSQLJoin) then
    raise EModelException.CreateUTF8(
      '%.CreateAndFillPrepareMany(): FillPrepareMany() failure',[self]);
end;

function TSQLRecord.FillPrepareMany(aClient: TSQLRest;
  aFormatSQLJoin: PUTF8Char; const aParamsSQLJoin, aBoundsSQLJoin: array of const): boolean;
var aSQLFields, aSQLFrom, aSQLWhere, aSQL: RawUTF8;
    aField: string[3];
    aMany: RawUTF8;
    f, n, i, SQLFieldsCount: Integer;
    Props: TSQLRecordProperties;
    T: TSQLTable;
    SQLFields: array of record
      SQL: string[3];
      Prop: TSQLPropInfo;
      Instance: TSQLRecord;
    end;
    M: TSQLRecordMany;
    D: TSQLRecord;
    P: PUTF8Char;
    Objects: array of TSQLRecord;
    ObjectsClass: array of TSQLRecordClass;

  function AddField(aProp: TSQLPropInfo): Boolean;
  begin
    if SQLFieldsCount>=MAX_SQLFIELDS then
      result := false else
................................................................................
    end;
  if Props.fSQLFillPrepareMany<>'' then
    aSQL := Props.fSQLFillPrepareMany else begin
    aSQL := FormatUTF8('select % from % where %',[aSQLFields,aSQLFrom,aSQLWhere]);
    Props.fSQLFillPrepareMany := aSQL;
  end;
  // process aFormatSQLJoin,aParamsSQLJoin and aBoundsSQLJoin parameters
  if aFormatSQLJoin<>nil then begin
    aSQLWhere := '';

    repeat
      P := aFormatSQLJoin;

      while not (ord(P^) in IsIdentifier) do begin
        case P^ of
        '"':  repeat inc(P) until P^ in [#0,'"'];
        '''': repeat inc(P) until P^ in [#0,''''];
        end;
        if P^=#0 then break;
        inc(P);
      end;
      if P<>aFormatSQLJoin then begin // append ' ',')'..
        SetString(aSQLFrom,aFormatSQLJoin,P-aFormatSQLJoin);
        aSQLWhere := aSQLWhere+aSQLFrom;
        aFormatSQLJoin := P;

      end;
      if P^=#0 then break;
      aSQLWhere := aSQLWhere+ProcessField(aFormatSQLJoin);
    until aFormatSQLJoin^=#0;

    aSQL := aSQL+' and ('+FormatUTF8(pointer(aSQLWhere),aParamsSQLJoin,aBoundsSQLJoin)+')';
  end;
  // execute SQL statement and retrieve data
  T := aClient.ExecuteList(ObjectsClass,aSQL);
  if (T=nil) or (T.fResults=nil) then
    exit;
  fFill.fTable := T;
  T.OwnerMustFree := true;
................................................................................
begin
  {$ifdef WITHLOG}
  if Level in fLogFamily.Level then
    fLogFamily.SynLog.Log(Level,Text,self);
  {$endif}
end;

procedure TSQLRest.InternalLog(Format: PWinAnsiChar;
  const Args: array of const; Level: TSynLogInfo);
begin
  {$ifdef WITHLOG}
  if Level in fLogFamily.Level then
    fLogFamily.SynLog.Log(Level,Format,Args,self);
  {$endif}
end;
................................................................................
begin
  if MultiFieldValue(Table,[FieldName],Res,WhereClause) then
    result := Res[0] else
    result := '';
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
  FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const): RawUTF8;
begin
  result := OneFieldValue(Table,FieldName,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass;
  const FieldName: RawUTF8; WhereClauseFmt: PUTF8Char;
  const Args, Bounds: array of const): RawUTF8;
begin
  result := OneFieldValue(Table,FieldName,FormatUTF8(WhereClauseFmt,Args,Bounds));
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass;
  const FieldName: RawUTF8; WhereID: TID): RawUTF8;
................................................................................

function TSQLRest.MemberExists(Table: TSQLRecordClass; ID: TID): boolean;
begin
  result := OneFieldValue(Table,'RowID',ID)<>'';
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
  WhereClauseFmt: PUTF8Char; const Args, Bounds: array of const;
  out Data: Int64): boolean;
var Res: array[0..0] of RawUTF8;
    err: integer;
begin
  result := false;
  if MultiFieldValue(Table,[FieldName],Res,FormatUTF8(WhereClauseFmt,Args,Bounds)) then
    if Res[0]<>'' then begin
................................................................................
  sql := SQLComputeForSelect(Table,FieldNames,WhereClause);
  if sql='' then
    result := nil else
    result := ExecuteList([Table],sql);
end;

function TSQLRest.MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
  WhereClauseFormat: PUTF8Char; const BoundsSQLWhere: array of const): TSQLTableJSON;
begin
  result := MultiFieldValues(Table,FieldNames,FormatUTF8(WhereClauseFormat,[],BoundsSQLWhere));
end;

function TSQLRest.MultiFieldValues(Table: TSQLRecordClass;
  const FieldNames: RawUTF8; WhereClauseFormat: PUTF8Char;
  const Args, Bounds: array of const): TSQLTableJSON;
begin
  result := MultiFieldValues(Table,FieldNames,FormatUTF8(WhereClauseFormat,Args,Bounds));
end;

function TSQLRest.MultiFieldValue(Table: TSQLRecordClass;
  const FieldName: array of RawUTF8; var FieldValue: array of RawUTF8;
................................................................................
        result := false;
      end;
    finally
      T.Free;
    end;
end;

function TSQLRest.RetrieveList(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): TObjectList;
var T: TSQLTable;
begin
  result := nil;
  if (self=nil) or (Table=nil) then
    exit;
  T := MultiFieldValues(Table,aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    result := TObjectList.Create;
    T.ToObjectList(result,Table);
  finally
    T.Free;
  end;
end;

function TSQLRest.RetrieveListJSON(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): RawJSON;
var sql: RawUTF8;
begin
  sql := SQLComputeForSelect(Table,aCustomFieldsCSV,
    FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
  if sql='' then
    result := '' else
    result := EngineList(sql);
end;

function TSQLRest.RetrieveListObjArray(var ObjArray; Table: TSQLRecordClass;
  FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8): boolean;
var T: TSQLTable;
begin
  result := false;
  if (self=nil) or (Table=nil) then
    exit;
  T := MultiFieldValues(Table,aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    T.Free;
  end;
end;

{$ifndef NOVARIANTS}
function TSQLRest.RetrieveDocVariantArray(Table: TSQLRecordClass;
  const ObjectName: RawUTF8;
  FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
  const CustomFieldsCSV: RawUTF8; FirstRecordID,LastRecordID: PID): variant;
var T: TSQLTable;
    res: variant;
begin
  TVarData(res).VType := varNull;
  if (self<>nil) and (Table<>nil) then begin
    T := MultiFieldValues(Table,CustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    result := _ObjFast([ObjectName,res]) else
    result := res;
end;

function TSQLRest.RetrieveDocVariantArray(Table: TSQLRecordClass;
  const ObjectName, CustomFieldsCSV: RawUTF8; FirstRecordID,LastRecordID: PID): variant;
begin
  result := RetrieveDocVariantArray(Table,ObjectName,nil,[],CustomFieldsCSV,
    FirstRecordID,LastRecordID);
end;

function TSQLRest.RetrieveDocVariant(Table: TSQLRecordClass;
  FormatSQLWhere: PUTF8Char; const BoundsSQLWhere: array of const;
  const CustomFieldsCSV: RawUTF8): variant;
var T: TSQLTable;
    bits: TSQLFieldBits;
    Rec: TSQLRecord;
    len: integer;
begin
  SetVariantNull(result);
  if (self<>nil) and (Table<>nil) then begin
    with Table.RecordProps do
    if Cache.IsCached(Table) and (length(BoundsSQLWhere)=1) and
       (BoundsSQLWhere[0].VType=vtInteger) and
       FieldIndexsFromCSV(CustomFieldsCSV,bits) then
      if IsZero(bits) then
        exit else
      if bits-SimpleFieldsBits[soSelect]=[] then begin
        len := StrLen(FormatSQLWhere);
        if IdemPropNameU('RowID=?',FormatSQLWhere,len) or
           IdemPropNameU('ID=?',FormatSQLWhere,len) then begin
          Rec := Table.Create(self,BoundsSQLWhere[0].VInteger);
          try
            result := Rec.GetAsDocVariant(True,bits);
          finally
            Rec.Free;
          end;
          exit;
        end;
      end;
    T := MultiFieldValues(Table,CustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
    if T<>nil then
    try
      T.ToDocVariant(1,result)
    finally
      T.Free;
    end;
  end;
end;
................................................................................
    fCache.Notify(Tableindex,aID,Resp,soSelect);
  end;
  // fill Value from JSON if was correctly retrieved
  Value.FillFrom(Resp);
  result := true;
end;

function TSQLRest.Retrieve(WhereClauseFmt: PUTF8Char; const Args,Bounds: array of const;
  Value: TSQLRecord): boolean;
var where: RawUTF8;
begin
  where := FormatUTF8(WhereClauseFmt,Args,Bounds);
  result := Retrieve(where,Value);
end;

................................................................................
var IDs: TIDDynArray;
begin
  if InternalDeleteNotifyAndGetIDs(Table,SQLWhere,IDs) then
    result := EngineDeleteWhere(Model.GetTableIndexExisting(Table),SQLWhere,IDs) else
    result := false;
end;

function TSQLRest.Delete(Table: TSQLRecordClass; FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const): boolean;
begin
  result := Delete(Table,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
end;

function TSQLRest.Update(Value: TSQLRecord; const CustomFields: TSQLFieldBits): boolean;
var JSONValues: RawUTF8;
................................................................................
end;

function TSQLRest.Execute(const aSQL: RawUTF8): boolean;
begin
  result := EngineExecute(aSQL);
end;

function TSQLRest.ExecuteFmt(SQLFormat: PUTF8Char;
  const Args: array of const): boolean;
begin
  result := EngineExecute(FormatUTF8(SQLFormat,Args));
end;

function TSQLRest.ExecuteFmt(SQLFormat: PUTF8Char;
  const Args, Bounds: array of const): boolean;
begin
  result := EngineExecute(FormatUTF8(SQLFormat,Args,Bounds));
end;

function TSQLRest.MainFieldValue(Table: TSQLRecordClass; ID: TID;
   ReturnFirstIfNoUnique: boolean=false): RawUTF8;
................................................................................
  service := fServices.Info(TypeInfo(T));
  if (service=nil) or not service.Get(result) then
    result := Default(T);
end;

function TSQLRest.RetrieveList<T>(const aCustomFieldsCSV: RawUTF8): TObjectList<T>;
begin
  result := RetrieveList<T>(nil,[],aCustomFieldsCSV);
end;

function TSQLRest.RetrieveList<T>(FormatSQLWhere: PUTF8Char;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): TObjectList<T>;
var Table: TSQLTable;
begin
  result := nil;
  if self=nil then
    exit;
  Table := MultiFieldValues(TSQLRecordClass(T),aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
begin
  result := true;
  for i := 0 to high(FieldNames) do
    if not CreateSQLMultiIndex(Table,[FieldNames[i]],Unique) then
     result := false;
end;

function TSQLRestServer.CreateBackgroundThread(Format: PUTF8Char; const Args: array of const): TSynBackgroundThreadMethod;
begin
  result := TSynBackgroundThreadMethod.Create(nil,FormatUTF8(Format,Args));
  result.OnBeforeExecute := BeginCurrentThread;
  result.OnAfterExecute := EndCurrentThread;
end;

function TSQLRestServer.GetAuthenticationSchemesCount: integer;
................................................................................
             not ContainsUTF8(pointer(SQLWhere),'ORDER BY') then begin
            if SameTextU(SQLDir,'DESC') then
              SQLSort := SQLSort+' DESC'; // allow DESC, default is ASC
            SQLWhere := SQLWhere+' ORDER BY '+SQLSort;
          end;
          SQLWhere := trim(SQLWhere);
          if (SQLResults<>0) and not ContainsUTF8(pointer(SQLWhere),'LIMIT ') then begin
            if (Server.URIPagingParameters.SendTotalRowsCountFmt<>nil) then begin
              if SQLWhere=SQLWhereCount then begin
                i := PosEx('ORDER BY ',UpperCase(SQLWhereCount));
                if i>0 then // if ORDER BY already in the SQLWhere clause
                  SetLength(SQLWhereCount,i-1);
              end;
              ResultList := Server.ExecuteList([Table],
                Server.Model.TableProps[TableIndex].SQLFromSelectWhere('Count(*)',SQLWhereCount));
................................................................................
          end;
        end;
        SQL := Server.Model.TableProps[TableIndex].
          SQLFromSelectWhere(SQLSelect,trim(SQLWhere));
        Call.OutBody := Server.InternalListRawUTF8(TableIndex,SQL);
        if Call.OutBody<>'' then begin // got JSON list '[{...}]' ?
          Call.OutStatus := HTML_SUCCESS;  // 200 OK
          if Server.URIPagingParameters.SendTotalRowsCountFmt<>nil then
            if Server.NoAJAXJSON then begin
              P := pointer(Call.OutBody);
              L := length(Call.OutBody);
              P := NotExpandedBufferRowCountPos(P,P+L);
              j := 0;
              if P<>nil then
                j := P-pointer(Call.OutBody)-11 else
................................................................................
procedure TSQLRestServerURIContext.Success(Status: integer);
begin
  if (Status in [HTML_SUCCESS,HTML_CREATED]) or (Status=HTML_NOTMODIFIED) then
    Call.OutStatus := Status else
    Error('',Status);
end;

procedure TSQLRestServerURIContext.Error(Format: PUTF8Char;
  const Args: array of const; Status: integer);
begin
  Error(FormatUTF8(Format,Args),Status);
end;

procedure TSQLRestServerURIContext.Error(E: Exception;
  Format: PUTF8Char; const Args: array of const; Status: integer);
var msg,exc: RawUTF8;
begin
  msg := FormatUTF8(Format,Args);
  if E=nil then
    Error(msg,Status) else begin
    exc := ObjectToJSONDebug(E);
    if msg='' then
................................................................................

procedure TSQLRestClient.RollBack(SessionID: cardinal);
begin
  inherited;
end;

function TSQLRestClient.ListFmt(const Tables: array of TSQLRecordClass; const SQLSelect: RawUTF8;
  SQLWhereFormat: PUTF8Char; const Args: array of const): TSQLTableJSON;
begin
  result := List(Tables,SQLSelect,FormatUTF8(SQLWhereFormat,Args));
end;

function TSQLRestClient.ListFmt(const Tables: array of TSQLRecordClass;
  const SQLSelect: RawUTF8; SQLWhereFormat: PUTF8Char;
  const Args, Bounds: array of const): TSQLTableJSON;
begin
  result := List(Tables,SQLSelect,FormatUTF8(SQLWhereFormat,Args,Bounds));
end;

function TSQLRestClient.RTreeMatch(DataTable: TSQLRecordClass;
  const DataTableBlobFieldName: RawUTF8; RTreeTable: TSQLRecordRTreeClass;
................................................................................

function ObjectToVariantDebug(Value: TObject): variant;
begin
  result := _JsonFast(ObjectToJSONDebug(Value));
end;

function ObjectToVariantDebug(Value: TObject;
  ContextFormat: PUTF8Char; const ContextArgs: array of const;
  const ContextName: RawUTF8): variant;
begin
  result := _JsonFast(ObjectToJSONDebug(Value));
  if ContextFormat<>'' then
    if ContextFormat[0]='{' then
      _ObjAddProps([ContextName,_JsonFastFmt(ContextFormat,[],ContextArgs)],result) else
      _ObjAddProps([ContextName,FormatUTF8(ContextFormat,ContextArgs)],result);
end;

function UrlEncode(const NameValuePairs: array of const): RawUTF8;
// (['select','*','where','ID=12','offset',23,'object',aObject]);
var A, n: PtrInt;
................................................................................
    if PosEx(RawUTF8(':('),aDestWhereSQL,1)>0 then
      // statement is globaly inlined -> cache prepared statement
      SQL := 'SELECT % FROM %,% WHERE %.Source=:(%): AND %.Dest=%.RowID AND %' else
      // statement is not globaly inlined -> no caching of prepared statement
      SQL := 'SELECT % FROM %,% WHERE %.Source=% AND %.Dest=%.RowID AND %';
  result := aClient.ExecuteList([PSQLRecordClass(Self)^,
     TSQLRecordClass(SelfProps.Props.fRecordManyDestProp.ObjectClass)],
    FormatUTF8(pointer(SQL),
      [Select, DestProps.Props.SQLTableName,SelfProps.Props.SQLTableName,
       SelfProps.Props.SQLTableName,aSourceID, SelfProps.Props.SQLTableName,
       DestProps.Props.SQLTableName, aDestWhereSQL]));
end;

function TSQLRecordMany.DestGet(aClient: TSQLRest;
  out DestIDs: TIDDynArray): boolean;
................................................................................
     (aClient=nil) then
    Result := '' else begin
    if aAndWhereSQL<>'' then
      if PosEx(RawUTF8(':('),aAndWhereSQL,1)>0 then
        Result := '%:(%): AND %' else // inlined parameters
        Result := '%% AND %' else // no inlined parameters -> not cached
      Result := '%:(%):'; // no additional where clause -> inline ID
    Result := FormatUTF8(pointer(result),[FieldName[isDest],aID,aAndWhereSQL]);
  end;
end;

function TSQLRecordMany.SourceGet(aClient: TSQLRest; aDestID: TID;
  out SourceIDs: TIDDynArray): boolean;
var Where: RawUTF8;
begin
................................................................................
  end;

  EInterfaceStub = class(EInterfaceFactoryException)
  public
    constructor Create(Sender: TInterfaceStub; const Method: TServiceMethod;
      const Error: RawUTF8); overload;
    constructor Create(Sender: TInterfaceStub; const Method: TServiceMethod;
      Format: PUTF8Char; const Args: array of const); overload;
  end;


constructor TInterfacedObjectFake.Create(aFactory: TInterfaceFactory;
  aInvoke: TOnFakeInstanceInvoke; aNotifyDestroy: TOnFakeInstanceDestroy);
begin
  inherited Create(aFactory,aInvoke,aNotifyDestroy);
................................................................................
function TInterfacedObjectFake.FakeCall(var aCall: TFakeCallStack): Int64;
{$ifdef CPUARM}
begin
  raise EInterfaceFactoryException.Create('You encountered an ALF! ARM not yet supported');
end;
{$else}
var method: ^TServiceMethod;
procedure RaiseError(Format: PUTF8Char; const Args: array of const);
begin
  raise EInterfaceFactoryException.CreateUTF8('Invalid %.FakeCall() for %.%: %',
    [self,fFactory.fInterfaceTypeInfo^.Name,method^.URI,FormatUTF8(Format,Args)]);
end;
var resultType: TServiceMethodValueType; // type of value stored into result
procedure InternalProcess;
var Params: TJSONSerializer;
................................................................................
    PP: ^PPTypeInfo absolute P;
    Ancestor: PTypeInfo;
    Kind: TMethodKind;
    f: TParamFlags;
    m,a: integer;
    n: cardinal;
    aURI: RawUTF8;
procedure RaiseError(Format: PUTF8Char; const Args: array of const);
begin
  raise EInterfaceFactoryException.CreateUTF8(
    '%.AddMethodsFromTypeInfo: %.% %',
    [self,fInterfaceTypeInfo^.Name,aURI,FormatUTF8(Format,Args)]);
end;
begin
  // handle interface inheritance via recursive calls
................................................................................
  const Method: TServiceMethod; const Error: RawUTF8);
begin
  inherited CreateUTF8('Error in % for %.% - %',
    [Sender,Sender.fInterface.fInterfaceTypeInfo^.Name,Method.URI,Error]);
end;

constructor EInterfaceStub.Create(Sender: TInterfaceStub;
  const Method: TServiceMethod; Format: PUTF8Char; const Args: array of const);
begin
  Create(Sender,Method,FormatUTF8(Format,Args));
end;

function TInterfaceStubLog.Results: RawUTF8;
begin
  if CustomResults='' then
................................................................................
begin
  fSender := aSender;
  fMethod := aMethod;
  fParams := aParams;
  fEventParams := aEventParams;
end;

procedure TOnInterfaceStubExecuteParamsAbstract.Error(Format: PUTF8Char; const Args: array of const);

begin
  Error(FormatUTF8(Format,Args));
end;

procedure TOnInterfaceStubExecuteParamsAbstract.Error(const aErrorMessage: RawUTF8);
begin
  fFailed := true;
................................................................................
  with TInterfacedObjectFake.Create(fInterface,Invoke,InstanceDestroyed) do begin
    pointer(aStubbedInterface) := @fVTable;
    _AddRef;
  end;
end;

function TInterfaceStub.InternalCheck(aValid,aExpectationFailed: boolean;
  aErrorMsgFmt: PUTF8Char; const aErrorMsgArgs: array of const): boolean;
begin
  result := aValid;
  if aExpectationFailed and not aValid then
    raise EInterfaceStub.CreateUTF8('%.InternalCheck(%) failed: %',
      [self,fInterface.fInterfaceTypeInfo^.Name,FormatUTF8(aErrorMsgFmt,aErrorMsgArgs)]);
end;

................................................................................
constructor TInterfaceMock.Create(const aGUID: TGUID; aTestCase: TSynTestCase);
begin
  inherited Create(aGUID);
  fTestCase := aTestCase;
end;

function TInterfaceMock.InternalCheck(aValid,aExpectationFailed: boolean;
      aErrorMsgFmt: PUTF8Char; const aErrorMsgArgs: array of const): boolean; 
begin
  if fTestCase=nil then
    result := inherited InternalCheck(aValid,aExpectationFailed,aErrorMsgFmt,aErrorMsgArgs) else begin
    if aValid xor (imoMockFailsWillPassTestCase in Options) then
      fTestCase.Check(true) else
      fTestCase.Check(false,UTF8ToString(FormatUTF8(aErrorMsgFmt,aErrorMsgArgs)));
    result := true; // do not raise any exception at this stage for TInterfaceMock

    - BREAKING CHANGE with newly added reSQLSelectWithoutTable security policy
      flags in TSQLAccessRight.AllowRemoteExecute - older applications which
      expected any SELECT statement to be executed on the server may break:
      you need to explicitely set this flag for the User's TSQLAuthGroup - note
      that SELECT with a simple table name in its FROM clause will now be
      checked againsts TSQLAccessRight.GET[] access rights
    - BREAKING CHANGE: added aSentData parameter to TNotifySQLEvent/OnUpdateEvent
    - BREAKING CHANGE: SQL "where" clause defined as PUTF8Char constant text
      have been changed into RawUTF8, to let the compiler fully handle Unicode
    - remove some unused TPropInfo methods, which were duplicates of the
      TSQLPropInfo cleaner class hierarchy: SetValue/GetValue/GetValueVar
      GetBinary/SetBinary GetVariant/SetVariant NormalizeValue/SameValue GetHash
      IsSimpleField AppendName GetCaption GetSQLFromFieldValue SetFieldAddr
    - following the Liskov substitution principle, Execute/ExecuteFmt and
      protected EngineExecute() are defined for TSQLRest, replacing ExecuteAll()
    - TSQLRestServerRemoteDB will now redirect into any TSQLRest instance
................................................................................

/// will serialize any TObject into a TDocVariant document
// - just a wrapper around _JsonFast(ObjectToJSONDebug()) with an optional
// "Context":"..." text message
// - if the supplied context format matches '{....}' then it will be added
// as a corresponding TDocVariant JSON object
function ObjectToVariantDebug(Value: TObject;
  const ContextFormat: RawUTF8; const ContextArgs: array of const;
  const ContextName: RawUTF8='context'): variant; overload;

/// will serialize any TObject into a TDocVariant document
// - just a wrapper around _JsonFast(ObjectToJSONDebug()) 
function ObjectToVariantDebug(Value: TObject): variant; overload;

/// encode supplied parameters to be compatible with URI encoding
................................................................................
    // supplied error text
    // - if no ErrorMessage is specified, will return a default text
    // corresponding to the Status code
    procedure Error(const ErrorMessage: RawUTF8='';
      Status: integer=HTML_BADREQUEST); overload;
    /// use this method to send back an error to the caller
    // - implementation is just a wrapper over Error(FormatUTF8(Format,Args))
    procedure Error(const Format: RawUTF8; const Args: array of const;
      Status: integer=HTML_BADREQUEST); overload;
    /// use this method to send back an error to the caller
    // - will serialize the supplied exception, with an optional error message
    procedure Error(E: Exception; const Format: RawUTF8; const Args: array of const;
      Status: integer=HTML_BADREQUEST); overload;
    /// at Client Side, compute URI and BODY according to the routing scheme
    // - abstract implementation which is to be overridden
    // - as input, method should be the method name to be executed,
    // params should contain the incoming parameters as JSON CSV (without []),
    // and clientDriven ID should contain the optional Client ID value 
    // - at output, should update the HTTP uri corresponding to the proper
................................................................................
      identified as '?' in the FormatSQLWhere statement, which is expected to
      follow the order of values supplied in BoundsSQLWhere open array - use
      DateToSQL/DateTimeToSQL for TDateTime, or directly any integer / double /
      currency / RawUTF8 values to be bound to the request as parameters
    - note that this method prototype changed with revision 1.17 of the
      framework: array of const used to be ParamsSQLWhere and '%' in the
      FormatSQLWhere statement, whereas it now expects bound parameters as '?' }
    constructor Create(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const); overload;
    {/ this constructor initializes the object as above, and fills its content
      from a client or server connection, using a specified WHERE clause
      with parameters
      - the FormatSQLWhere clause will replace all '%' chars with the supplied
      ParamsSQLWhere[] values, and all '?' chars with BoundsSQLWhere[] values,
      as :(...): inlined parameters - you should either call:
................................................................................
      or (letting the inlined parameters being computed by FormatUTF8)
      !  Rec := TSQLMyRecord.Create(aClient,'Count=?',[],[aCount]);
      or even better, using the other Create overloaded constructor:
      !  Rec := TSQLMyRecord.Create(aClient,'Count=?',[aCount]);
      - using '?' and BoundsSQLWhere[] is perhaps more readable in your code, and
      will in all case create a request with :(..): inline parameters, with
      automatic RawUTF8 quoting if necessary }
    constructor Create(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const ParamsSQLWhere, BoundsSQLWhere: array of const); overload;

    {/ this constructor initializes the object as above, and prepares itself to
      loop through a statement using a specified WHERE clause
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the WHERE clause, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
................................................................................
        you may need  to access only one or several fields, and will save remote
        bandwidth by specifying the needed fields
      - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs
      - note that you should not use this aCustomFieldsCSV optional parameter if
        you want to Update the retrieved record content later, since any
        missing fields will be left with previous values - but BatchUpdate() can be
        safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    constructor CreateAndFillPrepare(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''); overload;
    {/ this constructor initializes the object as above, and prepares itself to
      loop through a statement using a specified WHERE clause
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the WHERE clause, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
      - you should then loop for all rows using 'while Rec.FillOne do ...'
................................................................................
        you may need  to access only one or several fields, and will save remote
        bandwidth by specifying the needed fields
      - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs
      - note that you should not use this aCustomFieldsCSV optional parameter if
        you want to Update the retrieved record content later, since any
        missing fields will be left with previous values - but BatchUpdate() can be
        safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    constructor CreateAndFillPrepare(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const ParamsSQLWhere, BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''); overload;
    {/ this constructor initializes the object as above, and prepares itself to
      loop through a given list of IDs
      - this method creates a TSQLTableJSON, retrieves all records corresponding
        to the specified IDs, then call FillPrepare - previous Create(aClient)
        methods retrieve only one record, this one more multiple rows
................................................................................
        $  p.Owner='mark' and c.Name='for boy' and (s.Name='small' or s.Name='medium')
      - you SHALL call explicitely the FillClose method before using any
        methods of nested TSQLRecordMany instances which may override the Dest
        instance content (e.g. ManySelect) to avoid any GPF
      - the aFormatSQLJoin clause will replace all '%' chars with the supplied
        aParamsSQLJoin[] supplied values, and bind all '?' chars as bound
        parameters with aBoundsSQLJoin[] values }
    constructor CreateAndFillPrepareMany(aClient: TSQLRest; const aFormatSQLJoin: RawUTF8;
      const aParamsSQLJoin, aBoundsSQLJoin: array of const);

    {/ this method create a clone of the current record, with same ID and properties
      - copy all COPIABLE_FIELDS, i.e. all fields excluding tftMany (because
        those fields don't contain any data, but a TSQLRecordMany instance
        which allow to access to the pivot table data)
      - you can override this method to allow custom copy of the object,
................................................................................
       you may need  to access only one or several fields, and will save remote
       bandwidth by specifying the needed fields
     - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs 
     - note that you should not use this aCustomFieldsCSV optional parameter if
       you want to Update the retrieved record content later, since any
       missing fields will be left with previous values - but BatchUpdate() can be
       safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    function FillPrepare(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''): boolean; overload;
    {/ prepare to get values using a specified WHERE clause with '%' and '?' parameters
     - returns true in case of success, false in case of an error during SQL request
     - then call FillRow(1..Table.RowCount) to get any row value
     - or you can also loop through all rows with
     ! while Rec.FillOne do
     !   dosomethingwith(Rec);
................................................................................
       you may need  to access only one or several fields, and will save remote
       bandwidth by specifying the needed fields
     - if aCustomFieldsCSV='*', it will retrieve all fields, including BLOBs 
     - note that you should not use this aCustomFieldsCSV optional parameter if
       you want to Update the retrieved record content later, since any
       missing fields will be left with previous values - but BatchUpdate() can be
       safely used after FillPrepare (will set only ID, TModTime and mapped fields) }
    function FillPrepare(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
      const ParamsSQLWhere, BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): boolean; overload;
    {/ prepare to get values from a list of IDs
     - returns true in case of success, false in case of an error during SQL request
     - then call FillRow(1..Table.RowCount) to get any row value
     - or you can also loop through all rows with
     ! while Rec.FillOne do
................................................................................
     - the FormatSQLWhere clause will replace all '%' chars with the supplied
       ParamsSQLWhere[] supplied values, and bind all '?' chars as parameters
       with BoundsSQLWhere[] values
     - you SHALL call explicitely the FillClose method before using any
       methods of nested TSQLRecordMany instances which may override the Dest
       instance content (e.g. ManySelect) to avoid any GPF
     - is used by TSQLRecord.CreateAndFillPrepareMany constructor }
    function FillPrepareMany(aClient: TSQLRest; const aFormatSQLJoin: RawUTF8;
      const aParamsSQLJoin, aBoundsSQLJoin: array of const): boolean;
    {/ fill all published properties of an object from a TSQLTable prepared row
      - FillPrepare() must have been called before
      - if Dest is nil, this object values are filled
      - if Dest is not nil, this object values will be filled, but it won't
        work with TSQLRecordMany properties (i.e. after FillPrepareMany call)
      - ID field is updated if first Field Name is 'ID'
................................................................................
  public
    /// constructor of one parameters marshalling instance
    constructor Create(aSender: TInterfaceStub; aMethod: PServiceMethod;
      const aParams,aEventParams: RawUTF8); virtual;
    /// call this method if the callback implementation failed
    procedure Error(const aErrorMessage: RawUTF8); overload;
    /// call this method if the callback implementation failed
    procedure Error(const Format: RawUTF8; const Args: array of const); overload;
    /// the stubbing / mocking generator
    property Sender: TInterfaceStub read fSender;
    /// the mocking generator associated test case
    // - will raise an exception if the associated Sender generator is not
    // a TInterfaceMock
    property TestCase: TSynTestCase read GetSenderAsMockTestCase;
    /// pointer to the method which is to be executed
................................................................................
    fLogs: TInterfaceStubLogDynArray;
    fLog: TDynArray;
    fLogCount: integer;
    fInterfaceExpectedTraceHash: cardinal;
    function TryResolve(aInterface: PTypeInfo; out Obj): boolean; override;
    procedure InternalGetInstance(out aStubbedInterface); virtual;
    function InternalCheck(aValid,aExpectationFailed: boolean;
      const aErrorMsgFmt: RawUTF8; const aErrorMsgArgs: array of const): boolean; virtual;
    // match TOnFakeInstanceInvoke callback signature
    function Invoke(const aMethod: TServiceMethod;
      const aParams: RawUTF8; aResult, aErrorMsg: PRawUTF8;
      aClientDrivenID: PCardinal; aServiceCustomAnswer: PServiceCustomAnswer): boolean;
    // will launch InternalCheck() process if some expectations defined by
    // ExpectsCount() are not met, i.e. raise an exception for TInterfaceStub
    // or notify the associated test case for TInterfaceMock
................................................................................
  // are defined before running the test, and verification is performed
  // when the instance is released - use TInterfaceMockSpy if you prefer the
  // more explicit run-verify pattern
  TInterfaceMock = class(TInterfaceStub)
  protected
    fTestCase: TSynTestCase;
    function InternalCheck(aValid,aExpectationFailed: boolean;
      const aErrorMsgFmt: RawUTF8; const aErrorMsgArgs: array of const): boolean; override;
  public
    /// initialize an interface mock from TypeInfo(IMyInterface)
    // - aTestCase.Check() will be called in case of mocking failure
    // ! procedure TMyTestCase.OneTestCaseMethod;
    // ! var Persist: IPersistence;
    // ! ...
    // !   TInterfaceMock.Create(TypeInfo(IPersistence),Persist,self).
................................................................................
    fLogFamily: TSynLogFamily; // =SQLite3Log.Family by default
    procedure SetLogClass(aClass: TSynLogClass); virtual;
    function GetLogClass: TSynLogClass;
    {$endif}
    /// log the corresponding text (if logging is enabled)
    procedure InternalLog(const Text: RawUTF8; Level: TSynLogInfo); overload;
      {$ifdef HASINLINE}inline;{$endif}
    procedure InternalLog(const Format: RawUTF8; const Args: array of const;
      Level: TSynLogInfo); overload;
    /// internal method used by Delete(Table,SQLWhere) method
    function InternalDeleteNotifyAndGetIDs(Table: TSQLRecordClass; const SQLWhere: RawUTF8;
      var IDs: TIDDynArray): boolean; 
    /// retrieve the server time stamp
    // - default implementation will use fServerTimeStampOffset to compute
    // the value from PC time (i.e. NowUTC+fServerTimeStampOffset as TTimeLog)
................................................................................
    // - example of use:
    // ! aClient.OneFieldValue(TSQLRecord,'Name','ID=?',[aID])
    // - call internaly ExecuteList() to get the value
    // - note that this method prototype changed with revision 1.17 of the
    // framework: array of const used to be Args and '%' in the FormatSQLWhere
    // statement, whereas it now expects bound parameters as '?'
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const): RawUTF8; overload;
    /// get the UTF-8 encoded value of an unique field with a Where Clause
    // - this overloaded function will call FormatUTF8 to create the Where Clause
    // from supplied parameters, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! OneFieldValue(TSQLRecord,'Name','%=?',['ID'],[aID])
    // - call internaly ExecuteList() to get the value
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      const WhereClauseFmt: RawUTF8; const Args, Bounds: array of const): RawUTF8; overload;
    /// get one integer value of an unique field with a Where Clause
    // - this overloaded function will return the field value as integer
    function OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
      const WhereClauseFmt: RawUTF8; const Args, Bounds: array of const;
      out Data: Int64): boolean; overload;
    /// get the UTF-8 encoded value of an unique field from its ID
    // - example of use: OneFieldValue(TSQLRecord,'Name',23)
    // - call internaly ExecuteList() to get the value
    function OneFieldValue(Table: TSQLRecordClass;
      const FieldName: RawUTF8; WhereID: TID): RawUTF8; overload;
    /// get the UTF-8 encoded value of some fields with a Where Clause
................................................................................
    // - example of use:
    // ! aList := aClient.MultiFieldValues(TSQLRecord,'Name,FirstName','Salary>=?',[aMinSalary]);
    // - call overloaded MultiFieldValues() / ExecuteList() to get the list
    // - note that this method prototype changed with revision 1.17 of the
    // framework: array of const used to be Args and '%' in the WhereClauseFormat
    // statement, whereas it now expects bound parameters as '?'
    function MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
      const WhereClauseFormat: RawUTF8; const BoundsSQLWhere: array of const): TSQLTableJSON; overload;
    /// Execute directly a SQL statement, expecting a list of results
    // - return a result table on success, nil on failure
    // - FieldNames can be the CSV list of field names to be retrieved
    // - if FieldNames is '', will get all simple fields, excluding BLOBs
    // - if FieldNames is '*', will get ALL fields, including ID and BLOBs
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! Table := MultiFieldValues(TSQLRecord,'Name','%=?',['ID'],[aID]);
    // - call overloaded MultiFieldValues() / ExecuteList() to get the list
    function MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
      const WhereClauseFormat: RawUTF8; const Args, Bounds: array of const): TSQLTableJSON; overload;
    /// retrieve the main field (mostly 'Name') value of the specified record
    // - use GetMainFieldName() method to get the main field name
    // - use OneFieldValue() method to get the field value
    // - return '' if no such field or record exists
    // - if ReturnFirstIfNoUnique is TRUE and no unique property is found,
    // the first RawUTF8 property is returned anyway
    function MainFieldValue(Table: TSQLRecordClass; ID: TID;
................................................................................
    /// get a member from a SQL statement
    // - implements REST GET collection
    // - return true on success
    // - same as Retrieve(const SQLWhere: RawUTF8; Value: TSQLRecord) method, but
    // this overloaded function will call FormatUTF8 to create the Where Clause
    // from supplied parameters, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    function Retrieve(const WhereClauseFmt: RawUTF8; const Args,Bounds: array of const;
      Value: TSQLRecord): boolean; overload;
    /// get a member from its ID
    // - return true on success
    // - Execute 'SELECT * FROM TableName WHERE ID=:(aID): LIMIT 1' SQL Statememt
    // - if ForUpdate is true, the REST method is LOCK and not GET: it tries to lock
    // the corresponding record, then retrieve its content; caller has to call
    // UnLock() method after Value usage, to release the record
................................................................................
    // - aCustomFieldsCSV can be the CSV list of field names to be retrieved
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - return a TObjectList on success (possibly with Count=0) - caller is
    // responsible of freeing the instance
    // - this TObjectList will contain a list of all matching records
    // - return nil on error
    function RetrieveList(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): TObjectList; overload;
    /// get a list of members from a SQL statement as RawJSON
    // - implements REST GET collection
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
................................................................................
    // our expanded / not expanded JSON format - so can be used with SOA methods
    // and RawJSON results, for direct process from the client side
    // - returns '' on error
    // - the data is directly retrieved from raw JSON as returned by the database
    // without any conversion, so this method would be the fastest, but complex
    // types like dynamic array would be returned as Base64-encoded blob value -
    // if you need proper JSON access to those, see RetrieveDocVariantArray()
    function RetrieveListJSON(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): RawJSON;
    {$ifndef NOVARIANTS}
    /// get a list of all members from a SQL statement as a TDocVariant
    // - implements REST GET collection
    // - if ObjectName='', it will return a TDocVariant of dvArray kind
    // - if ObjectName is set, it will return a TDocVariant of dvObject kind,
................................................................................
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - the data will be converted to variants and TDocVariant following the
    // TSQLRecord layout, so complex types like dynamic array would be returned
    // as a true array of values (in contrast to the RetrieveListJSON method)
    function RetrieveDocVariantArray(Table: TSQLRecordClass;
      const ObjectName: RawUTF8;
      const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
      const CustomFieldsCSV: RawUTF8; FirstRecordID: PID=nil;
      LastRecordID: PID=nil): variant; overload;
    /// get one member from a SQL statement as a TDocVariant
    // - implements REST GET collection
    // - the data will be converted to a TDocVariant variant following the
    // TSQLRecord layout, so complex types like dynamic array would be returned
    // as a true array of values 
    function RetrieveDocVariant(Table: TSQLRecordClass;
      const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
      const CustomFieldsCSV: RawUTF8): variant; 
    {$endif NOVARIANTS}
    /// get a list of members from a SQL statement as T*ObjArray
    // - implements REST GET collection
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
................................................................................
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - set the T*ObjArray variable with all items on success - so that it can
    // be used with SOA methods
    // - it is up to the caller to ensure that ObjClear(ObjArray) is called
    // when the T*ObjArray list is not needed any more 
    // - returns true on success, false on error
    function RetrieveListObjArray(var ObjArray; Table: TSQLRecordClass;
      const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): boolean;
    /// Execute directly a SQL statement, expecting a list of results
    // - return a result table on success, nil on failure
    // - will call EngineList() abstract method to retrieve its JSON content
    function ExecuteList(const Tables: array of TSQLRecordClass; const SQL: RawUTF8): TSQLTableJSON; virtual;
    /// Execute directly a SQL statement, without any expected result
    // - implements POST SQL on ModelRoot URI
................................................................................
    // - return true on success
    // - will call EngineExecute() abstract method to run the SQL statement
    function Execute(const aSQL: RawUTF8): boolean; virtual;
    /// Execute directly a SQL statement with supplied parameters, with no result
    // - expect the same format as FormatUTF8() function, replacing all '%' chars
    // with Args[] values
    // - return true on success
    function ExecuteFmt(const SQLFormat: RawUTF8; const Args: array of const): boolean; overload;
    /// Execute directly a SQL statement with supplied parameters, with no result
    // - expect the same format as FormatUTF8() function, replacing all '%' chars
    // with Args[] values, and all '?' chars with Bounds[] (inlining them
    // with :(...): and auto-quoting strings)
    // - return true on success
    function ExecuteFmt(const SQLFormat: RawUTF8; const Args, Bounds: array of const): boolean; overload;
    /// unlock the corresponding record
    // - record should have been locked previously e.g. with Retrieve() and
    // forupdate=true, i.e. retrieved not via GET with LOCK REST-like verb
    // - use our custom UNLOCK REST-like verb
    // - returns true on success
    function UnLock(Table: TSQLRecordClass; aID: TID): boolean; overload; virtual; abstract;
    /// unlock the corresponding record
................................................................................
    // TSQLRecordMany kind (i.e. only so called "simple fields")
    // - the aSimpleFields must have exactly the same count of parameters as
    // there are "simple fields" in the published properties
    // - if ForcedID is set to non null, client sends this ID to be used
    // when adding the record (instead of a database-generated ID)
    // - on success, returns the new RowID value; on error, returns 0
    // - call internaly the Add virtual method above
    function Add(aTable: TSQLRecordClass; const aSimpleFields: array of const;
      ForcedID: TID=0): TID; overload;
    /// update a member from Value simple fields content
    // - implements REST PUT collection
    // - return true on success
    // - the TSQLRawBlob(BLOB) fields values are not updated by this method, to
    // preserve bandwidth: use the UpdateBlob() methods for handling BLOB fields
    // - the TSQLRecordMany fields are not set either: they are separate
    // instances created by TSQLRecordMany.Create, with dedicated methods to
................................................................................
    /// update a member from a supplied list of simple field values
    // - implements REST PUT collection
    // - the aSimpleFields parameters MUST follow explicitely both count and
    // order of published properties of the supplied aTable class, excepting the
    // TSQLRawBlob and TSQLRecordMany kind (i.e. only so called "simple fields")
    // - return true on success
    // - call internaly the Update() / EngineUpdate() virtual methods 
    function Update(aTable: TSQLRecordClass; aID: TID;
      const aSimpleFields: array of const): boolean; overload;
    /// create or update a member, depending if the Value has already an ID
    // - implements REST POST if Value.ID=0 or PUT collection on Value.ID
    // - will return the created or updated ID
    function AddOrUpdate(Value: TSQLRecord): TID;
    /// update one field/column value a given member
    // - implements REST PUT collection with one field value
    // - only one single field shall be specified in FieldValue, but could
................................................................................
    // - for better server speed, the WHERE clause should use bound parameters
    // identified as '?' in the FormatSQLWhere statement, which is expected to
    // follow the order of values supplied in BoundsSQLWhere open array - use
    // DateToSQL/DateTimeToSQL for TDateTime, or directly any integer / double /
    // currency / RawUTF8 values to be bound to the request as parameters
    // - is a simple wrapper around:
    // ! Delete(Table,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere))
    function Delete(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const): boolean; overload;

    /// access the internal caching parameters for a given TSQLRecord
    // - purpose of this caching mechanism is to speed up retrieval of some
    // common values at either Client or Server level (like configuration settings)
    // - by default, this CRUD level per-ID cache is disabled
    // - use Cache.SetCache() and Cache.SetTimeOut() methods to set the appropriate
................................................................................
    // double, currency, RawUTF8 values to be bound to the request as parameters
    // - aCustomFieldsCSV can be the CSV list of field names to be retrieved
    // - if aCustomFieldsCSV is '', will get all simple fields, excluding BLOBs
    // - if aCustomFieldsCSV is '*', will get ALL fields, including ID and BLOBs
    // - return a TObjectList<T> on success (possibly with Count=0) - caller is
    // responsible of freeing the instance
    // - return nil on error
    function RetrieveList<T: TSQLRecord>(const FormatSQLWhere: RawUTF8;
      const BoundsSQLWhere: array of const;
      const aCustomFieldsCSV: RawUTF8=''): TObjectList<T>; overload;
    {$endif}

    /// you can call this method in TThread.Execute to ensure that
    // the thread will be taken in account during process
    // - this abstract method won't do anything, but TSQLRestServer's will
................................................................................
    Where: PAnsiChar;
    /// returned JSON field value of optional total row counts
    // - default value is nil, i.e. no total row counts field
    // - computing total row counts can be very expensive, depending on the
    // database back-end used (especially for external databases)
    // - can be set e.g. to ',"totalRows":%' value (note that the initial "," is
    // expected by the produced JSON content, and % will be set with the value)
    SendTotalRowsCountFmt: RawUTF8;
  end;

  /// used for statistics update in TSQLRestServer.URI()
  TSQLRestServerStats = class(TPersistent)
  private
    /// used to determine if something changed
    fLastIncomingBytes: QWord;
................................................................................
    fTrackChangesHistoryTableIndex: TIntegerDynArray;
    fTrackChangesHistory: array of record
      CurrentRow: integer;
      MaxSentDataJsonRow: integer;
      MaxRevisionJSON: integer;
      MaxUncompressedBlobSize: integer;
    end;
    function CreateBackgroundThread(const Format: RawUTF8; const Args: array of const): TSynBackgroundThreadMethod;
    function GetAuthenticationSchemesCount: integer;
    /// fast get the associated static server, if any
    function GetStaticDataServer(aClass: TSQLRecordClass): TSQLRest;
    /// retrieve a TSQLRestStorage instance associated to a Virtual Table
    // - is e.g. TSQLRestStorageInMemory instance associated to a
    // TSQLVirtualTableBinary or TSQLVirtualTableJSON class
    // - may be a TSQLRestStorageExternal (as defined in mORMotDB unit)
................................................................................
    /// retrieve a list of members as a TSQLTable
    // - implements REST GET collection
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[] values
    // - using inlined parameters via :(...): in SQLWhereFormat is always a good idea
    // - for one TClass, you should better use TSQLRest.MultiFieldValues()
    // - will call the List virtual method internaly
    function ListFmt(const Tables: array of TSQLRecordClass;
      const SQLSelect, SQLWhereFormat: RawUTF8; const Args: array of const): TSQLTableJSON; overload;
    /// retrieve a list of members as a TSQLTable
    // - implements REST GET collection
    // - in this version, the WHERE clause can be created with the same format
    // as FormatUTF8() function, replacing all '%' chars with Args[], and all '?'
    // chars with Bounds[] (inlining them with :(...): and auto-quoting strings)
    // - example of use:
    // ! Table := ListFmt([TSQLRecord],'Name','ID=?',[],[aID]);
    // - for one TClass, you should better use TSQLRest.MultiFieldValues()
    // - will call the List virtual method internaly
    function ListFmt(const Tables: array of TSQLRecordClass;
      const SQLSelect, SQLWhereFormat: RawUTF8; const Args, Bounds: array of const): TSQLTableJSON; overload;
    /// dedicated method used to retrieve matching IDs using a fast R-Tree index
    // - a TSQLRecordRTree is associated to a TSQLRecord with a specified BLOB
    // field, and will call TSQLRecordRTree BlobToCoord and ContainedIn virtual
    // class methods to execute an optimized SQL query
    // - will return all matching DataTable IDs in DataID[]
    // - will generate e.g. the following statement
    // $ SELECT MapData.ID From MapData, MapBox WHERE MapData.ID=MapBox.ID
................................................................................
  PAGINGPARAMETERS_YAHOO: TSQLRestServerURIPagingParameters = (
    Sort: 'SORT=';
    Dir: 'DIR=';
    StartIndex: 'STARTINDEX=';
    Results: 'RESULTS=';
    Select: 'SELECT=';
    Where: 'WHERE=';
    SendTotalRowsCountFmt: '');

  /// options to specify no index createon for TSQLRestServer.CreateMissingTables
  // and TSQLRecord.InitializeTable methods
  INITIALIZETABLE_NOINDEX: TSQLInitializeTableOptions =
    [itoNoIndex4ID..itoNoIndex4RecordReference];


................................................................................
  SetString(fPrivateCopy,PAnsiChar(pointer(aJSON)),len);
  CreateWithColumnTypes(ColumnTypes,aSQL,pointer(fPrivateCopy),len);
end;


{ TINIWriter }





procedure TINIWriter.WriteObject(Value: TObject; const SubCompName: RawUTF8='';
  WithSection: boolean=true);
var P: PPropInfo;
    i, V: integer;
    VT: shortstring; // for str()
    Obj: TObject;
    WS: WideString;
................................................................................
    VV: Variant;
    {$endif}
begin
  if Value<>nil then begin
    if WithSection then
      // new TObject.ClassName is UnicodeString (Delphi 20009) -> inline code with
      // vmtClassName = UTF-8 encoded text stored in a shortstring = -44
      Add(#13'[%]'#13,[PShortString(PPointer(PPtrInt(Value)^+vmtClassName)^)^]);
    for i := 1 to InternalClassPropInfo(PPointer(Value)^,P) do begin
      case P^.PropType^.Kind of
        tkInt64{$ifdef FPC}, tkQWord{$endif}:
          Add('%%=%'#13,[SubCompName,P^.Name,P^.GetInt64Prop(Value)]);
        {$ifdef FPC}tkBool,{$endif}
        tkEnumeration, tkInteger, tkSet: begin
          V := P^.GetOrdProp(Value);
          if V<>P^.Default then
            Add('%%=%'#13,[SubCompName,P^.Name,V]);
        end;
        {$ifdef FPC}tkAString,{$endif} tkLString:
          Add('%%=%'#13,[SubCompName,P^.Name,P^.GetLongStrValue(Value)]);
        tkFloat: begin
          VT[0] := AnsiChar(ExtendedToString(VT,P^.GetFloatProp(Value),DOUBLE_PRECISION));
          Add('%%=%'#13,[SubCompName,P^.Name,VT]);
        end;
        tkWString: begin
          P^.GetWideStrProp(Value,WS);
          Add('%%=%'#13,[SubCompName,P^.Name,WS]);
        end;
        {$ifdef UNICODE}
        tkUString: // write converted to UTF-8
          Add('%%=%'#13,[SubCompName,P^.Name,P^.GetUnicodeStrProp(Value)]);
        {$endif}
        tkDynArray: begin
          Add('%%=%'#13,[SubCompName,P^.Name]);
          AddDynArrayJSON(P^.GetDynArray(Value));
          Add(#13);
        end;
        {$ifdef PUBLISHRECORD}
        tkRecord{$ifdef FPC},tkObject{$endif}:
          Add('%%=%'#13,[SubCompName,P^.Name,BinToBase64WithMagic(
            RecordSave(P^.GetFieldAddr(Value)^,P^.PropType^))]);
        {$endif}
        tkClass: begin
          Obj := P^.GetObjProp(Value); 
          if (Obj<>nil) and Obj.InheritsFrom(TPersistent) then
             WriteObject(Obj,SubCompName+RawUTF8(P^.Name)+'.',false);
        end;
        {$ifndef NOVARIANTS}
        tkVariant: begin // stored as JSON, e.g. '1.234' or '"text"'
          P^.GetVariantProp(Value,VV);
          Add('%%=%'#13,[SubCompName,P^.Name,VariantSaveJSON(VV)]);
        end;
        {$endif}
      end; // tkString (shortstring) is not handled
      P := P^.Next;
    end;
  end;
end;
................................................................................
constructor TSQLRecord.Create(aClient: TSQLRest; const aSQLWhere: RawUTF8);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(aSQLWhere,self);
end;

constructor TSQLRecord.Create(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),self);
end;

constructor TSQLRecord.Create(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
  const ParamsSQLWhere, BoundsSQLWhere: array of const);
begin
  Create;
  if aClient<>nil then
    aClient.Retrieve(FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),self);
end;

................................................................................
  if T=nil then
    exit;
  T.OwnerMustFree := true;
  FillPrepare(T,aCheckTableName);
  result := true;
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest; const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8=''): boolean;
begin
  if (FormatSQLWhere='') or (high(BoundsSQLWhere)<0) then
    result := false else
    result := FillPrepare(aClient,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),
      aCustomFieldsCSV);
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest;
  const FormatSQLWhere: RawUTF8; const ParamsSQLWhere, BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8): boolean;
begin
  if (FormatSQLWhere='') or ((high(ParamsSQLWhere)<0)and(high(BoundsSQLWhere)<0)) then
    result := false else
    result := FillPrepare(aClient,
      FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),aCustomFieldsCSV);
end;

function TSQLRecord.FillPrepare(aClient: TSQLRest; const aIDs: array of Int64;
  const aCustomFieldsCSV: RawUTF8=''): boolean;
................................................................................
  if aTable=nil then
    exit;
  aTable.OwnerMustFree := true;
  FillPrepare(aTable);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
  const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8='');
begin
  CreateAndFillPrepare(aClient,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere),
    aCustomFieldsCSV);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
  const FormatSQLWhere: RawUTF8; const ParamsSQLWhere,
  BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8);
begin
  CreateAndFillPrepare(aClient,
    FormatUTF8(FormatSQLWhere,ParamsSQLWhere,BoundsSQLWhere),aCustomFieldsCSV);
end;

constructor TSQLRecord.CreateAndFillPrepare(aClient: TSQLRest;
................................................................................
begin
  Create;
  props := aClient.Model.Props[PSQLRecordClass(Self)^];
  if props.props.JoinedFields=nil then
    raise EORMException.CreateUTF8('No nested TSQLRecord to JOIN in %',[self]);
  SQL := props.SQL.SelectAllJoined;
  if aFormatSQLJoin<>'' then
    SQL := SQL+FormatUTF8(SQLFromWhere(aFormatSQLJoin),
      aParamsSQLJoin,aBoundsSQLJoin);
  T := aClient.ExecuteList(props.props.JoinedFieldsTable,SQL);
  if T=nil then
    exit;
  fFill := TSQLRecordFill.Create;
  fFill.fJoinedFields := True;
  fFill.fTable := T;
................................................................................
constructor TSQLRecord.CreateJoined(aClient: TSQLRest; aID: TID);
begin
  CreateAndFillPrepareJoined(aClient,'%.RowID=?',[RecordProps.SQLTableName],[aID]);
  FillOne;
end;

constructor TSQLRecord.CreateAndFillPrepareMany(aClient: TSQLRest;
  const aFormatSQLJoin: RawUTF8; const aParamsSQLJoin, aBoundsSQLJoin: array of const);
begin
  Create;
  if Length(RecordProps.ManyFields)=0 then
    raise EModelException.CreateUTF8(
      '%.CreateAndFillPrepareMany() with no many-to-many fields',[self]);
  if not FillPrepareMany(aClient,aFormatSQLJoin,aParamsSQLJoin,aBoundsSQLJoin) then
    raise EModelException.CreateUTF8(
      '%.CreateAndFillPrepareMany(): FillPrepareMany() failure',[self]);
end;

function TSQLRecord.FillPrepareMany(aClient: TSQLRest;
  const aFormatSQLJoin: RawUTF8; const aParamsSQLJoin, aBoundsSQLJoin: array of const): boolean;
var aSQLFields, aSQLFrom, aSQLWhere, aSQL: RawUTF8;
    aField: string[3];
    aMany: RawUTF8;
    f, n, i, SQLFieldsCount: Integer;
    Props: TSQLRecordProperties;
    T: TSQLTable;
    SQLFields: array of record
      SQL: string[3];
      Prop: TSQLPropInfo;
      Instance: TSQLRecord;
    end;
    M: TSQLRecordMany;
    D: TSQLRecord;
    J,JBeg: PUTF8Char;
    Objects: array of TSQLRecord;
    ObjectsClass: array of TSQLRecordClass;

  function AddField(aProp: TSQLPropInfo): Boolean;
  begin
    if SQLFieldsCount>=MAX_SQLFIELDS then
      result := false else
................................................................................
    end;
  if Props.fSQLFillPrepareMany<>'' then
    aSQL := Props.fSQLFillPrepareMany else begin
    aSQL := FormatUTF8('select % from % where %',[aSQLFields,aSQLFrom,aSQLWhere]);
    Props.fSQLFillPrepareMany := aSQL;
  end;
  // process aFormatSQLJoin,aParamsSQLJoin and aBoundsSQLJoin parameters
  if aFormatSQLJoin<>'' then begin
    aSQLWhere := '';
    JBeg := pointer(aFormatSQLJoin);
    repeat

      J := JBeg;
      while not (ord(J^) in IsIdentifier) do begin
        case J^ of
        '"':  repeat inc(J) until J^ in [#0,'"'];
        '''': repeat inc(J) until J^ in [#0,''''];
        end;
        if J^=#0 then break;
        inc(J);
      end;
      if J<>JBeg then begin // append ' ',')'..
        SetString(aSQLFrom,PAnsiChar(JBeg),J-JBeg);
        aSQLWhere := aSQLWhere+aSQLFrom;

        JBeg := J;
      end;
      if J^=#0 then break;
      aSQLWhere := aSQLWhere+ProcessField(JBeg);

    until JBeg^=#0;
    aSQL := aSQL+' and ('+FormatUTF8(aSQLWhere,aParamsSQLJoin,aBoundsSQLJoin)+')';
  end;
  // execute SQL statement and retrieve data
  T := aClient.ExecuteList(ObjectsClass,aSQL);
  if (T=nil) or (T.fResults=nil) then
    exit;
  fFill.fTable := T;
  T.OwnerMustFree := true;
................................................................................
begin
  {$ifdef WITHLOG}
  if Level in fLogFamily.Level then
    fLogFamily.SynLog.Log(Level,Text,self);
  {$endif}
end;

procedure TSQLRest.InternalLog(const Format: RawUTF8; 
  const Args: array of const; Level: TSynLogInfo);
begin
  {$ifdef WITHLOG}
  if Level in fLogFamily.Level then
    fLogFamily.SynLog.Log(Level,Format,Args,self);
  {$endif}
end;
................................................................................
begin
  if MultiFieldValue(Table,[FieldName],Res,WhereClause) then
    result := Res[0] else
    result := '';
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
  const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const): RawUTF8;
begin
  result := OneFieldValue(Table,FieldName,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass;
  const FieldName: RawUTF8; const WhereClauseFmt: RawUTF8;
  const Args, Bounds: array of const): RawUTF8;
begin
  result := OneFieldValue(Table,FieldName,FormatUTF8(WhereClauseFmt,Args,Bounds));
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass;
  const FieldName: RawUTF8; WhereID: TID): RawUTF8;
................................................................................

function TSQLRest.MemberExists(Table: TSQLRecordClass; ID: TID): boolean;
begin
  result := OneFieldValue(Table,'RowID',ID)<>'';
end;

function TSQLRest.OneFieldValue(Table: TSQLRecordClass; const FieldName: RawUTF8;
  const WhereClauseFmt: RawUTF8; const Args, Bounds: array of const;
  out Data: Int64): boolean;
var Res: array[0..0] of RawUTF8;
    err: integer;
begin
  result := false;
  if MultiFieldValue(Table,[FieldName],Res,FormatUTF8(WhereClauseFmt,Args,Bounds)) then
    if Res[0]<>'' then begin
................................................................................
  sql := SQLComputeForSelect(Table,FieldNames,WhereClause);
  if sql='' then
    result := nil else
    result := ExecuteList([Table],sql);
end;

function TSQLRest.MultiFieldValues(Table: TSQLRecordClass; const FieldNames: RawUTF8;
  const WhereClauseFormat: RawUTF8; const BoundsSQLWhere: array of const): TSQLTableJSON;
begin
  result := MultiFieldValues(Table,FieldNames,FormatUTF8(WhereClauseFormat,[],BoundsSQLWhere));
end;

function TSQLRest.MultiFieldValues(Table: TSQLRecordClass;
  const FieldNames: RawUTF8; const WhereClauseFormat: RawUTF8;
  const Args, Bounds: array of const): TSQLTableJSON;
begin
  result := MultiFieldValues(Table,FieldNames,FormatUTF8(WhereClauseFormat,Args,Bounds));
end;

function TSQLRest.MultiFieldValue(Table: TSQLRecordClass;
  const FieldName: array of RawUTF8; var FieldValue: array of RawUTF8;
................................................................................
        result := false;
      end;
    finally
      T.Free;
    end;
end;

function TSQLRest.RetrieveList(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): TObjectList;
var T: TSQLTable;
begin
  result := nil;
  if (self=nil) or (Table=nil) then
    exit;
  T := MultiFieldValues(Table,aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    result := TObjectList.Create;
    T.ToObjectList(result,Table);
  finally
    T.Free;
  end;
end;

function TSQLRest.RetrieveListJSON(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): RawJSON;
var sql: RawUTF8;
begin
  sql := SQLComputeForSelect(Table,aCustomFieldsCSV,
    FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
  if sql='' then
    result := '' else
    result := EngineList(sql);
end;

function TSQLRest.RetrieveListObjArray(var ObjArray; Table: TSQLRecordClass;
  const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
  const aCustomFieldsCSV: RawUTF8): boolean;
var T: TSQLTable;
begin
  result := false;
  if (self=nil) or (Table=nil) then
    exit;
  T := MultiFieldValues(Table,aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    T.Free;
  end;
end;

{$ifndef NOVARIANTS}
function TSQLRest.RetrieveDocVariantArray(Table: TSQLRecordClass;
  const ObjectName: RawUTF8;
  const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
  const CustomFieldsCSV: RawUTF8; FirstRecordID,LastRecordID: PID): variant;
var T: TSQLTable;
    res: variant;
begin
  TVarData(res).VType := varNull;
  if (self<>nil) and (Table<>nil) then begin
    T := MultiFieldValues(Table,CustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
    result := _ObjFast([ObjectName,res]) else
    result := res;
end;

function TSQLRest.RetrieveDocVariantArray(Table: TSQLRecordClass;
  const ObjectName, CustomFieldsCSV: RawUTF8; FirstRecordID,LastRecordID: PID): variant;
begin
  result := RetrieveDocVariantArray(Table,ObjectName,'',[],CustomFieldsCSV,
    FirstRecordID,LastRecordID);
end;

function TSQLRest.RetrieveDocVariant(Table: TSQLRecordClass;
  const FormatSQLWhere: RawUTF8; const BoundsSQLWhere: array of const;
  const CustomFieldsCSV: RawUTF8): variant;
var T: TSQLTable;
    bits: TSQLFieldBits;
    Rec: TSQLRecord;
    ID: TID;
begin
  SetVariantNull(result);
  if (self<>nil) and (Table<>nil) then begin
    with Table.RecordProps do // optimized primary key direct access
    if Cache.IsCached(Table) and (length(BoundsSQLWhere)=1) and
       VarRecToInt64(BoundsSQLWhere[0],Int64(ID)) and 
       FieldIndexsFromCSV(CustomFieldsCSV,bits) then
      if IsZero(bits) then
        exit else
      if bits-SimpleFieldsBits[soSelect]=[] then

        if IdemPropNameU('RowID=?',FormatSQLWhere) or
           IdemPropNameU('ID=?',FormatSQLWhere) then begin
          Rec := Table.Create(self,ID);
          try
            result := Rec.GetAsDocVariant(True,bits);
          finally
            Rec.Free;
          end;
          exit;
        end;

    T := MultiFieldValues(Table,CustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
    if T<>nil then                   
    try
      T.ToDocVariant(1,result)
    finally
      T.Free;
    end;
  end;
end;
................................................................................
    fCache.Notify(Tableindex,aID,Resp,soSelect);
  end;
  // fill Value from JSON if was correctly retrieved
  Value.FillFrom(Resp);
  result := true;
end;

function TSQLRest.Retrieve(const WhereClauseFmt: RawUTF8; const Args,Bounds: array of const;
  Value: TSQLRecord): boolean;
var where: RawUTF8;
begin
  where := FormatUTF8(WhereClauseFmt,Args,Bounds);
  result := Retrieve(where,Value);
end;

................................................................................
var IDs: TIDDynArray;
begin
  if InternalDeleteNotifyAndGetIDs(Table,SQLWhere,IDs) then
    result := EngineDeleteWhere(Model.GetTableIndexExisting(Table),SQLWhere,IDs) else
    result := false;
end;

function TSQLRest.Delete(Table: TSQLRecordClass; const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const): boolean;
begin
  result := Delete(Table,FormatUTF8(FormatSQLWhere,[],BoundsSQLWhere));
end;

function TSQLRest.Update(Value: TSQLRecord; const CustomFields: TSQLFieldBits): boolean;
var JSONValues: RawUTF8;
................................................................................
end;

function TSQLRest.Execute(const aSQL: RawUTF8): boolean;
begin
  result := EngineExecute(aSQL);
end;

function TSQLRest.ExecuteFmt(const SQLFormat: RawUTF8;
  const Args: array of const): boolean;
begin
  result := EngineExecute(FormatUTF8(SQLFormat,Args));
end;

function TSQLRest.ExecuteFmt(const SQLFormat: RawUTF8;
  const Args, Bounds: array of const): boolean;
begin
  result := EngineExecute(FormatUTF8(SQLFormat,Args,Bounds));
end;

function TSQLRest.MainFieldValue(Table: TSQLRecordClass; ID: TID;
   ReturnFirstIfNoUnique: boolean=false): RawUTF8;
................................................................................
  service := fServices.Info(TypeInfo(T));
  if (service=nil) or not service.Get(result) then
    result := Default(T);
end;

function TSQLRest.RetrieveList<T>(const aCustomFieldsCSV: RawUTF8): TObjectList<T>;
begin
  result := RetrieveList<T>('',[],aCustomFieldsCSV);
end;

function TSQLRest.RetrieveList<T>(const FormatSQLWhere: RawUTF8;
  const BoundsSQLWhere: array of const; const aCustomFieldsCSV: RawUTF8): TObjectList<T>;
var Table: TSQLTable;
begin
  result := nil;
  if self=nil then
    exit;
  Table := MultiFieldValues(TSQLRecordClass(T),aCustomFieldsCSV,FormatSQLWhere,BoundsSQLWhere);
................................................................................
begin
  result := true;
  for i := 0 to high(FieldNames) do
    if not CreateSQLMultiIndex(Table,[FieldNames[i]],Unique) then
     result := false;
end;

function TSQLRestServer.CreateBackgroundThread(const Format: RawUTF8; const Args: array of const): TSynBackgroundThreadMethod;
begin
  result := TSynBackgroundThreadMethod.Create(nil,FormatUTF8(Format,Args));
  result.OnBeforeExecute := BeginCurrentThread;
  result.OnAfterExecute := EndCurrentThread;
end;

function TSQLRestServer.GetAuthenticationSchemesCount: integer;
................................................................................
             not ContainsUTF8(pointer(SQLWhere),'ORDER BY') then begin
            if SameTextU(SQLDir,'DESC') then
              SQLSort := SQLSort+' DESC'; // allow DESC, default is ASC
            SQLWhere := SQLWhere+' ORDER BY '+SQLSort;
          end;
          SQLWhere := trim(SQLWhere);
          if (SQLResults<>0) and not ContainsUTF8(pointer(SQLWhere),'LIMIT ') then begin
            if (Server.URIPagingParameters.SendTotalRowsCountFmt<>'') then begin
              if SQLWhere=SQLWhereCount then begin
                i := PosEx('ORDER BY ',UpperCase(SQLWhereCount));
                if i>0 then // if ORDER BY already in the SQLWhere clause
                  SetLength(SQLWhereCount,i-1);
              end;
              ResultList := Server.ExecuteList([Table],
                Server.Model.TableProps[TableIndex].SQLFromSelectWhere('Count(*)',SQLWhereCount));
................................................................................
          end;
        end;
        SQL := Server.Model.TableProps[TableIndex].
          SQLFromSelectWhere(SQLSelect,trim(SQLWhere));
        Call.OutBody := Server.InternalListRawUTF8(TableIndex,SQL);
        if Call.OutBody<>'' then begin // got JSON list '[{...}]' ?
          Call.OutStatus := HTML_SUCCESS;  // 200 OK
          if Server.URIPagingParameters.SendTotalRowsCountFmt<>'' then
            if Server.NoAJAXJSON then begin
              P := pointer(Call.OutBody);
              L := length(Call.OutBody);
              P := NotExpandedBufferRowCountPos(P,P+L);
              j := 0;
              if P<>nil then
                j := P-pointer(Call.OutBody)-11 else
................................................................................
procedure TSQLRestServerURIContext.Success(Status: integer);
begin
  if (Status in [HTML_SUCCESS,HTML_CREATED]) or (Status=HTML_NOTMODIFIED) then
    Call.OutStatus := Status else
    Error('',Status);
end;

procedure TSQLRestServerURIContext.Error(const Format: RawUTF8;
  const Args: array of const; Status: integer);
begin
  Error(FormatUTF8(Format,Args),Status);
end;

procedure TSQLRestServerURIContext.Error(E: Exception;
  const Format: RawUTF8; const Args: array of const; Status: integer);
var msg,exc: RawUTF8;
begin
  msg := FormatUTF8(Format,Args);
  if E=nil then
    Error(msg,Status) else begin
    exc := ObjectToJSONDebug(E);
    if msg='' then
................................................................................

procedure TSQLRestClient.RollBack(SessionID: cardinal);
begin
  inherited;
end;

function TSQLRestClient.ListFmt(const Tables: array of TSQLRecordClass; const SQLSelect: RawUTF8;
  const SQLWhereFormat: RawUTF8; const Args: array of const): TSQLTableJSON;
begin
  result := List(Tables,SQLSelect,FormatUTF8(SQLWhereFormat,Args));
end;

function TSQLRestClient.ListFmt(const Tables: array of TSQLRecordClass;
  const SQLSelect: RawUTF8; const SQLWhereFormat: RawUTF8;
  const Args, Bounds: array of const): TSQLTableJSON;
begin
  result := List(Tables,SQLSelect,FormatUTF8(SQLWhereFormat,Args,Bounds));
end;

function TSQLRestClient.RTreeMatch(DataTable: TSQLRecordClass;
  const DataTableBlobFieldName: RawUTF8; RTreeTable: TSQLRecordRTreeClass;
................................................................................

function ObjectToVariantDebug(Value: TObject): variant;
begin
  result := _JsonFast(ObjectToJSONDebug(Value));
end;

function ObjectToVariantDebug(Value: TObject;
  const ContextFormat: RawUTF8; const ContextArgs: array of const;
  const ContextName: RawUTF8): variant;
begin
  result := _JsonFast(ObjectToJSONDebug(Value));
  if ContextFormat<>'' then
    if ContextFormat[1]='{' then
      _ObjAddProps([ContextName,_JsonFastFmt(ContextFormat,[],ContextArgs)],result) else
      _ObjAddProps([ContextName,FormatUTF8(ContextFormat,ContextArgs)],result);
end;

function UrlEncode(const NameValuePairs: array of const): RawUTF8;
// (['select','*','where','ID=12','offset',23,'object',aObject]);
var A, n: PtrInt;
................................................................................
    if PosEx(RawUTF8(':('),aDestWhereSQL,1)>0 then
      // statement is globaly inlined -> cache prepared statement
      SQL := 'SELECT % FROM %,% WHERE %.Source=:(%): AND %.Dest=%.RowID AND %' else
      // statement is not globaly inlined -> no caching of prepared statement
      SQL := 'SELECT % FROM %,% WHERE %.Source=% AND %.Dest=%.RowID AND %';
  result := aClient.ExecuteList([PSQLRecordClass(Self)^,
     TSQLRecordClass(SelfProps.Props.fRecordManyDestProp.ObjectClass)],
    FormatUTF8(SQL,
      [Select, DestProps.Props.SQLTableName,SelfProps.Props.SQLTableName,
       SelfProps.Props.SQLTableName,aSourceID, SelfProps.Props.SQLTableName,
       DestProps.Props.SQLTableName, aDestWhereSQL]));
end;

function TSQLRecordMany.DestGet(aClient: TSQLRest;
  out DestIDs: TIDDynArray): boolean;
................................................................................
     (aClient=nil) then
    Result := '' else begin
    if aAndWhereSQL<>'' then
      if PosEx(RawUTF8(':('),aAndWhereSQL,1)>0 then
        Result := '%:(%): AND %' else // inlined parameters
        Result := '%% AND %' else // no inlined parameters -> not cached
      Result := '%:(%):'; // no additional where clause -> inline ID
    Result := FormatUTF8(result,[FieldName[isDest],aID,aAndWhereSQL]);
  end;
end;

function TSQLRecordMany.SourceGet(aClient: TSQLRest; aDestID: TID;
  out SourceIDs: TIDDynArray): boolean;
var Where: RawUTF8;
begin
................................................................................
  end;

  EInterfaceStub = class(EInterfaceFactoryException)
  public
    constructor Create(Sender: TInterfaceStub; const Method: TServiceMethod;
      const Error: RawUTF8); overload;
    constructor Create(Sender: TInterfaceStub; const Method: TServiceMethod;
      const Format: RawUTF8; const Args: array of const); overload;
  end;


constructor TInterfacedObjectFake.Create(aFactory: TInterfaceFactory;
  aInvoke: TOnFakeInstanceInvoke; aNotifyDestroy: TOnFakeInstanceDestroy);
begin
  inherited Create(aFactory,aInvoke,aNotifyDestroy);
................................................................................
function TInterfacedObjectFake.FakeCall(var aCall: TFakeCallStack): Int64;
{$ifdef CPUARM}
begin
  raise EInterfaceFactoryException.Create('You encountered an ALF! ARM not yet supported');
end;
{$else}
var method: ^TServiceMethod;
procedure RaiseError(const Format: RawUTF8; const Args: array of const);
begin
  raise EInterfaceFactoryException.CreateUTF8('Invalid %.FakeCall() for %.%: %',
    [self,fFactory.fInterfaceTypeInfo^.Name,method^.URI,FormatUTF8(Format,Args)]);
end;
var resultType: TServiceMethodValueType; // type of value stored into result
procedure InternalProcess;
var Params: TJSONSerializer;
................................................................................
    PP: ^PPTypeInfo absolute P;
    Ancestor: PTypeInfo;
    Kind: TMethodKind;
    f: TParamFlags;
    m,a: integer;
    n: cardinal;
    aURI: RawUTF8;
procedure RaiseError(const Format: RawUTF8; const Args: array of const);
begin
  raise EInterfaceFactoryException.CreateUTF8(
    '%.AddMethodsFromTypeInfo: %.% %',
    [self,fInterfaceTypeInfo^.Name,aURI,FormatUTF8(Format,Args)]);
end;
begin
  // handle interface inheritance via recursive calls
................................................................................
  const Method: TServiceMethod; const Error: RawUTF8);
begin
  inherited CreateUTF8('Error in % for %.% - %',
    [Sender,Sender.fInterface.fInterfaceTypeInfo^.Name,Method.URI,Error]);
end;

constructor EInterfaceStub.Create(Sender: TInterfaceStub;
  const Method: TServiceMethod; const Format: RawUTF8; const Args: array of const);
begin
  Create(Sender,Method,FormatUTF8(Format,Args));
end;

function TInterfaceStubLog.Results: RawUTF8;
begin
  if CustomResults='' then
................................................................................
begin
  fSender := aSender;
  fMethod := aMethod;
  fParams := aParams;
  fEventParams := aEventParams;
end;

procedure TOnInterfaceStubExecuteParamsAbstract.Error(
  const Format: RawUTF8; const Args: array of const);
begin
  Error(FormatUTF8(Format,Args));
end;

procedure TOnInterfaceStubExecuteParamsAbstract.Error(const aErrorMessage: RawUTF8);
begin
  fFailed := true;
................................................................................
  with TInterfacedObjectFake.Create(fInterface,Invoke,InstanceDestroyed) do begin
    pointer(aStubbedInterface) := @fVTable;
    _AddRef;
  end;
end;

function TInterfaceStub.InternalCheck(aValid,aExpectationFailed: boolean;
  const aErrorMsgFmt: RawUTF8; const aErrorMsgArgs: array of const): boolean;
begin
  result := aValid;
  if aExpectationFailed and not aValid then
    raise EInterfaceStub.CreateUTF8('%.InternalCheck(%) failed: %',
      [self,fInterface.fInterfaceTypeInfo^.Name,FormatUTF8(aErrorMsgFmt,aErrorMsgArgs)]);
end;

................................................................................
constructor TInterfaceMock.Create(const aGUID: TGUID; aTestCase: TSynTestCase);
begin
  inherited Create(aGUID);
  fTestCase := aTestCase;
end;

function TInterfaceMock.InternalCheck(aValid,aExpectationFailed: boolean;
  const aErrorMsgFmt: RawUTF8; const aErrorMsgArgs: array of const): boolean; 
begin
  if fTestCase=nil then
    result := inherited InternalCheck(aValid,aExpectationFailed,aErrorMsgFmt,aErrorMsgArgs) else begin
    if aValid xor (imoMockFailsWillPassTestCase in Options) then
      fTestCase.Check(true) else
      fTestCase.Check(false,UTF8ToString(FormatUTF8(aErrorMsgFmt,aErrorMsgArgs)));
    result := true; // do not raise any exception at this stage for TInterfaceMock

begin
  if (self=nil) or (FSCHandle=0) then
    result := ssErrorRetrievingState else
  if FHandle=0 then
    result := ssNotInstalled else
    result := CurrentStateToServiceState(Status.dwCurrentState);
  {$ifndef NOMORMOTKERNEL}
  SQLite3Log.Add.Log(sllTrace,pointer(FName),TypeInfo(TServiceState),result);
  {$endif}
end;

function TServiceController.GetStatus: TServiceStatus;
begin
  FillChar(FStatus, Sizeof(FStatus), 0);
  QueryServiceStatus(FHandle, FStatus);

begin
  if (self=nil) or (FSCHandle=0) then
    result := ssErrorRetrievingState else
  if FHandle=0 then
    result := ssNotInstalled else
    result := CurrentStateToServiceState(Status.dwCurrentState);
  {$ifndef NOMORMOTKERNEL}
  SQLite3Log.Add.Log(sllTrace,FName,TypeInfo(TServiceState),result);
  {$endif}
end;

function TServiceController.GetStatus: TServiceStatus;
begin
  FillChar(FStatus, Sizeof(FStatus), 0);
  QueryServiceStatus(FHandle, FStatus);

  - BREAKING CHANGE of TTextWriter.WriteObject() method: serialization is now
    defined with a new TTextWriterWriteObjectOptions set
  - BREAKING CHANGE rename of Iso8601 low-level structure as TTimeLogBits, to use
    explicitly the TTimeLog type and name for all Int64 bit-oriented functions -
    now "Iso8601" naming will be only for standard ISO-8601 text, not Int64 value
  - BREAKING CHANGE: TTextWriter.Add(Format) won't handle the alternate $ % tags
    any more, unless you define the OLDTEXTWRITERFORMAT conditional



  - Delphi XE4/XE5/XE6/XE7/XE8 compatibility (Win32/Win64 target platform only
    for the SynCommons and mORMot* units, but see SynCrossPlatform* units for
    clients on all other targets, including OSX and the NextGen compilers)
  - unit fixed and tested with Delphi XE2 (and up) 64-bit compiler under Windows
  - now all variants created within our units will create string instances of
    kind varString and type RawUTF8 - prior to Delphi 2009, ensure you call
    UTF8ToString(aVariant) if you want to use the value with the VCL
................................................................................
/// fast Format() function replacement, optimized for RawUTF8
// - only supported token is %, which will be inlined in the resulting string
// according to each Args[] supplied item
// - resulting string has no length limit and uses fast concatenation
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
function FormatUTF8(Format: PUTF8Char; const Args: array of const): RawUTF8; overload;

/// fast Format() function replacement, handling % and ? parameters
// - will include Args[] for every % in Format
// - will inline Params[] for every ? in Format, handling special "inlined"
// parameters, as exected by mORMot.pas unit, i.e. :(1234): for numerical
// values, and :('quoted '' string'): for textual values
// - if optional JSONFormat parameter is TRUE, ? parameters will be written
// as JSON quoted strings, without :(...): tokens, e.g. "quoted "" string"
// - resulting string has no length limit and uses fast concatenation
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
function FormatUTF8(Format: PUTF8Char; const Args, Params: array of const;
  JSONFormat: boolean=false): RawUTF8; overload;

/// convert an open array (const Args: array of const) argument to an UTF-8
// encoded text
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
procedure VarRecToUTF8(const V: TVarRec; var result: RawUTF8;
  wasString: PBoolean=nil);






/// convert an open array (const Args: array of const) argument to a value
// encoded as with :(..:) inlined parameters in FormatUTF8(Format,Args,Params)
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
procedure VarRecToInlineValue(const V: TVarRec; var result: RawUTF8);
................................................................................
    // - expected element layout is to have a RawUTF8 field at first position
    // - the aName is searched (using hashing) to be unique, and if not the case,
    // an ESynException.CreateUTF8() is raised with the supplied arguments 
    // - use internaly FindHashedForAdding method
    // - this version will set the field content with the unique value
    // - returns a pointer to the newly added element (to set other fields)
    function AddUniqueName(const aName: RawUTF8;
      ExceptionMsg: PUTF8Char; const ExceptionArgs: array of const): pointer;
    /// search for a given element name, make it unique, and add it to the array
    // - expected element layout is to have a RawUTF8 field at first position
    // - the aName is searched (using hashing) to be unique, and if not the case,
    // some suffix is added to make it unique
    // - use internaly FindHashedForAdding method
    // - this version will set the field content with the unique value
    // - returns a pointer to the newly added element (to set other fields)
................................................................................
    // - CR = #13 indicates CR+LF chars
    // - � = #167 indicates to trim last comma
    // - | = #124 will write the next char e.g. Add('%|$',[10]) will write '10$'
    // - since some of this characters above are > #127, they are not UTF-8
    // ready, so we expect the input format to be WinAnsi, i.e. mostly English
    // text (with chars < #128) with some values to be inserted inside
    {$endif}
    procedure Add(Format: PWinAnsiChar; const Values: array of const;
      Escape: TTextWriterKind=twNone); overload;
{$endif DELPHI5OROLDER}
    /// append some values at once
    // - text values (e.g. RawUTF8) will be escaped as JSON
    procedure Add(const Values: array of const); overload;
    /// append CR+LF (#13#10) chars
    // - this method won't call EchoAdd() registered events - use AddEndOfLine()
................................................................................
    // versions of Delphi will retrieve the code page from string
    // - if CodePage is defined to a >= 0 value, the encoding will take place
    procedure AddAnyAnsiString(const s: RawByteString; Escape: TTextWriterKind;
      CodePage: Integer=-1);
    /// append some chars to the buffer
    // - if Len is 0, Len is calculated from zero-ended char
    // - don't escapes chars according to the JSON RFC
    procedure AddNoJSONEscape(P: Pointer; Len: integer=0);
    /// append some chars, quoting all " chars
    // - same algorithm than AddString(QuotedStr()) - without memory allocation
    // - this function implements what is specified in the official SQLite3
    // documentation: "A string constant is formed by enclosing the string in single
    // quotes ('). A single quote within the string can be encoded by putting two
    // single quotes in a row - as in Pascal."
    procedure AddQuotedStr(Text: PUTF8Char; Quote: AnsiChar; TextLen: integer=0); 
................................................................................
    // - escapes chars according to the JSON RFC
    procedure AddJSONEscapeW(P: PWord; Len: PtrInt=0);
    /// append an open array constant value to the buffer
    // - "" will be added if necessary
    // - escapes chars according to the JSON RFC
    // - very fast (avoid most temporary storage)
    procedure AddJSONEscape(const V: TVarRec); overload;





    /// encode the supplied data as an UTF-8 valid JSON object content
    // - data must be supplied two by two, as Name,Value pairs, e.g.
    // ! aWriter.AddJSONEscape(['name','John','year',1972]);
    // will append to the buffer:
    // ! '{"name":"John","year":1972}'
    // - or you can specify nested arrays or objects with '['..']' or '{'..'}':
    // ! aWriter.AddJSONEscape(['doc','{','name','John','ab','[','a','b']','}','id',123]);
................................................................................
    // ! new Date()   ObjectId()   MinKey   MaxKey  /<jRegex>/<jOptions>
    // see @http://docs.mongodb.org/manual/reference/mongodb-extended-json
    // !  aWriter.AddJSON('{name:?,field:/%/i}',['acme.*corp'],['John']))
    // ! // will write
    // ! '{"name":"John","field":{"$regex":"acme.*corp","$options":"i"}}'
    // - will call internally _JSONFastFmt() to create a temporary TDocVariant
    // with all its features - so is slightly slower than other AddJSON* methods
    procedure AddJSON(Format: PUTF8Char; const Args,Params: array of const);
{$endif}
    /// append a dynamic array content as UTF-8 encoded JSON array
    // - expect a dynamic array TDynArray wrapper as incoming parameter
    // - TIntegerDynArray, TInt64DynArray, TCardinalDynArray, TDoubleDynArray,
    // TCurrencyDynArray, TWordDynArray and TByteDynArray will be written as
    // numerical JSON values
    // - TRawUTF8DynArray, TWinAnsiDynArray, TRawByteStringDynArray,
................................................................................
// ! new Date()   ObjectId()   MinKey   MaxKey  /<jRegex>/<jOptions>
// see @http://docs.mongodb.org/manual/reference/mongodb-extended-json
// !  aJSON := JSONEncode('{name:?,field:/%/i}',['acme.*corp'],['John']))
// ! // will return
// ! '{"name":"John","field":{"$regex":"acme.*corp","$options":"i"}}'
// - will call internally _JSONFastFmt() to create a temporary TDocVariant with
// all its features - so is slightly slower than other JSONEncode* functions
function JSONEncode(Format: PUTF8Char; const Args,Params: array of const): RawUTF8; overload;
{$endif}

/// encode the supplied RawUTF8 array data as an UTF-8 valid JSON array content
function JSONEncodeArray(const Values: array of RawUTF8): RawUTF8; overload;

/// encode the supplied integer array data as a valid JSON array
function JSONEncodeArray(const Values: array of integer): RawUTF8; overload;
................................................................................
  ESynException = class(Exception)
  public
    /// constructor which will use FormatUTF8() instead of Format()
    // - expect % as delimitor, so is less error prone than %s %d %g
    // - will handle vtPointer/vtClass/vtObject/vtVariant kind of arguments,
    // appending class name for any class or object, the hexa value for a
    // pointer, or the JSON representation of the supplied variant
    constructor CreateUTF8(Format: PUTF8Char; const Args: array of const);
    {$ifndef NOEXCEPTIONINTERCEPT}
    /// can be used to customize how the exception is logged
    // - this default implementation will call the DefaultSynLogExceptionToStr()
    // function or the TSynLogExceptionToStrCustom global callback, if defined
    // - override this method to provide a custom logging content
    // - should return TRUE if Context.EAddr and Stack trace is not to be
    // written (i.e. as for any TSynLogExceptionToStr callback)
................................................................................
function SearchFieldIndex(var Indexes: TSQLFieldIndexDynArray; Field: integer): integer;

/// convert an array of field indexes into a TSQLFieldBits set of bits
function FieldIndexToBits(const Index: TSQLFieldIndexDynArray): TSQLFieldBits; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// name the current thread so that it would be easily identified in the IDE debugger
procedure SetCurrentThreadName(Format: PUTF8Char; const Args: array of const);

/// name a thread so that it would be easily identified in the IDE debugger
// - you can force this function to do nothing by setting the NOSETTHREADNAME
// conditional, if you have issues with this feature when debugging your app
procedure SetThreadName(ThreadID: cardinal; Format: PUTF8Char; const Args: array of const);

type
  TSynBackgroundThreadAbstract = class;
  TSynBackgroundThreadEvent = class;

  /// idle method called by TSynBackgroundThreadAbstract in the caller thread
  // during remote blocking process in a background thread
................................................................................
// ! assert(u='{"type":{"$in":["food","snack"]}}');
// ! u := VariantSaveMongoJSON(aVariant,modMongoShell);
// ! assert(u='{type:{$in:["food","snack"]}}');
// - by default, every internal value will be copied, so access of nested
// properties can be slow - if you expect the data to be read-only or not
// propagated into another place, add dvoValueCopiedByReference in Options
// will increase the process speed a lot, or use _JsonFast()
function _JsonFmt(Format: PUTF8Char; const Args,Params: array of const;
  Options: TDocVariantOptions=[dvoReturnNullForUnknownProperty]): variant;

/// initialize a variant instance to store some document-based content
// from a supplied (extended) JSON content
// - this global function is an alias to TDocVariant.NewJSON(), and
// will return TRUE if JSON content was correctly converted into a variant
// - in addition to the JSON RFC specification strict mode, this method will
................................................................................
// from a supplied (extended) JSON content, with parameters formating
// - this global function is an handy alias e.g. to:
// ! aVariant := _JSONFmt('{%:{$in:[?,?]}}',['type'],['food','snack'],JSON_OPTIONS[true]);
// - so all created objects and arrays will be handled by reference, for best
// speed - but you should better write on the resulting variant tree with caution
// - in addition to the JSON RFC specification strict mode, this method will
// handle some BSON-like extensions, e.g. unquoted field names or ObjectID():
function _JsonFastFmt(Format: PUTF8Char; const Args,Params: array of const): variant;

/// ensure a document-based variant instance will have only per-value nested
// objects or array documents
// - is just a wrapper around:
// ! TDocVariantData(DocVariant).InitCopy(DocVariant,JSON_OPTIONS[false])
// - you can use this function to ensure that all internal properties of this
// variant will be copied per-value whatever options the nested objects or
................................................................................
begin
  case V.VType of
    vtChar:     result := ord(V.VChar);
    vtWideChar: result := ord(V.VWideChar);
    else        result := 0;
  end;
end;














procedure VarRecToUTF8(const V: TVarRec; var result: RawUTF8; wasString: PBoolean=nil);
var isString: boolean;
begin
  isString := not (V.VType in [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended]);
  with V do
  case V.VType of
................................................................................
  DigitChars = ['-','+','0'..'9'];
  DigitFirstChars = ['-','1'..'9']; // 0/- excluded by JSON!
  DigitFloatChars = ['-','+','0'..'9','.','E','e'];


function SQLParamContent(P: PUTF8Char; out ParamType: TSQLParamType; out ParamValue: RawUTF8;
  out wasNull: boolean): PUTF8Char;
var PDeb: PAnsiChar;
    L: integer;
    c: cardinal;
begin
  ParamType := sptUnknown;
  wasNull := false;
  result := nil;
  if P=nil then
................................................................................
        ParamValue := copy(ParamValue,4,L); // return ISO-8601 text
        ParamType := sptDateTime;           // identified as Date/Time
      end;
    end;
  end;
  '-','+','0'..'9': begin // allow 0 or + in SQL
    // check if P^ is a true numerical value
    PDeb := pointer(P);
    ParamType := sptInteger;
    repeat inc(P) until not (P^ in ['0'..'9']); // check digits
    if P^='.' then begin
      inc(P);
      if P^ in ['0'..'9'] then begin
        ParamType := sptFloat;
        repeat inc(P) until not (P^ in ['0'..'9']); // check fractional digits
................................................................................
    if byte(P^) and $DF=ord('E') then begin
      ParamType := sptFloat;
      inc(P);
      if P^='+' then inc(P) else
      if P^='-' then inc(P);
      while P^ in ['0'..'9'] do inc(P);
    end;
    SetRawUTF8(ParamValue,PDeb,P-PDeb);
  end;
  'n':
  if PInteger(P)^=NULL_LOW then begin
    inc(P,4);
    wasNull := true;
  end else
    exit; // invalid content (only :(null): expected)
................................................................................
var tmp: ShortString;
begin
  if Value=0 then
    result := '0' else
    SetString(result,PAnsiChar(@tmp[1]),ExtendedToString(tmp,Value,DOUBLE_PRECISION));
end;

function FormatUTF8(Format: PUTF8Char; const Args: array of const): RawUTF8;
// only supported token is %, with any const arguments
var i, blocksN, L, argN: PtrInt;
    blocks: array of record
      Text: PUTF8Char;
      Len: integer;
    end;
    Arg: TRawUTF8DynArray;
    PDeb: PUTF8Char;
procedure Add(aText: PUTF8Char; aLen: Integer);
begin
  if aLen>0 then begin
    inc(L,aLen);
    assert(blocksN<length(blocks));
    with blocks[blocksN] do begin // add inbetween text
      Text := aText;
      Len := aLen;
    end;
    inc(blocksN);
  end;
end;
begin
  if (Format=nil) or (high(Args)<0) then begin
    result := Format; // no formatting to process
    exit;
  end;
  if PWord(Format)^=ord('%') then begin
    VarRecToUTF8(Args[0],result); // optimize raw conversion
    exit;
  end;
  result := '';
  SetLength(Arg,length(Args));
  SetLength(blocks,length(Args)*2+1);
  blocksN := 0;
  argN := 0;
  L := 0;

  while Format^<>#0 do begin
    if Format^<>'%' then begin
      PDeb := Format;
      while (Format^<>'%') and (Format^<>#0) do inc(Format);
      Add(PDeb,Format-PDeb);

    end;
    if Format^=#0 then break;
    inc(Format); // jump '%'
    if argN<=high(Args) then begin
      VarRecToUTF8(Args[argN],arg[argN]);
      Add(pointer(arg[argN]),length(arg[argN]));
      Inc(argN);
    end else
    if Format^<>#0 then begin // no more available Args -> add all remaining text
      Add(Format,StrLen(Format));
      break;
    end;
  end;
  if L=0 then
    exit;
  SetLength(result,L);
  Format := pointer(result);
  for i := 0 to blocksN-1 do
  with blocks[i] do begin
    move(Text^,Format^,Len);
    inc(Format,Len);
  end;
end;

function FormatUTF8(Format: PUTF8Char; const Args, Params: array of const; JSONFormat: boolean): RawUTF8; overload;
// support both % and ? tokens
var i, tmpN, L, A, P, len: PtrInt;
    isParam: AnsiChar;
    tmp: TRawUTF8DynArray; 
    inlin: set of 0..255; 
    PDeb: PUTF8Char;
    wasString: Boolean;
const QUOTECHAR: array[boolean] of AnsiChar = ('''','"');
      NOTTOQUOTE: array[boolean] of set of 0..31 = (
        [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended],
        [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended,vtVariant]);
label Txt;
begin
  if (Format='') or ((high(Args)<0)and(high(Params)<0)) then begin
    result := Format; // no formatting to process
    exit;




  end;
  result := '';
  tmpN := 0;
  FillChar(inlin,SizeOf(inlin),0);
  L := 0;
  A := 0;
  P := 0;

  while Format^<>#0 do begin
    if Format^<>'%' then begin
      PDeb := Format;
      while not (Format^ in [#0,'%','?']) do inc(Format);
Txt:  len := Format-PDeb;
      if len>0 then begin
        inc(L,len);
        if tmpN=length(tmp) then
          SetLength(tmp,tmpN+8);
        SetString(tmp[tmpN],PDeb,len); // add inbetween text
        inc(tmpN);
      end;
    end;
    if Format^=#0 then
      break;
    isParam := Format^;
    inc(Format); // jump '%' or '?'
    if (isParam='%') and (A<=high(Args)) then begin // handle % substitution
      if tmpN=length(tmp) then
        SetLength(tmp,tmpN+8);
      VarRecToUTF8(Args[A],tmp[tmpN]);
      inc(A);
      if tmp[tmpN]<>'' then begin
        inc(L,length(tmp[tmpN]));
................................................................................
          include(inlin,tmpN);
        end;
      end;
      inc(P);
      inc(L,length(tmp[tmpN]));
      inc(tmpN);
    end else
    if Format^<>#0 then begin // no more available Args -> add all remaining text
      PDeb := Format;
      repeat inc(Format) until (Format^=#0);
      goto Txt;
    end;
  end;
  if L=0 then
    exit;
  if (not JSONFormat) and (tmpN>SizeOf(inlin)shl 3) then
    raise ESynException.CreateUTF8(
      'Too many parameters for FormatUTF8(): %>%',[tmpN,SizeOf(inlin)shl 3]);
  SetLength(result,L);
  Format := pointer(result);
  for i := 0 to tmpN-1 do
  if tmp[i]<>'' then begin
    if i in inlin then begin
      PWord(Format)^ := ord(':')+ord('(')shl 8;
      inc(Format,2);
    end;
    L := PInteger(PtrInt(tmp[i])-sizeof(integer))^;
    move(pointer(tmp[i])^,Format^,L);
    inc(Format,L);
    if i in inlin then begin
      PWord(Format)^ := ord(')')+ord(':')shl 8;
      inc(Format,2);
    end;
  end;
end;

function RawByteStringArrayConcat(const Values: array of RawByteString): RawByteString;
var i, L: integer;
    P: PAnsiChar;
................................................................................
@z: pop edx       // ignore source var, result := false
end;
{$endif}

/// find the Value of UpperName in P, till end of current section
// - expect UpperName as 'NAME='
function FindIniNameValue(P: PUTF8Char; UpperName: PAnsiChar): RawUTF8;
var PDeb: PUTF8Char;
    L: integer;
begin
  while (P<>nil) and (P^<>'[') do begin
    PDeb := GetNextLineBegin(P,P); // since PDeb=P, we have PDeb<>nil
    if PDeb^=' ' then repeat inc(PDeb) until PDeb^<>' ';   // trim left ' '
    if IdemPChar(PDeb,UpperName) then begin
      inc(PDeb,StrLen(PUTF8Char(UpperName)));
      L := 0; while PDeb[L]>=' ' do inc(L); // get line length
      SetString(result,PDeb,L);
      exit;
    end;
  end;
  result := '';
end;

function ExistsIniName(P: PUTF8Char; UpperName: PAnsiChar): boolean;
var PDeb: PUTF8Char;
begin
  result := true;
  while (P<>nil) and (P^<>'[') do begin
    PDeb := GetNextLineBegin(P,P); // since PDeb=P, we have PDeb<>nil
    if PDeb^=' ' then repeat inc(PDeb) until PDeb^<>' ';   // trim left ' '
    if IdemPChar(PDeb,UpperName) then
      exit;
  end;
  result := false;
end;

function ExistsIniNameValue(P: PUTF8Char; const UpperName: RawUTF8;
  const UpperValues: array of RawUTF8): boolean;
var PDeb: PUTF8Char;
    i: integer;
begin
  result := true;
  if high(UpperValues)>=0 then
    while (P<>nil) and (P^<>'[') do begin
      PDeb := GetNextLineBegin(P,P); // since PDeb=P, we have PDeb<>nil
      if PDeb^=' ' then repeat inc(PDeb) until PDeb^<>' ';   // trim left ' '
      if IdemPChar(PDeb,pointer(UpperName)) then begin
        inc(PDeb,length(UpperName));
        for i := 0 to high(UpperValues) do
          if IdemPChar(PDeb,pointer(UpperValues[i])) then
            exit; // found one value
        break;
      end;
    end;
  result := false;
end;

function FindWinAnsiIniNameValue(P: PUTF8Char; UpperName: PAnsiChar): RawUTF8;
begin
  result := WinAnsiToUtf8(RawByteString(FindIniNameValue(P,UpperName)));
end;

function GetSectionContent(SectionFirstLine: PUTF8Char): RawUTF8;
var PDeb: PUTF8Char;
begin
  PDeb := SectionFirstLine;
  while (SectionFirstLine<>nil) and (SectionFirstLine^<>'[') do
    GetNextLineBegin(SectionFirstLine,SectionFirstLine);
  if SectionFirstLine=nil then
    result := PDeb else
    SetString(result,PDeb,SectionFirstLine-PDeb);
end;

function GetSectionContent(const Content, SectionName: RawUTF8): RawUTF8; overload;
var P: PUTF8Char;
    UpperSection: array[byte] of AnsiChar;
begin
  P := pointer(Content);
................................................................................
    result := '' else
    result := FindIniEntry(Content,Section,Name);
end;

procedure UpdateIniEntry(var Content: RawUTF8; const Section,Name,Value: RawUTF8);
const CRLF = #13#10;
var P: PUTF8Char;
    PDeb: PUTF8Char;
    SectionFound: boolean;
    i, UpperNameLength: PtrInt;
    V: RawUTF8;
    UpperSection, UpperName: array[byte] of AnsiChar;
    // possible GPF if length(Section/Name)>255, but should be short const in code
label Sec;
begin
................................................................................
  if Section='' then
    goto Sec; // find the Name= entry before any [Section]
  SectionFound := false;
  PWord(UpperCopy255(UpperSection,Section))^ := ord(']');
  if FindSectionFirstLine(P,UpperSection) then begin 
Sec:SectionFound := true;
    while (P<>nil) and (P^<>'[') do begin
      PDeb := GetNextLineBegin(P,P); // since PDeb=P, we have PDeb<>nil
      while PDeb^=' ' do inc(PDeb);   // trim left ' '
      if IdemPChar(PDeb,UpperName) then begin
        // update Name=Value entry
        inc(PDeb,UpperNameLength);
        i := (PDeb-pointer(Content))+1;
        if (i=length(Value)) and CompareMem(PDeb,pointer(Value),i) then
          exit; // new Value is identical to the old one -> no change
        if P=nil then // avoid last line (P-PDeb) calculation error
          SetLength(Content,i-1) else
          delete(Content,i,P-PDeb); // delete old Value
        insert(V,Content,i); // set new value
        exit;
      end;
    end;
    // we reached next [Section] without having found Name=
   end;
  // 2. section or Name= entry not found: add Name=Value
................................................................................
  if source^=#10 then inc(source);
  if source^=#0 then
    next := nil else
    next := source;
end;

function FindIniNameValueW(P: PWideChar; UpperName: PUTF8Char): string;
var PDeb: PWideChar;
    L: PtrInt;
begin
  while (P<>nil) and (P^<>'[') do begin
    PDeb := P;
    while not (cardinal(P^) in [0,10,13]) do inc(P);
    while cardinal(P^) in [10,13] do inc(P);
    if P^=#0 then P := nil;
    if PDeb^=' ' then repeat inc(PDeb) until PDeb^<>' ';   // trim left ' '
    if IdemPCharW(PDeb,UpperName) then begin
      inc(PDeb,StrLen(UpperName));
      L := 0; while PDeb[L]>=' ' do inc(L); // get line length
      SetString(result,PDeb,L);
      exit;
    end;
  end;
  result := '';
end;

function FindIniEntryW(const Content: string; const Section, Name: RawUTF8): string;
................................................................................
end;

function _JsonFast(const JSON: RawUTF8): variant;
begin
  _Json(JSON,result,JSON_OPTIONS[true]);
end;

function _JsonFmt(Format: PUTF8Char; const Args,Params: array of const;
  Options: TDocVariantOptions): variant;
begin
  _Json(FormatUTF8(Format,Args,Params,true),result,Options);
end;

function _JsonFastFmt(Format: PUTF8Char; const Args,Params: array of const): variant;
begin
  _Json(FormatUTF8(Format,Args,Params,true),result,JSON_OPTIONS[true]);
end;

function _Json(const JSON: RawUTF8; var Value: variant;
  Options: TDocVariantOptions): boolean;
begin
................................................................................
  end;
  assert(ndx=Count-1);
  result := PAnsiChar(fValue^)+cardinal(ndx)*ElemSize;
  PRawUTF8(result)^ := aName; // store unique name at 1st elem position
end;

function TDynArrayHashed.AddUniqueName(const aName: RawUTF8;
  ExceptionMsg: PUTF8Char; const ExceptionArgs: array of const): pointer;
var ndx: integer;
    added: boolean;
begin
  ndx := FindHashedForAdding(aName,added);
  if added then begin
    assert(ndx=Count-1);
    result := PAnsiChar(fValue^)+cardinal(ndx)*ElemSize;
    PRawUTF8(result)^ := aName; // store unique name at 1st elem position
  end else
    if ExceptionMsg=nil then
      raise ESynException.CreateUTF8('Duplicated "%" name',[aName]) else
      raise ESynException.CreateUTF8(ExceptionMsg,ExceptionArgs);
end;

function TDynArrayHashed.FindHashedAndFill(var Elem): integer;
var P: PAnsiChar;
begin
................................................................................
    end;
    end;
  CancelLastComma;
  Add(']');
end;

{$ifndef DELPHI5OROLDER}
procedure TTextWriter.Add(Format: PWinAnsiChar; const Values: array of const;
  Escape: TTextWriterKind=twNone);
var ValuesIndex: integer;

label write;
begin // we put const char > #127 as #??? -> asiatic MBCS codepage OK
  if Format=nil then
    exit;




  ValuesIndex := 0;

  repeat
    repeat
      case ord(Format^) of
      0: exit;
      13: AddCR;
      ord('%'): break;
      {$ifdef OLDTEXTWRITERFORMAT}
      164: AddCR; // � -> add CR,LF
      167: if B^=',' then dec(B); // �
      ord('|'): begin
        inc(Format); // |% -> %
        goto write;
      end;
      ord('$'),163,181: // $,�,�
        break; // process command value
      {$endif}
      else begin
write:  if B>=BEnd then
          Flush;
        B[1] := Format^;
        inc(B);
      end;
      end;
      inc(Format);
    until false;
    // add next value as text
    if ValuesIndex<=high(Values) then // missing value will display nothing
    case ord(Format^) of
    ord('%'):
       with Values[ValuesIndex] do
       case Vtype of
         vtInteger:      Add(VInteger);
         vtBoolean:      AddU(byte(VBoolean));
         vtChar:         Add(@VChar,1,Escape);
         vtExtended:     Add(VExtended^);
         vtString:       Add(@VString^[1],ord(VString^[0]),Escape);
         vtPointer:      AddPointer(PtrUInt(VPointer));
         vtPChar:        Add(PUTF8Char(VPChar),Escape);
         vtObject:       WriteObject(VObject,[woFullExpand]);
         vtClass:
           if VClass<>nil then
             AddShort(PShortString(PPointer(PtrInt(VClass)+vmtClassName)^)^);
         vtWideChar:
           AddW(@VWideChar,1,Escape);
         vtPWideChar:
           AddW(pointer(VPWideChar),StrLenW(VPWideChar),Escape);
         vtAnsiString:
           Add(VAnsiString,Escape); // expect RawUTF8
         vtCurrency:
           AddCurr64(VInt64^);
         vtWideString:
           if VWideString<>nil then
             AddW(VWideString,length(WideString(VWideString)),Escape);
         vtInt64:
           Add(VInt64^);
{$ifndef NOVARIANTS}
         vtVariant:
           AddVariantJSON(VVariant^,Escape);
{$endif}
{$ifdef UNICODE}
         vtUnicodeString:
           if VUnicodeString<>nil then // convert to UTF-8
             AddW(VUnicodeString,length(UnicodeString(VUnicodeString)),Escape);
{$endif} end;
    {$ifdef OLDTEXTWRITERFORMAT}
    ord('$'): with Values[ValuesIndex] do
           if Vtype=vtInteger then Add2(VInteger);
    163: with Values[ValuesIndex] do // �
           if Vtype=vtInteger then Add4(VInteger);
    181: with Values[ValuesIndex] do // �
           if Vtype=vtInteger then Add3(VInteger);
    {$endif}
    end;
    inc(Format);
    inc(ValuesIndex);
  until false;
end;
{$endif}

procedure TTextWriter.AddLine(const Text: shortstring);
begin
................................................................................
    vtExtended: Add(VExtended^);
    vtCurrency: AddCurr64(VInt64^);
    {$ifndef NOVARIANTS}
    vtVariant:  AddVariantJSON(VVariant^,twJSONEscape);
    {$endif}
  end;
end;





























{$ifndef NOVARIANTS}











procedure TTextWriter.AddJSON(Format: PUTF8Char; const Args,Params: array of const);
begin
  AddVariantJSON(_JsonFastFmt(Format,Args,Params),twJSONEscape);
end;
{$endif}

procedure TTextWriter.AddJSONEscape(const NameValuePairs: array of const);
var a: integer;
................................................................................
      SetText(result);
    finally
      Free
    end;
end;

{$ifndef NOVARIANTS}
function JSONEncode(Format: PUTF8Char; const Args,Params: array of const): RawUTF8; overload;
begin
  with DefaultTextWriterJSONClass.CreateOwnedStream do
  try
    AddJSON(Format,Args,Params);
    SetText(result);
  finally
    Free
................................................................................
    Map.UnMap;
  end;
end;

procedure TRawUTF8List.SetTextPtr(P: PUTF8Char; const Delimiter: RawUTF8);
var DelimLen: PtrInt;
    DelimFirst: AnsiChar;
    PDeb, DelimNext: PUTF8Char;
    Line: RawUTF8;
begin
  DelimLen := length(Delimiter);
  BeginUpdate;
  Clear;
  if (P<>nil) and (DelimLen>0) then begin
    DelimFirst := Delimiter[1];
    DelimNext := PUTF8Char(pointer(Delimiter))+1;
    repeat
      PDeb := P;
      while P^<>#0 do begin
        if (P^=DelimFirst) and CompareMem(P+1,DelimNext,DelimLen-1) then
          break;
        inc(P);
      end;
      SetString(Line,PDeb,P-PDeb);
      AddObject(Line,nil);
      if P^=#0 then
        break;
      inc(P,DelimLen);
    until P^=#0;
  end;
  EndUpdate;
................................................................................
begin
  SynLZDecompress(pointer(Data),length(Data),result);
end;


{ ESynException }

constructor ESynException.CreateUTF8(Format: PUTF8Char; const Args: array of const);
begin
  Create(UTF8ToString(FormatUTF8(Format,Args)));
end;

{$ifndef NOEXCEPTIONINTERCEPT}
function ESynException.CustomLog(WR: TTextWriter;
  const Context: TSynLogExceptionContext): boolean;
................................................................................

{ TSynBackgroundThreadAbstract }

{$ifdef MSWINDOWS}
function IsDebuggerPresent: BOOL; stdcall; external kernel32; // since XP
{$endif}

procedure SetCurrentThreadName(Format: PUTF8Char; const Args: array of const);
begin
  SetThreadName(GetCurrentThreadId,Format,Args);
end;

procedure SetThreadName(ThreadID: cardinal; Format: PUTF8Char; const Args: array of const);

var name: RawByteString;
{$ifndef ISDELPHIXE2}
{$ifdef MSWINDOWS}
    info: record
      FType: LongWord;     // must be 0x1000
      FName: PAnsiChar;    // pointer to name (in user address space)
      FThreadID: LongWord; // thread ID (-1 indicates caller thread)

  - BREAKING CHANGE of TTextWriter.WriteObject() method: serialization is now
    defined with a new TTextWriterWriteObjectOptions set
  - BREAKING CHANGE rename of Iso8601 low-level structure as TTimeLogBits, to use
    explicitly the TTimeLog type and name for all Int64 bit-oriented functions -
    now "Iso8601" naming will be only for standard ISO-8601 text, not Int64 value
  - BREAKING CHANGE: TTextWriter.Add(Format) won't handle the alternate $ % tags
    any more, unless you define the OLDTEXTWRITERFORMAT conditional
  - BREAKING CHANGE: FormatUTF8() and TTextWriter.Add(Format) PUTF8Char type for
    constant text parameter has been changed into RawUTF8, to let the compiler
    handle any Unicode content as expected
  - Delphi XE4/XE5/XE6/XE7/XE8 compatibility (Win32/Win64 target platform only
    for the SynCommons and mORMot* units, but see SynCrossPlatform* units for
    clients on all other targets, including OSX and the NextGen compilers)
  - unit fixed and tested with Delphi XE2 (and up) 64-bit compiler under Windows
  - now all variants created within our units will create string instances of
    kind varString and type RawUTF8 - prior to Delphi 2009, ensure you call
    UTF8ToString(aVariant) if you want to use the value with the VCL
................................................................................
/// fast Format() function replacement, optimized for RawUTF8
// - only supported token is %, which will be inlined in the resulting string
// according to each Args[] supplied item
// - resulting string has no length limit and uses fast concatenation
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
function FormatUTF8(const Format: RawUTF8; const Args: array of const): RawUTF8; overload;

/// fast Format() function replacement, handling % and ? parameters
// - will include Args[] for every % in Format
// - will inline Params[] for every ? in Format, handling special "inlined"
// parameters, as exected by mORMot.pas unit, i.e. :(1234): for numerical
// values, and :('quoted '' string'): for textual values
// - if optional JSONFormat parameter is TRUE, ? parameters will be written
// as JSON quoted strings, without :(...): tokens, e.g. "quoted "" string"
// - resulting string has no length limit and uses fast concatenation
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
function FormatUTF8(const Format: RawUTF8; const Args, Params: array of const;
  JSONFormat: boolean=false): RawUTF8; overload;

/// convert an open array (const Args: array of const) argument to an UTF-8
// encoded text
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
procedure VarRecToUTF8(const V: TVarRec; var result: RawUTF8;
  wasString: PBoolean=nil);

/// convert an open array (const Args: array of const) argument to an Int64
// - returns TRUE and set Value if the supplied argument is a vtInteger or vtInt64
// - returns FALSE if the argument is not an integer 
function VarRecToInt64(const V: TVarRec; out value: Int64): boolean;

/// convert an open array (const Args: array of const) argument to a value
// encoded as with :(..:) inlined parameters in FormatUTF8(Format,Args,Params)
// - note that cardinal values should be type-casted to Int64() (otherwise
// the integer mapped value will be transmitted, therefore wrongly)
// - any supplied TObject instance will be written as their class name
procedure VarRecToInlineValue(const V: TVarRec; var result: RawUTF8);
................................................................................
    // - expected element layout is to have a RawUTF8 field at first position
    // - the aName is searched (using hashing) to be unique, and if not the case,
    // an ESynException.CreateUTF8() is raised with the supplied arguments 
    // - use internaly FindHashedForAdding method
    // - this version will set the field content with the unique value
    // - returns a pointer to the newly added element (to set other fields)
    function AddUniqueName(const aName: RawUTF8;
      const ExceptionMsg: RawUTF8; const ExceptionArgs: array of const): pointer;
    /// search for a given element name, make it unique, and add it to the array
    // - expected element layout is to have a RawUTF8 field at first position
    // - the aName is searched (using hashing) to be unique, and if not the case,
    // some suffix is added to make it unique
    // - use internaly FindHashedForAdding method
    // - this version will set the field content with the unique value
    // - returns a pointer to the newly added element (to set other fields)
................................................................................
    // - CR = #13 indicates CR+LF chars
    // - � = #167 indicates to trim last comma
    // - | = #124 will write the next char e.g. Add('%|$',[10]) will write '10$'
    // - since some of this characters above are > #127, they are not UTF-8
    // ready, so we expect the input format to be WinAnsi, i.e. mostly English
    // text (with chars < #128) with some values to be inserted inside
    {$endif}
    procedure Add(const Format: RawUTF8; const Values: array of const;
      Escape: TTextWriterKind=twNone); overload;
{$endif DELPHI5OROLDER}
    /// append some values at once
    // - text values (e.g. RawUTF8) will be escaped as JSON
    procedure Add(const Values: array of const); overload;
    /// append CR+LF (#13#10) chars
    // - this method won't call EchoAdd() registered events - use AddEndOfLine()
................................................................................
    // versions of Delphi will retrieve the code page from string
    // - if CodePage is defined to a >= 0 value, the encoding will take place
    procedure AddAnyAnsiString(const s: RawByteString; Escape: TTextWriterKind;
      CodePage: Integer=-1);
    /// append some chars to the buffer
    // - if Len is 0, Len is calculated from zero-ended char
    // - don't escapes chars according to the JSON RFC
    procedure AddNoJSONEscape(P: Pointer; Len: integer=0); overload;
    /// append some chars, quoting all " chars
    // - same algorithm than AddString(QuotedStr()) - without memory allocation
    // - this function implements what is specified in the official SQLite3
    // documentation: "A string constant is formed by enclosing the string in single
    // quotes ('). A single quote within the string can be encoded by putting two
    // single quotes in a row - as in Pascal."
    procedure AddQuotedStr(Text: PUTF8Char; Quote: AnsiChar; TextLen: integer=0); 
................................................................................
    // - escapes chars according to the JSON RFC
    procedure AddJSONEscapeW(P: PWord; Len: PtrInt=0);
    /// append an open array constant value to the buffer
    // - "" will be added if necessary
    // - escapes chars according to the JSON RFC
    // - very fast (avoid most temporary storage)
    procedure AddJSONEscape(const V: TVarRec); overload;
    /// append an open array constant value to the buffer
    // - "" won't be added for string values
    // - string values may be escaped, depending on the supplied parameter
    // - very fast (avoid most temporary storage)
    procedure Add(const V: TVarRec; Escape: TTextWriterKind=twNone); overload;
    /// encode the supplied data as an UTF-8 valid JSON object content
    // - data must be supplied two by two, as Name,Value pairs, e.g.
    // ! aWriter.AddJSONEscape(['name','John','year',1972]);
    // will append to the buffer:
    // ! '{"name":"John","year":1972}'
    // - or you can specify nested arrays or objects with '['..']' or '{'..'}':
    // ! aWriter.AddJSONEscape(['doc','{','name','John','ab','[','a','b']','}','id',123]);
................................................................................
    // ! new Date()   ObjectId()   MinKey   MaxKey  /<jRegex>/<jOptions>
    // see @http://docs.mongodb.org/manual/reference/mongodb-extended-json
    // !  aWriter.AddJSON('{name:?,field:/%/i}',['acme.*corp'],['John']))
    // ! // will write
    // ! '{"name":"John","field":{"$regex":"acme.*corp","$options":"i"}}'
    // - will call internally _JSONFastFmt() to create a temporary TDocVariant
    // with all its features - so is slightly slower than other AddJSON* methods
    procedure AddJSON(const Format: RawUTF8; const Args,Params: array of const);
{$endif}
    /// append a dynamic array content as UTF-8 encoded JSON array
    // - expect a dynamic array TDynArray wrapper as incoming parameter
    // - TIntegerDynArray, TInt64DynArray, TCardinalDynArray, TDoubleDynArray,
    // TCurrencyDynArray, TWordDynArray and TByteDynArray will be written as
    // numerical JSON values
    // - TRawUTF8DynArray, TWinAnsiDynArray, TRawByteStringDynArray,
................................................................................
// ! new Date()   ObjectId()   MinKey   MaxKey  /<jRegex>/<jOptions>
// see @http://docs.mongodb.org/manual/reference/mongodb-extended-json
// !  aJSON := JSONEncode('{name:?,field:/%/i}',['acme.*corp'],['John']))
// ! // will return
// ! '{"name":"John","field":{"$regex":"acme.*corp","$options":"i"}}'
// - will call internally _JSONFastFmt() to create a temporary TDocVariant with
// all its features - so is slightly slower than other JSONEncode* functions
function JSONEncode(const Format: RawUTF8; const Args,Params: array of const): RawUTF8; overload;
{$endif}

/// encode the supplied RawUTF8 array data as an UTF-8 valid JSON array content
function JSONEncodeArray(const Values: array of RawUTF8): RawUTF8; overload;

/// encode the supplied integer array data as a valid JSON array
function JSONEncodeArray(const Values: array of integer): RawUTF8; overload;
................................................................................
  ESynException = class(Exception)
  public
    /// constructor which will use FormatUTF8() instead of Format()
    // - expect % as delimitor, so is less error prone than %s %d %g
    // - will handle vtPointer/vtClass/vtObject/vtVariant kind of arguments,
    // appending class name for any class or object, the hexa value for a
    // pointer, or the JSON representation of the supplied variant
    constructor CreateUTF8(const Format: RawUTF8; const Args: array of const);
    {$ifndef NOEXCEPTIONINTERCEPT}
    /// can be used to customize how the exception is logged
    // - this default implementation will call the DefaultSynLogExceptionToStr()
    // function or the TSynLogExceptionToStrCustom global callback, if defined
    // - override this method to provide a custom logging content
    // - should return TRUE if Context.EAddr and Stack trace is not to be
    // written (i.e. as for any TSynLogExceptionToStr callback)
................................................................................
function SearchFieldIndex(var Indexes: TSQLFieldIndexDynArray; Field: integer): integer;

/// convert an array of field indexes into a TSQLFieldBits set of bits
function FieldIndexToBits(const Index: TSQLFieldIndexDynArray): TSQLFieldBits; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// name the current thread so that it would be easily identified in the IDE debugger
procedure SetCurrentThreadName(const Format: RawUTF8; const Args: array of const);

/// name a thread so that it would be easily identified in the IDE debugger
// - you can force this function to do nothing by setting the NOSETTHREADNAME
// conditional, if you have issues with this feature when debugging your app
procedure SetThreadName(ThreadID: cardinal; const Format: RawUTF8; const Args: array of const);

type
  TSynBackgroundThreadAbstract = class;
  TSynBackgroundThreadEvent = class;

  /// idle method called by TSynBackgroundThreadAbstract in the caller thread
  // during remote blocking process in a background thread
................................................................................
// ! assert(u='{"type":{"$in":["food","snack"]}}');
// ! u := VariantSaveMongoJSON(aVariant,modMongoShell);
// ! assert(u='{type:{$in:["food","snack"]}}');
// - by default, every internal value will be copied, so access of nested
// properties can be slow - if you expect the data to be read-only or not
// propagated into another place, add dvoValueCopiedByReference in Options
// will increase the process speed a lot, or use _JsonFast()
function _JsonFmt(const Format: RawUTF8; const Args,Params: array of const;
  Options: TDocVariantOptions=[dvoReturnNullForUnknownProperty]): variant;

/// initialize a variant instance to store some document-based content
// from a supplied (extended) JSON content
// - this global function is an alias to TDocVariant.NewJSON(), and
// will return TRUE if JSON content was correctly converted into a variant
// - in addition to the JSON RFC specification strict mode, this method will
................................................................................
// from a supplied (extended) JSON content, with parameters formating
// - this global function is an handy alias e.g. to:
// ! aVariant := _JSONFmt('{%:{$in:[?,?]}}',['type'],['food','snack'],JSON_OPTIONS[true]);
// - so all created objects and arrays will be handled by reference, for best
// speed - but you should better write on the resulting variant tree with caution
// - in addition to the JSON RFC specification strict mode, this method will
// handle some BSON-like extensions, e.g. unquoted field names or ObjectID():
function _JsonFastFmt(const Format: RawUTF8; const Args,Params: array of const): variant;

/// ensure a document-based variant instance will have only per-value nested
// objects or array documents
// - is just a wrapper around:
// ! TDocVariantData(DocVariant).InitCopy(DocVariant,JSON_OPTIONS[false])
// - you can use this function to ensure that all internal properties of this
// variant will be copied per-value whatever options the nested objects or
................................................................................
begin
  case V.VType of
    vtChar:     result := ord(V.VChar);
    vtWideChar: result := ord(V.VWideChar);
    else        result := 0;
  end;
end;

function VarRecToInt64(const V: TVarRec; out value: Int64): boolean;
begin
  case V.VType of
    vtInteger: value := V.VInteger;
    vtInt64:   value := V.VInt64^;
    else begin
      result := false;
      exit;
    end;
  end;
  result := true;
end;

procedure VarRecToUTF8(const V: TVarRec; var result: RawUTF8; wasString: PBoolean=nil);
var isString: boolean;
begin
  isString := not (V.VType in [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended]);
  with V do
  case V.VType of
................................................................................
  DigitChars = ['-','+','0'..'9'];
  DigitFirstChars = ['-','1'..'9']; // 0/- excluded by JSON!
  DigitFloatChars = ['-','+','0'..'9','.','E','e'];


function SQLParamContent(P: PUTF8Char; out ParamType: TSQLParamType; out ParamValue: RawUTF8;
  out wasNull: boolean): PUTF8Char;
var PBeg: PAnsiChar;
    L: integer;
    c: cardinal;
begin
  ParamType := sptUnknown;
  wasNull := false;
  result := nil;
  if P=nil then
................................................................................
        ParamValue := copy(ParamValue,4,L); // return ISO-8601 text
        ParamType := sptDateTime;           // identified as Date/Time
      end;
    end;
  end;
  '-','+','0'..'9': begin // allow 0 or + in SQL
    // check if P^ is a true numerical value
    PBeg := pointer(P);
    ParamType := sptInteger;
    repeat inc(P) until not (P^ in ['0'..'9']); // check digits
    if P^='.' then begin
      inc(P);
      if P^ in ['0'..'9'] then begin
        ParamType := sptFloat;
        repeat inc(P) until not (P^ in ['0'..'9']); // check fractional digits
................................................................................
    if byte(P^) and $DF=ord('E') then begin
      ParamType := sptFloat;
      inc(P);
      if P^='+' then inc(P) else
      if P^='-' then inc(P);
      while P^ in ['0'..'9'] do inc(P);
    end;
    SetRawUTF8(ParamValue,PBeg,P-PBeg);
  end;
  'n':
  if PInteger(P)^=NULL_LOW then begin
    inc(P,4);
    wasNull := true;
  end else
    exit; // invalid content (only :(null): expected)
................................................................................
var tmp: ShortString;
begin
  if Value=0 then
    result := '0' else
    SetString(result,PAnsiChar(@tmp[1]),ExtendedToString(tmp,Value,DOUBLE_PRECISION));
end;

function FormatUTF8(const Format: RawUTF8; const Args: array of const): RawUTF8;
// only supported token is %, with any const arguments
var i, blocksN, L, argN: PtrInt;
    blocks: array of record
      Text: PUTF8Char;
      Len: integer;
    end;
    Arg: TRawUTF8DynArray;
    F,FDeb: PUTF8Char;
procedure Add(aText: PUTF8Char; aLen: Integer);
begin
  if aLen>0 then begin
    inc(L,aLen);
    assert(blocksN<length(blocks));
    with blocks[blocksN] do begin // add inbetween text
      Text := aText;
      Len := aLen;
    end;
    inc(blocksN);
  end;
end;
begin
  if (Format='') or (high(Args)<0) then begin
    result := Format; // no formatting to process
    exit;
  end;
  if Format='%' then begin
    VarRecToUTF8(Args[0],result); // optimize raw conversion
    exit;
  end;
  result := '';
  SetLength(Arg,length(Args));
  SetLength(blocks,length(Args)*2+1);
  blocksN := 0;
  argN := 0;
  L := 0;
  F := pointer(Format);
  while F^<>#0 do begin
    if F^<>'%' then begin
      FDeb := F;

      while (F^<>'%') and (F^<>#0) do inc(F);
      Add(FDeb,F-FDeb);
    end;
    if F^=#0 then break;
    inc(F); // jump '%'
    if argN<=high(Args) then begin
      VarRecToUTF8(Args[argN],arg[argN]);
      Add(pointer(arg[argN]),length(arg[argN]));
      inc(argN);
    end else
    if F^<>#0 then begin // no more available Args -> add all remaining text
      Add(F,StrLen(F));
      break;
    end;
  end;
  if L=0 then
    exit;
  SetLength(result,L);
  F := pointer(result);
  for i := 0 to blocksN-1 do
  with blocks[i] do begin
    move(Text^,F^,Len);
    inc(F,Len);
  end;
end;

function FormatUTF8(const Format: RawUTF8; const Args, Params: array of const; JSONFormat: boolean): RawUTF8; overload;
// supports both % and ? tokens
var i, tmpN, L, A, P, len: PtrInt;
    isParam: AnsiChar;
    tmp: TRawUTF8DynArray; 
    inlin: set of 0..255; 
    F,FDeb: PUTF8Char;
    wasString: Boolean;
const QUOTECHAR: array[boolean] of AnsiChar = ('''','"');
      NOTTOQUOTE: array[boolean] of set of 0..31 = (
        [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended],
        [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended,vtVariant]);
label Txt;
begin
  if (Format='') or ((high(Args)<0)and(high(Params)<0)) then begin
    result := Format; // no formatting to process
    exit;
  end;
  if Format='%' then begin
    VarRecToUTF8(Args[0],result); // optimize raw conversion
    exit;
  end;
  result := '';
  tmpN := 0;
  FillChar(inlin,SizeOf(inlin),0);
  L := 0;
  A := 0;
  P := 0;
  F := pointer(Format);
  while F^<>#0 do begin
    if F^<>'%' then begin
      FDeb := F;
      while not (F^ in [#0,'%','?']) do inc(F);
Txt:  len := F-FDeb;
      if len>0 then begin
        inc(L,len);
        if tmpN=length(tmp) then
          SetLength(tmp,tmpN+8);
        SetString(tmp[tmpN],FDeb,len); // add inbetween text
        inc(tmpN);
      end;
    end;
    if F^=#0 then
      break;
    isParam := F^;
    inc(F); // jump '%' or '?'
    if (isParam='%') and (A<=high(Args)) then begin // handle % substitution
      if tmpN=length(tmp) then
        SetLength(tmp,tmpN+8);
      VarRecToUTF8(Args[A],tmp[tmpN]);
      inc(A);
      if tmp[tmpN]<>'' then begin
        inc(L,length(tmp[tmpN]));
................................................................................
          include(inlin,tmpN);
        end;
      end;
      inc(P);
      inc(L,length(tmp[tmpN]));
      inc(tmpN);
    end else
    if F^<>#0 then begin // no more available Args -> add all remaining text
      FDeb := F;
      repeat inc(F) until (F^=#0);
      goto Txt;
    end;
  end;
  if L=0 then
    exit;
  if (not JSONFormat) and (tmpN>SizeOf(inlin)shl 3) then
    raise ESynException.CreateUTF8(
      'Too many parameters for FormatUTF8(): %>%',[tmpN,SizeOf(inlin)shl 3]);
  SetLength(result,L);
  F := pointer(result);
  for i := 0 to tmpN-1 do
  if tmp[i]<>'' then begin
    if i in inlin then begin
      PWord(F)^ := ord(':')+ord('(')shl 8;
      inc(F,2);
    end;
    L := PInteger(PtrInt(tmp[i])-sizeof(integer))^;
    move(pointer(tmp[i])^,F^,L);
    inc(F,L);
    if i in inlin then begin
      PWord(F)^ := ord(')')+ord(':')shl 8;
      inc(F,2);
    end;
  end;
end;

function RawByteStringArrayConcat(const Values: array of RawByteString): RawByteString;
var i, L: integer;
    P: PAnsiChar;
................................................................................
@z: pop edx       // ignore source var, result := false
end;
{$endif}

/// find the Value of UpperName in P, till end of current section
// - expect UpperName as 'NAME='
function FindIniNameValue(P: PUTF8Char; UpperName: PAnsiChar): RawUTF8;
var PBeg: PUTF8Char;
    L: integer;
begin
  while (P<>nil) and (P^<>'[') do begin
    PBeg := GetNextLineBegin(P,P); // since PBeg=P, we have PBeg<>nil
    if PBeg^=' ' then repeat inc(PBeg) until PBeg^<>' ';   // trim left ' '
    if IdemPChar(PBeg,UpperName) then begin
      inc(PBeg,StrLen(PUTF8Char(UpperName)));
      L := 0; while PBeg[L]>=' ' do inc(L); // get line length
      SetString(result,PBeg,L);
      exit;
    end;
  end;
  result := '';
end;

function ExistsIniName(P: PUTF8Char; UpperName: PAnsiChar): boolean;
var PBeg: PUTF8Char;
begin
  result := true;
  while (P<>nil) and (P^<>'[') do begin
    PBeg := GetNextLineBegin(P,P); // since PBeg=P, we have PBeg<>nil
    if PBeg^=' ' then repeat inc(PBeg) until PBeg^<>' ';   // trim left ' '
    if IdemPChar(PBeg,UpperName) then
      exit;
  end;
  result := false;
end;

function ExistsIniNameValue(P: PUTF8Char; const UpperName: RawUTF8;
  const UpperValues: array of RawUTF8): boolean;
var PBeg: PUTF8Char;
    i: integer;
begin
  result := true;
  if high(UpperValues)>=0 then
    while (P<>nil) and (P^<>'[') do begin
      PBeg := GetNextLineBegin(P,P); // since PBeg=P, we have PBeg<>nil
      if PBeg^=' ' then repeat inc(PBeg) until PBeg^<>' ';   // trim left ' '
      if IdemPChar(PBeg,pointer(UpperName)) then begin
        inc(PBeg,length(UpperName));
        for i := 0 to high(UpperValues) do
          if IdemPChar(PBeg,pointer(UpperValues[i])) then
            exit; // found one value
        break;
      end;
    end;
  result := false;
end;

function FindWinAnsiIniNameValue(P: PUTF8Char; UpperName: PAnsiChar): RawUTF8;
begin
  result := WinAnsiToUtf8(RawByteString(FindIniNameValue(P,UpperName)));
end;

function GetSectionContent(SectionFirstLine: PUTF8Char): RawUTF8;
var PBeg: PUTF8Char;
begin
  PBeg := SectionFirstLine;
  while (SectionFirstLine<>nil) and (SectionFirstLine^<>'[') do
    GetNextLineBegin(SectionFirstLine,SectionFirstLine);
  if SectionFirstLine=nil then
    result := PBeg else
    SetString(result,PBeg,SectionFirstLine-PBeg);
end;

function GetSectionContent(const Content, SectionName: RawUTF8): RawUTF8; overload;
var P: PUTF8Char;
    UpperSection: array[byte] of AnsiChar;
begin
  P := pointer(Content);
................................................................................
    result := '' else
    result := FindIniEntry(Content,Section,Name);
end;

procedure UpdateIniEntry(var Content: RawUTF8; const Section,Name,Value: RawUTF8);
const CRLF = #13#10;
var P: PUTF8Char;
    PBeg: PUTF8Char;
    SectionFound: boolean;
    i, UpperNameLength: PtrInt;
    V: RawUTF8;
    UpperSection, UpperName: array[byte] of AnsiChar;
    // possible GPF if length(Section/Name)>255, but should be short const in code
label Sec;
begin
................................................................................
  if Section='' then
    goto Sec; // find the Name= entry before any [Section]
  SectionFound := false;
  PWord(UpperCopy255(UpperSection,Section))^ := ord(']');
  if FindSectionFirstLine(P,UpperSection) then begin 
Sec:SectionFound := true;
    while (P<>nil) and (P^<>'[') do begin
      PBeg := GetNextLineBegin(P,P); // since PBeg=P, we have PBeg<>nil
      while PBeg^=' ' do inc(PBeg);   // trim left ' '
      if IdemPChar(PBeg,UpperName) then begin
        // update Name=Value entry
        inc(PBeg,UpperNameLength);
        i := (PBeg-pointer(Content))+1;
        if (i=length(Value)) and CompareMem(PBeg,pointer(Value),i) then
          exit; // new Value is identical to the old one -> no change
        if P=nil then // avoid last line (P-PBeg) calculation error
          SetLength(Content,i-1) else
          delete(Content,i,P-PBeg); // delete old Value
        insert(V,Content,i); // set new value
        exit;
      end;
    end;
    // we reached next [Section] without having found Name=
   end;
  // 2. section or Name= entry not found: add Name=Value
................................................................................
  if source^=#10 then inc(source);
  if source^=#0 then
    next := nil else
    next := source;
end;

function FindIniNameValueW(P: PWideChar; UpperName: PUTF8Char): string;
var PBeg: PWideChar;
    L: PtrInt;
begin
  while (P<>nil) and (P^<>'[') do begin
    PBeg := P;
    while not (cardinal(P^) in [0,10,13]) do inc(P);
    while cardinal(P^) in [10,13] do inc(P);
    if P^=#0 then P := nil;
    if PBeg^=' ' then repeat inc(PBeg) until PBeg^<>' ';   // trim left ' '
    if IdemPCharW(PBeg,UpperName) then begin
      inc(PBeg,StrLen(UpperName));
      L := 0; while PBeg[L]>=' ' do inc(L); // get line length
      SetString(result,PBeg,L);
      exit;
    end;
  end;
  result := '';
end;

function FindIniEntryW(const Content: string; const Section, Name: RawUTF8): string;
................................................................................
end;

function _JsonFast(const JSON: RawUTF8): variant;
begin
  _Json(JSON,result,JSON_OPTIONS[true]);
end;

function _JsonFmt(const Format: RawUTF8; const Args,Params: array of const;
  Options: TDocVariantOptions): variant;
begin
  _Json(FormatUTF8(Format,Args,Params,true),result,Options);
end;

function _JsonFastFmt(const Format: RawUTF8; const Args,Params: array of const): variant;
begin
  _Json(FormatUTF8(Format,Args,Params,true),result,JSON_OPTIONS[true]);
end;

function _Json(const JSON: RawUTF8; var Value: variant;
  Options: TDocVariantOptions): boolean;
begin
................................................................................
  end;
  assert(ndx=Count-1);
  result := PAnsiChar(fValue^)+cardinal(ndx)*ElemSize;
  PRawUTF8(result)^ := aName; // store unique name at 1st elem position
end;

function TDynArrayHashed.AddUniqueName(const aName: RawUTF8;
  const ExceptionMsg: RawUTF8; const ExceptionArgs: array of const): pointer;
var ndx: integer;
    added: boolean;
begin
  ndx := FindHashedForAdding(aName,added);
  if added then begin
    assert(ndx=Count-1);
    result := PAnsiChar(fValue^)+cardinal(ndx)*ElemSize;
    PRawUTF8(result)^ := aName; // store unique name at 1st elem position
  end else
    if ExceptionMsg='' then
      raise ESynException.CreateUTF8('Duplicated "%" name',[aName]) else
      raise ESynException.CreateUTF8(ExceptionMsg,ExceptionArgs);
end;

function TDynArrayHashed.FindHashedAndFill(var Elem): integer;
var P: PAnsiChar;
begin
................................................................................
    end;
    end;
  CancelLastComma;
  Add(']');
end;

{$ifndef DELPHI5OROLDER}
procedure TTextWriter.Add(const Format: RawUTF8; const Values: array of const;
  Escape: TTextWriterKind=twNone);
var ValuesIndex: integer;
    F: PUTF8Char;
label write;
begin // we put const char > #127 as #??? -> asiatic MBCS codepage OK
  if Format='' then
    exit;
  if (Format='%') and (high(Values)>=0) then begin
    Add(Values[0],Escape);
    exit;
  end;
  ValuesIndex := 0;
  F := pointer(Format);
  repeat
    repeat
      case ord(F^) of
      0: exit;
      13: AddCR;
      ord('%'): break;
      {$ifdef OLDTEXTWRITERFORMAT}
      164: AddCR; // � -> add CR,LF
      167: if B^=',' then dec(B); // �
      ord('|'): begin
        inc(F); // |% -> %
        goto write;
      end;
      ord('$'),163,181: // $,�,�
        break; // process command value
      {$endif}
      else begin
write:  if B>=BEnd then
          Flush;
        B[1] := F^;
        inc(B);
      end;
      end;
      inc(F);
    until false;
    // add next value as text
    if ValuesIndex<=high(Values) then // missing value will display nothing
    case ord(F^) of
    ord('%'):
      Add(Values[ValuesIndex],Escape);


































    {$ifdef OLDTEXTWRITERFORMAT}
    ord('$'): with Values[ValuesIndex] do
           if Vtype=vtInteger then Add2(VInteger);
    163: with Values[ValuesIndex] do // �
           if Vtype=vtInteger then Add4(VInteger);
    181: with Values[ValuesIndex] do // �
           if Vtype=vtInteger then Add3(VInteger);
    {$endif}
    end;
    inc(F);
    inc(ValuesIndex);
  until false;
end;
{$endif}

procedure TTextWriter.AddLine(const Text: shortstring);
begin
................................................................................
    vtExtended: Add(VExtended^);
    vtCurrency: AddCurr64(VInt64^);
    {$ifndef NOVARIANTS}
    vtVariant:  AddVariantJSON(VVariant^,twJSONEscape);
    {$endif}
  end;
end;

procedure TTextWriter.Add(const V: TVarRec; Escape: TTextWriterKind);
begin
  with V do
  case Vtype of
  vtInteger:      Add(VInteger);
  vtBoolean:      AddU(byte(VBoolean));
  vtChar:         Add(@VChar,1,Escape);
  vtExtended:     Add(VExtended^);
  vtString:       Add(@VString^[1],ord(VString^[0]),Escape);
  vtPointer:      AddPointer(PtrUInt(VPointer));
  vtPChar:        Add(PUTF8Char(VPChar),Escape);
  vtObject:       WriteObject(VObject,[woFullExpand]);
  vtClass:
   if VClass<>nil then
     AddShort(PShortString(PPointer(PtrInt(VClass)+vmtClassName)^)^);
  vtWideChar:
   AddW(@VWideChar,1,Escape);
  vtPWideChar:
   AddW(pointer(VPWideChar),StrLenW(VPWideChar),Escape);
  vtAnsiString:
   Add(VAnsiString,Escape); // expect RawUTF8
  vtCurrency:
   AddCurr64(VInt64^);
  vtWideString:
   if VWideString<>nil then
     AddW(VWideString,length(WideString(VWideString)),Escape);
  vtInt64:
   Add(VInt64^);
  {$ifndef NOVARIANTS}
  vtVariant:
   AddVariantJSON(VVariant^,Escape);
  {$endif}
  {$ifdef UNICODE}
  vtUnicodeString:
   if VUnicodeString<>nil then // convert to UTF-8
     AddW(VUnicodeString,length(UnicodeString(VUnicodeString)),Escape);
  {$endif} end;
end;

{$ifndef NOVARIANTS}
procedure TTextWriter.AddJSON(const Format: RawUTF8; const Args,Params: array of const);
begin
  AddVariantJSON(_JsonFastFmt(Format,Args,Params),twJSONEscape);
end;
{$endif}

procedure TTextWriter.AddJSONEscape(const NameValuePairs: array of const);
var a: integer;
................................................................................
      SetText(result);
    finally
      Free
    end;
end;

{$ifndef NOVARIANTS}
function JSONEncode(const Format: RawUTF8; const Args,Params: array of const): RawUTF8; overload;
begin
  with DefaultTextWriterJSONClass.CreateOwnedStream do
  try
    AddJSON(Format,Args,Params);
    SetText(result);
  finally
    Free
................................................................................
    Map.UnMap;
  end;
end;

procedure TRawUTF8List.SetTextPtr(P: PUTF8Char; const Delimiter: RawUTF8);
var DelimLen: PtrInt;
    DelimFirst: AnsiChar;
    PBeg, DelimNext: PUTF8Char;
    Line: RawUTF8;
begin
  DelimLen := length(Delimiter);
  BeginUpdate;
  Clear;
  if (P<>nil) and (DelimLen>0) then begin
    DelimFirst := Delimiter[1];
    DelimNext := PUTF8Char(pointer(Delimiter))+1;
    repeat
      PBeg := P;
      while P^<>#0 do begin
        if (P^=DelimFirst) and CompareMem(P+1,DelimNext,DelimLen-1) then
          break;
        inc(P);
      end;
      SetString(Line,PBeg,P-PBeg);
      AddObject(Line,nil);
      if P^=#0 then
        break;
      inc(P,DelimLen);
    until P^=#0;
  end;
  EndUpdate;
................................................................................
begin
  SynLZDecompress(pointer(Data),length(Data),result);
end;


{ ESynException }

constructor ESynException.CreateUTF8(const Format: RawUTF8; const Args: array of const);
begin
  Create(UTF8ToString(FormatUTF8(Format,Args)));
end;

{$ifndef NOEXCEPTIONINTERCEPT}
function ESynException.CustomLog(WR: TTextWriter;
  const Context: TSynLogExceptionContext): boolean;
................................................................................

{ TSynBackgroundThreadAbstract }

{$ifdef MSWINDOWS}
function IsDebuggerPresent: BOOL; stdcall; external kernel32; // since XP
{$endif}

procedure SetCurrentThreadName(const Format: RawUTF8; const Args: array of const);
begin
  SetThreadName(GetCurrentThreadId,Format,Args);
end;

procedure SetThreadName(ThreadID: cardinal; const Format: RawUTF8;
  const Args: array of const);
var name: RawByteString;
{$ifndef ISDELPHIXE2}
{$ifdef MSWINDOWS}
    info: record
      FType: LongWord;     // must be 0x1000
      FName: PAnsiChar;    // pointer to name (in user address space)
      FThreadID: LongWord; // thread ID (-1 indicates caller thread)

  end;
end;

function TSQLDBConnectionProperties.SQLFieldCreate(const aField: TSQLDBColumnCreate;
  var aAddPrimaryKey: RawUTF8): RawUTF8;
begin
  if (aField.DBType=ftUTF8) and (aField.Width-1<fSQLCreateFieldMax) then
    result := FormatUTF8(pointer(fSQLCreateField[ftNull]),[aField.Width]) else
    result := fSQLCreateField[aField.DBType];
  if aField.NonNullable or aField.Unique or aField.PrimaryKey then
    result := result+' NOT NULL';
  if aField.Unique and not aField.PrimaryKey then
    result := result+' UNIQUE'; // see http://www.w3schools.com/sql/sql_unique.asp
  if aField.PrimaryKey then
    case DBMS of

  end;
end;

function TSQLDBConnectionProperties.SQLFieldCreate(const aField: TSQLDBColumnCreate;
  var aAddPrimaryKey: RawUTF8): RawUTF8;
begin
  if (aField.DBType=ftUTF8) and (aField.Width-1<fSQLCreateFieldMax) then
    result := FormatUTF8(fSQLCreateField[ftNull],[aField.Width]) else
    result := fSQLCreateField[aField.DBType];
  if aField.NonNullable or aField.Unique or aField.PrimaryKey then
    result := result+' NOT NULL';
  if aField.Unique and not aField.PrimaryKey then
    result := result+' UNIQUE'; // see http://www.w3schools.com/sql/sql_unique.asp
  if aField.PrimaryKey then
    case DBMS of

  the provisions above, a recipient may use your version of this file under
  the terms of any one of the MPL, the GPL or the LGPL.

  ***** END LICENSE BLOCK *****

  Version 1.18
  - first public release, extracted from SynCommons.pas unit


  - Delphi XE4/XE5/XE6/XE7 compatibility (Windows target platform only)
  - unit fixed and tested with Delphi XE2 (and up) 64-bit compiler under Windows
  - Exception logging and Stack trace do work now on Linux with Kylix/CrossKylix
  - added TSynLogFile.Freq read-only property
  - added DefaultSynLogExceptionToStr() function and TSynLogExceptionToStrCustom
    variable, and ESynException.CustomLog() method to customize how raised
    exception are logged when intercepted - feature request [495720e0b9]
................................................................................
    /// call this method to add some information to the log at a specified level
    // - see the format in TSynLog.Log() method description
    // (not compatible with default SysUtils.Format function)
    // - if Instance is set, it will log the corresponding class name and address
    // (to be used if you didn't call TSynLog.Enter() method first)
    // - note that cardinal values should be type-casted to Int64() (otherwise
    // the integer mapped value will be transmitted, therefore wrongly)
    procedure Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArgs: array of const;
      Instance: TObject=nil); overload;
{$endif}
    /// call this method to add some information to the log at a specified level
    // - if Instance is set and Text is not '', it will log the corresponding
    // class name and address (to be used e.g. if you didn't call TSynLog.Enter()
    // method first)
    // - if Instance is set and Text is '', will behave the same as
................................................................................
    // - TSynLog will write the class and hexa address - TSQLLog will write the
    // object JSON content
    procedure Log(Level: TSynLogInfo; Instance: TObject); overload;
    /// call this method to add the content of most low-level types to the log
    // at a specified level
    // - TSynLog will handle enumerations and dynamic array; TSQLLog will be
    // able to write TObject/TSQLRecord and sets content as JSON
    procedure Log(Level: TSynLogInfo; aName: PWinAnsiChar;
      aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload;
    /// call this method to add the caller address to the log at the specified level
    // - if the debugging info is available from TSynMapFile, will log the
    // unit name, associated symbol and source code line
    procedure Log(Level: TSynLogInfo=sllTrace); overload;
    /// call this method to add some multi-line information to the log at a
    // specified level
................................................................................
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    {$endif}
    class function FamilyCreate: TSynLogFamily;
    procedure DoEnterLeave(aLevel: TSynLogInfo);
    procedure CreateLogWriter; virtual;
{$ifndef DELPHI5OROLDER}
    procedure LogInternal(Level: TSynLogInfo; TextFmt: PWinAnsiChar;
      const TextArgs: array of const; Instance: TObject); overload; 
{$endif}
    procedure LogInternal(Level: TSynLogInfo; const Text: RawUTF8;
      Instance: TObject; TextTruncateAtLength: integer); overload;
    procedure LogInternal(Level: TSynLogInfo; aName: PWinAnsiChar;
     aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload; 
    // any call to this method MUST call UnLock
    function LogHeaderLock(Level: TSynLogInfo): boolean;
    procedure LogTrailerUnLock(Level: TSynLogInfo); {$ifdef HASINLINE}inline;{$endif}
    procedure LogCurrentTime;
    procedure LogFileHeader; virtual;
{$ifndef DELPHI5OROLDER}
................................................................................
    // - i.e. a TSynLog sub-class with Family.Level := []
    class function Void: TSynLogClass;
{$ifndef DELPHI5OROLDER}
    /// low-level method helper which can be called to make debugging easier
    // - log some warning message to the TSynLog family
    // - will force a manual breakpoint if tests are run from the IDE
    class procedure DebuggerNotify(Level: TSynLogInfo;
      const Args: array of const; Format: PWinAnsiChar=nil);
    /// call this method to add some information to the log at the specified level
    // - % = #37 indicates a string, integer, floating-point, or class parameter
    // to be appended as text (e.g. class name)
    // - $ = #36 indicates an integer to be written with 2 digits and a comma
    // - � = #163 indicates an integer to be written with 4 digits and a comma
    // - � = #181 indicates an integer to be written with 3 digits without any comma
    // - � = #164 indicates CR+LF chars
................................................................................
    // - CR = #13 indicates CR+LF chars
    // - � = #167 indicates to trim last comma
    // - since some of this characters above are > #127, they are not UTF-8
    // ready, so we expect the input format to be WinAnsi, i.e. mostly English
    // text (with chars < #128) with some values to be inserted inside
    // - note that cardinal values should be type-casted to Int64() (otherwise
    // the integer mapped value will be transmitted, therefore wrongly)
    procedure Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArgs: array of const;
      aInstance: TObject=nil); overload;
    /// same as Log(Level,TextFmt,[]) but with one RawUTF8 parameter
    procedure Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArg: RawUTF8;
      aInstance: TObject=nil); overload;
    /// same as Log(Level,TextFmt,[]) but with one Int64 parameter
    procedure Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArg: Int64;
      aInstance: TObject=nil); overload;
{$endif}
    /// call this method to add some information to the log at the specified level
    // - if Instance is set and Text is not '', it will log the corresponding
    // class name and address (to be used e.g. if you didn't call TSynLog.Enter()
    // method first) - for instance
    // ! TSQLLog.Add.Log(sllDebug,'GarbageCollector',GarbageCollector);
................................................................................
    procedure Log(Level: TSynLogInfo; aInstance: TObject); overload;
    /// call this method to add the content of most low-level types to the log
    // at a specified level
    // - this overridden implementation will write the value content,
    // written as human readable JSON: handle dynamic arrays and enumerations
    // - TSQLLog from mORMot.pas unit will be able to write
    // TObject/TSQLRecord and sets content as JSON
    procedure Log(Level: TSynLogInfo; aName: PWinAnsiChar;
      aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload;
    /// call this method to add the caller address to the log at the specified level
    // - if the debugging info is available from TSynMapFile, will log the
    // unit name, associated symbol and source code line
    procedure Log(Level: TSynLogInfo); overload;
    /// call this method to add some multi-line information to the log at a
    // specified level
................................................................................
  TextColor(LOGCOLORS[Level]);
  writeln(#13#10,Text,#13#10);
  TextColor(ccLightGray);
  {$endif}
end;

{$ifndef DELPHI5OROLDER}
procedure TSynLog.Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArgs: array of const;
  aInstance: TObject);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,TextArgs,aInstance);
end;

procedure TSynLog.Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArg: RawUTF8;
  aInstance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,[TextArg],aInstance);
end;

procedure TSynLog.Log(Level: TSynLogInfo; TextFmt: PWinAnsiChar; const TextArg: Int64;
  aInstance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,[TextArg],aInstance);
end;
{$endif}

................................................................................
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    if aInstance<>nil then
      LogInternal(Level,'',aInstance,maxInt) else
      LogInternal(Level,'Instance=nil',nil,maxInt);
end;

procedure TSynLog.Log(Level: TSynLogInfo; aName: PWinAnsiChar;
  aTypeInfo: pointer; var aValue; Instance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,aName,aTypeInfo,aValue,Instance);
end;

{$STACKFRAMES ON}
................................................................................
      SetLastError(LastError);
  end;
end;
{$STACKFRAMES OFF}

{$ifndef DELPHI5OROLDER}
class procedure TSynLog.DebuggerNotify(Level: TSynLogInfo;
  const Args: array of const; Format: PWinAnsiChar=nil);
var Msg: RawUTF8;
begin
  if Format<>nil then begin
    Msg := FormatUTF8(PUTF8Char(Format),Args);
    Add.LogInternal(Level,Msg,nil,maxInt);
    {$ifdef MSWINDOWS}
    OutputDebugStringA(pointer(Msg));
    {$endif}
    {$ifdef LINUX}
    //write(Msg);
    {$endif}
  end;
  {$ifndef FPC_OR_PUREPASCAL}
  if DebugHook<>0 then
    asm int 3 end; // force manual breakpoint if tests are run from the IDE
................................................................................
      PerformRotation;
  finally
    LeaveCriticalSection(fThreadLock);
  end;
end;

{$ifndef DELPHI5OROLDER}
procedure TSynLog.LogInternal(Level: TSynLogInfo; TextFmt: PWinAnsiChar;
  const TextArgs: array of const; Instance: TObject);
var LastError: cardinal;
begin
  if Level=sllLastError then
    LastError := GetLastError else
    LastError := 0;
  if LogHeaderLock(Level) then
................................................................................
  finally
    LogTrailerUnLock(Level);
    if LastError<>0 then
      SetLastError(LastError);
  end;
end;

procedure TSynLog.LogInternal(Level: TSynLogInfo; aName: PWinAnsiChar;
   aTypeInfo: pointer; var aValue; Instance: TObject=nil);
begin
  if LogHeaderLock(Level) then
  try
    if Instance<>nil then
      fWriter.AddInstancePointer(Instance,' ');
    fWriter.AddNoJSONEscape(aName);
    fWriter.Add('=');
    fWriter.AddTypedJSON(aTypeInfo,aValue);
  finally
    LogTrailerUnLock(Level);
  end;
end;

  the provisions above, a recipient may use your version of this file under
  the terms of any one of the MPL, the GPL or the LGPL.

  ***** END LICENSE BLOCK *****

  Version 1.18
  - first public release, extracted from SynCommons.pas unit
  - BREAKING CHANGE: PWinAnsiChar type for constant text parameters has been
    changed into RawUTF8, to allow logging of any Unicode text 
  - Delphi XE4/XE5/XE6/XE7 compatibility (Windows target platform only)
  - unit fixed and tested with Delphi XE2 (and up) 64-bit compiler under Windows
  - Exception logging and Stack trace do work now on Linux with Kylix/CrossKylix
  - added TSynLogFile.Freq read-only property
  - added DefaultSynLogExceptionToStr() function and TSynLogExceptionToStrCustom
    variable, and ESynException.CustomLog() method to customize how raised
    exception are logged when intercepted - feature request [495720e0b9]
................................................................................
    /// call this method to add some information to the log at a specified level
    // - see the format in TSynLog.Log() method description
    // (not compatible with default SysUtils.Format function)
    // - if Instance is set, it will log the corresponding class name and address
    // (to be used if you didn't call TSynLog.Enter() method first)
    // - note that cardinal values should be type-casted to Int64() (otherwise
    // the integer mapped value will be transmitted, therefore wrongly)
    procedure Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArgs: array of const;
      Instance: TObject=nil); overload;
{$endif}
    /// call this method to add some information to the log at a specified level
    // - if Instance is set and Text is not '', it will log the corresponding
    // class name and address (to be used e.g. if you didn't call TSynLog.Enter()
    // method first)
    // - if Instance is set and Text is '', will behave the same as
................................................................................
    // - TSynLog will write the class and hexa address - TSQLLog will write the
    // object JSON content
    procedure Log(Level: TSynLogInfo; Instance: TObject); overload;
    /// call this method to add the content of most low-level types to the log
    // at a specified level
    // - TSynLog will handle enumerations and dynamic array; TSQLLog will be
    // able to write TObject/TSQLRecord and sets content as JSON
    procedure Log(Level: TSynLogInfo; const aName: RawUTF8;
      aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload;
    /// call this method to add the caller address to the log at the specified level
    // - if the debugging info is available from TSynMapFile, will log the
    // unit name, associated symbol and source code line
    procedure Log(Level: TSynLogInfo=sllTrace); overload;
    /// call this method to add some multi-line information to the log at a
    // specified level
................................................................................
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    {$endif}
    class function FamilyCreate: TSynLogFamily;
    procedure DoEnterLeave(aLevel: TSynLogInfo);
    procedure CreateLogWriter; virtual;
{$ifndef DELPHI5OROLDER}
    procedure LogInternal(Level: TSynLogInfo; const TextFmt: RawUTF8;
      const TextArgs: array of const; Instance: TObject); overload; 
{$endif}
    procedure LogInternal(Level: TSynLogInfo; const Text: RawUTF8;
      Instance: TObject; TextTruncateAtLength: integer); overload;
    procedure LogInternal(Level: TSynLogInfo; const aName: RawUTF8;
     aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload; 
    // any call to this method MUST call UnLock
    function LogHeaderLock(Level: TSynLogInfo): boolean;
    procedure LogTrailerUnLock(Level: TSynLogInfo); {$ifdef HASINLINE}inline;{$endif}
    procedure LogCurrentTime;
    procedure LogFileHeader; virtual;
{$ifndef DELPHI5OROLDER}
................................................................................
    // - i.e. a TSynLog sub-class with Family.Level := []
    class function Void: TSynLogClass;
{$ifndef DELPHI5OROLDER}
    /// low-level method helper which can be called to make debugging easier
    // - log some warning message to the TSynLog family
    // - will force a manual breakpoint if tests are run from the IDE
    class procedure DebuggerNotify(Level: TSynLogInfo;
      const Format: RawUTF8; const Args: array of const);
    /// call this method to add some information to the log at the specified level
    // - % = #37 indicates a string, integer, floating-point, or class parameter
    // to be appended as text (e.g. class name)
    // - $ = #36 indicates an integer to be written with 2 digits and a comma
    // - � = #163 indicates an integer to be written with 4 digits and a comma
    // - � = #181 indicates an integer to be written with 3 digits without any comma
    // - � = #164 indicates CR+LF chars
................................................................................
    // - CR = #13 indicates CR+LF chars
    // - � = #167 indicates to trim last comma
    // - since some of this characters above are > #127, they are not UTF-8
    // ready, so we expect the input format to be WinAnsi, i.e. mostly English
    // text (with chars < #128) with some values to be inserted inside
    // - note that cardinal values should be type-casted to Int64() (otherwise
    // the integer mapped value will be transmitted, therefore wrongly)
    procedure Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArgs: array of const;
      aInstance: TObject=nil); overload;
    /// same as Log(Level,TextFmt,[]) but with one RawUTF8 parameter
    procedure Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArg: RawUTF8;
      aInstance: TObject=nil); overload;
    /// same as Log(Level,TextFmt,[]) but with one Int64 parameter
    procedure Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArg: Int64;
      aInstance: TObject=nil); overload;
{$endif}
    /// call this method to add some information to the log at the specified level
    // - if Instance is set and Text is not '', it will log the corresponding
    // class name and address (to be used e.g. if you didn't call TSynLog.Enter()
    // method first) - for instance
    // ! TSQLLog.Add.Log(sllDebug,'GarbageCollector',GarbageCollector);
................................................................................
    procedure Log(Level: TSynLogInfo; aInstance: TObject); overload;
    /// call this method to add the content of most low-level types to the log
    // at a specified level
    // - this overridden implementation will write the value content,
    // written as human readable JSON: handle dynamic arrays and enumerations
    // - TSQLLog from mORMot.pas unit will be able to write
    // TObject/TSQLRecord and sets content as JSON
    procedure Log(Level: TSynLogInfo; const aName: RawUTF8;
      aTypeInfo: pointer; var aValue; Instance: TObject=nil); overload;
    /// call this method to add the caller address to the log at the specified level
    // - if the debugging info is available from TSynMapFile, will log the
    // unit name, associated symbol and source code line
    procedure Log(Level: TSynLogInfo); overload;
    /// call this method to add some multi-line information to the log at a
    // specified level
................................................................................
  TextColor(LOGCOLORS[Level]);
  writeln(#13#10,Text,#13#10);
  TextColor(ccLightGray);
  {$endif}
end;

{$ifndef DELPHI5OROLDER}
procedure TSynLog.Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArgs: array of const;
  aInstance: TObject);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,TextArgs,aInstance);
end;

procedure TSynLog.Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArg: RawUTF8;
  aInstance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,[TextArg],aInstance);
end;

procedure TSynLog.Log(Level: TSynLogInfo; const TextFmt: RawUTF8; const TextArg: Int64;
  aInstance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,TextFmt,[TextArg],aInstance);
end;
{$endif}

................................................................................
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    if aInstance<>nil then
      LogInternal(Level,'',aInstance,maxInt) else
      LogInternal(Level,'Instance=nil',nil,maxInt);
end;

procedure TSynLog.Log(Level: TSynLogInfo; const aName: RawUTF8;
  aTypeInfo: pointer; var aValue; Instance: TObject=nil);
begin
  if (self<>nil) and (Level in fFamily.fLevel) then
    LogInternal(Level,aName,aTypeInfo,aValue,Instance);
end;

{$STACKFRAMES ON}
................................................................................
      SetLastError(LastError);
  end;
end;
{$STACKFRAMES OFF}

{$ifndef DELPHI5OROLDER}
class procedure TSynLog.DebuggerNotify(Level: TSynLogInfo;
  const Format: RawUTF8; const Args: array of const);
var Msg: RawUTF8;
begin
  if Format<>''then begin
    Msg := FormatUTF8(Format,Args);
    Add.LogInternal(Level,Msg,nil,maxInt);
    {$ifdef MSWINDOWS}
    OutputDebugStringA(pointer(CurrentAnsiConvert.UTF8ToAnsi(Msg)));
    {$endif}                                                      
    {$ifdef LINUX}
    //write(Msg);
    {$endif}
  end;
  {$ifndef FPC_OR_PUREPASCAL}
  if DebugHook<>0 then
    asm int 3 end; // force manual breakpoint if tests are run from the IDE
................................................................................
      PerformRotation;
  finally
    LeaveCriticalSection(fThreadLock);
  end;
end;

{$ifndef DELPHI5OROLDER}
procedure TSynLog.LogInternal(Level: TSynLogInfo; const TextFmt: RawUTF8;
  const TextArgs: array of const; Instance: TObject);
var LastError: cardinal;
begin
  if Level=sllLastError then
    LastError := GetLastError else
    LastError := 0;
  if LogHeaderLock(Level) then
................................................................................
  finally
    LogTrailerUnLock(Level);
    if LastError<>0 then
      SetLastError(LastError);
  end;
end;

procedure TSynLog.LogInternal(Level: TSynLogInfo; const aName: RawUTF8;
   aTypeInfo: pointer; var aValue; Instance: TObject=nil);
begin
  if LogHeaderLock(Level) then
  try
    if Instance<>nil then
      fWriter.AddInstancePointer(Instance,' ');
    fWriter.AddString(aName);
    fWriter.Add('=');
    fWriter.AddTypedJSON(aTypeInfo,aValue);
  finally
    LogTrailerUnLock(Level);
  end;
end;

// - will create the BSON binary without any temporary TDocVariant storage,
// by calling JSONBufferToBSONDocument() on the generated JSON content
// - since all content will be transformed into JSON internally, use this
// method only if the supplied parameters are simple types, and identified
// explicitely via BSON-like extensions: any complex value (e.g. a TDateTime
// or a BSONVariant binary) won't be handled as expected - use the overloaded
// BSON() with explicit BSONVariant() name/value pairs instead
function BSON(Format: PUTF8Char; const Args,Params: array of const): TBSONDocument; overload;

/// store some TDocVariant custom variant content into BSON encoded binary
// - will write either a BSON object or array, depending of the internal
// layout of this TDocVariantData instance (i.e. Kind property value)
// - if supplied variant is not a TDocVariant, raise an EBSONException
function BSON(const doc: TDocVariantData): TBSONDocument; overload;

................................................................................
// instead if you do not want to modify the input buffer content
procedure BSONVariant(JSON: PUTF8Char; var result: variant); overload;

/// store some object content, supplied as (extended) JSON and parameters,
// into a TBSONVariant betDoc type instance
// - in addition to the JSON RFC specification strict mode, this method will
// handle some BSON-like extensions, as with the overloaded BSON() function
function BSONVariant(Format: PUTF8Char; const Args,Params: array of const): variant; overload;

/// convert a TDocVariant variant into a TBSONVariant betDoc type instance
function BSONVariant(doc: TDocVariantData): variant; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// store an array of integer into a TBSONVariant betArray type instance
// - object will be initialized with data supplied e.g. as a TIntegerDynArray
................................................................................
    // !   products.insert('{ item: ?, qty: ? }',[1,'card',15]);
    // !   // here the _id will be created on the client side as an ObjectID
    // - you can retrieve the client-side computed ObjectID, as such:
    // ! var oid: TBSONObjectID;
    // ! ...
    // !   products.insert('{ item: ?, qty: ? }',['card',15],@oid);
    // !   writeln(oid.ToText);
    procedure Insert(Document: PUTF8Char; const Params: array of const;
      CreatedObjectID: PBSONObjectID=nil); overload;
    /// insert one or more documents in the collection
    // - Documents is an array of TDocVariant (i.e. created via _JsonFast()
    // or _JsonFastFmt()) - or of TBSONVariant (created via BSONVariant())
    // - by default, it will follow Client.WriteConcern pattern - but you can
    // set NoAcknowledge = TRUE to avoid calling the getLastError command and
    // increase the execution speed, at the expense of a unsafe process
................................................................................
    // document with the fields from the document - and the method returns TRUE
    function Save(var Document: variant; CreatedObjectID: PBSONObjectID=nil): boolean; overload;
    /// updates an existing document or inserts a new document, depending on
    // its document parameter, supplied as (extended) JSON and parameters
    // - supplied JSON could be either strict or in MongoDB Shell syntax:
    // - will perform either an insert or an update, depending of the
    // presence of the _id field, as overloaded Save(const Document: variant)
    procedure Save(Document: PUTF8Char; const Params: array of const;
      CreatedObjectID: PBSONObjectID=nil); overload;

    /// modifies an existing document or several documents in a collection
    // - the method can modify specific fields of existing document or documents
    // or replace an existing document entirely, depending on the update parameter
    // - Query and Update parameters should be TDocVariant (i.e. created via
    // _JsonFast() or _JsonFastFmt()) or TBSONVariant (created via BSONVariant())
................................................................................
    // - if Update contains update operators (like $set), it will update the
    // corresponding fields in the document:
    // ! book.insert('{_id:?,item:?,stock:?}',[11,'Divine Comedy',2]);
    // ! book.update('{item:?},['Divine Comedy'],'{$set:{price:?},$inc:{stock:?}},[18,5]);
    // ! // the updated document is now:
    // ! { "_id" : 11, "item" : "Divine Comedy", "price" : 18, "stock" : 7 }
    procedure Update(Query: PUTF8Char; const QueryParams: array of const;
      Update: PUTF8Char; const UpdateParams: array of const;
      Flags: TMongoUpdateFlags=[]); overload;
    /// modifies some fields of an existing document in a collection
    // - by default, Update() or Save() will replace the whole document
    // - this method will expect the identifier to be supplied as a variant -
    // may be via the ObjectID() function
    // - and will replace the specified fields, i.e. it will execute a $set:
    // with the supplied UpdatedFields value
................................................................................
  EMongoConnectionException = class(EMongoException)
  protected
    fConnection: TMongoConnection;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(Format: PUTF8Char; const Args: array of const;
      aConnection: TMongoConnection); reintroduce;
  published
    /// the associated connection
    property Connection: TMongoConnection read fConnection;
  end;

  EMongoDatabaseException = class(EMongoConnectionException)
  protected
    fDatabase: TMongoDatabase;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aDatabase: TMongoDatabase); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(Format: PUTF8Char; const Args: array of const;
      aDatabase: TMongoDatabase); reintroduce;
    {$ifndef NOEXCEPTIONINTERCEPT}
    /// used to customize the exception log to contain information about the Query
    // - it will log the database parameters
    function CustomLog(WR: TTextWriter; const Context: TSynLogExceptionContext): boolean; override;
    {$endif}
  published
................................................................................
    fErrorDoc: variant;
    function GetErrorDoc: variant;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest=nil); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(Format: PUTF8Char; const Args: array of const;
      aConnection: TMongoConnection; aRequest: TMongoRequest); reintroduce;
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest; const aError: TMongoReplyCursor); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest; const aErrorDoc: TDocVariantData); reintroduce; overload;
................................................................................
  finally
    W.Free;
  end;
  SetLength(docs,n);
  result := true;
end;

function BSON(Format: PUTF8Char; const Args,Params: array of const): TBSONDocument;
var JSON: RawUTF8;
    v: variant;
begin
  if (Format<>nil) and (PWord(Format)^=ord('?')) and (high(Params)>=0) then begin
    VarRecToVariant(Params[0],v);
    if DocVariantType.IsOfType(v) then begin
      result := BSON(TDocVariantData(v));
      exit;
    end;
  end;
  JSON := FormatUTF8(Format,Args,Params,true);

  JSONBufferToBSONDocument(pointer(JSON),result);
end;

function BSON(const JSON: RawUTF8): TBSONDocument;
var tmp: RawUTF8; // make a private copy
begin
  SetString(tmp,PAnsiChar(pointer(JSON)),length(JSON));
................................................................................
procedure BSONVariant(JSON: PUTF8Char; var result: variant);
var tmp: TBSONDocument;
begin
  JSONBufferToBSONDocument(JSON,tmp);
  BSONVariantType.FromBSONDocument(tmp,result);
end;

function BSONVariant(Format: PUTF8Char; const Args,Params: array of const): variant; overload;
begin
  BSONVariantType.FromBSONDocument(BSON(Format,Args,Params),result);
end;

function BSONVariant(doc: TDocVariantData): variant; overload;
begin
  BSONVariantType.FromBSONDocument(BSON(Doc),result);
................................................................................
constructor EMongoConnectionException.Create(const aMsg: string;
  aConnection: TMongoConnection);
begin
  inherited Create(aMsg);
  fConnection := aConnection;
end;

constructor EMongoConnectionException.CreateUTF8(Format: PUTF8Char; const Args: array of const;
  aConnection: TMongoConnection);
begin
  inherited CreateUTF8(Format,Args);
  fConnection := aConnection;
end;


................................................................................
constructor EMongoRequestException.Create(const aMsg: string;
  aConnection: TMongoConnection; aRequest: TMongoRequest);
begin
  inherited Create(aMsg,aConnection);
  fRequest := aRequest;
end;

constructor EMongoRequestException.CreateUTF8(Format: PUTF8Char;
  const Args: array of const; aConnection: TMongoConnection;
  aRequest: TMongoRequest);
begin
  inherited CreateUTF8(Format,Args,aConnection);
  fRequest := aRequest;
end;

................................................................................
constructor EMongoDatabaseException.Create(const aMsg: string;
  aDatabase: TMongoDatabase);
begin
  inherited Create(aMsg,aDatabase.Client.Connections[0]);
  fDatabase := aDatabase;
end;

constructor EMongoDatabaseException.CreateUTF8(Format: PUTF8Char;
  const Args: array of const; aDatabase: TMongoDatabase);
begin
  inherited CreateUTF8(Format,Args,aDatabase.Client.Connections[0]);
  fDatabase := aDatabase;
end;

{$ifndef NOEXCEPTIONINTERCEPT}
................................................................................
    oid := doc.Values[ndx];
    result := false;
  end;
  if CreatedObjectID<>nil then
    CreatedObjectID^.FromVariant(oid)
end;

procedure TMongoCollection.Insert(Document: PUTF8Char;
  const Params: array of const; CreatedObjectID: PBSONObjectID);
var doc: variant;
    oid: variant;
begin
  doc := _JsonFastFmt(Document,[],Params);
  EnsureDocumentHasID(TDocVariantData(doc),oid,CreatedObjectID);
  Insert([doc]);
................................................................................
    Document := _JsonFast(VariantSaveMongoJSON(Document,modMongoShell));
  result := EnsureDocumentHasID(TDocVariantData(Document),oid,CreatedObjectID);
  if result then
    Insert([Document]) else
    Update(BSONVariant(['_id',oid]),Document,[mufUpsert])
end;

procedure TMongoCollection.Save(Document: PUTF8Char;
  const Params: array of const; CreatedObjectID: PBSONObjectID);
var doc: variant;
begin
  doc := _JsonFastFmt(Document,[],Params);
  Save(doc,CreatedObjectID);
end;

procedure TMongoCollection.Update(Query: PUTF8Char;
  const QueryParams: array of const; Update: PUTF8Char;
  const UpdateParams: array of const; Flags: TMongoUpdateFlags);
var quer,upd: variant;
begin
  quer := BSONVariant(Query,[],QueryParams);
  upd := BSONVariant(Update,[],UpdateParams);
  self.Update(quer,upd,Flags);
end;

// - will create the BSON binary without any temporary TDocVariant storage,
// by calling JSONBufferToBSONDocument() on the generated JSON content
// - since all content will be transformed into JSON internally, use this
// method only if the supplied parameters are simple types, and identified
// explicitely via BSON-like extensions: any complex value (e.g. a TDateTime
// or a BSONVariant binary) won't be handled as expected - use the overloaded
// BSON() with explicit BSONVariant() name/value pairs instead
function BSON(const Format: RawUTF8; const Args,Params: array of const): TBSONDocument; overload;

/// store some TDocVariant custom variant content into BSON encoded binary
// - will write either a BSON object or array, depending of the internal
// layout of this TDocVariantData instance (i.e. Kind property value)
// - if supplied variant is not a TDocVariant, raise an EBSONException
function BSON(const doc: TDocVariantData): TBSONDocument; overload;

................................................................................
// instead if you do not want to modify the input buffer content
procedure BSONVariant(JSON: PUTF8Char; var result: variant); overload;

/// store some object content, supplied as (extended) JSON and parameters,
// into a TBSONVariant betDoc type instance
// - in addition to the JSON RFC specification strict mode, this method will
// handle some BSON-like extensions, as with the overloaded BSON() function
function BSONVariant(const Format: RawUTF8; const Args,Params: array of const): variant; overload;

/// convert a TDocVariant variant into a TBSONVariant betDoc type instance
function BSONVariant(doc: TDocVariantData): variant; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// store an array of integer into a TBSONVariant betArray type instance
// - object will be initialized with data supplied e.g. as a TIntegerDynArray
................................................................................
    // !   products.insert('{ item: ?, qty: ? }',[1,'card',15]);
    // !   // here the _id will be created on the client side as an ObjectID
    // - you can retrieve the client-side computed ObjectID, as such:
    // ! var oid: TBSONObjectID;
    // ! ...
    // !   products.insert('{ item: ?, qty: ? }',['card',15],@oid);
    // !   writeln(oid.ToText);
    procedure Insert(const Document: RawUTF8; const Params: array of const;
      CreatedObjectID: PBSONObjectID=nil); overload;
    /// insert one or more documents in the collection
    // - Documents is an array of TDocVariant (i.e. created via _JsonFast()
    // or _JsonFastFmt()) - or of TBSONVariant (created via BSONVariant())
    // - by default, it will follow Client.WriteConcern pattern - but you can
    // set NoAcknowledge = TRUE to avoid calling the getLastError command and
    // increase the execution speed, at the expense of a unsafe process
................................................................................
    // document with the fields from the document - and the method returns TRUE
    function Save(var Document: variant; CreatedObjectID: PBSONObjectID=nil): boolean; overload;
    /// updates an existing document or inserts a new document, depending on
    // its document parameter, supplied as (extended) JSON and parameters
    // - supplied JSON could be either strict or in MongoDB Shell syntax:
    // - will perform either an insert or an update, depending of the
    // presence of the _id field, as overloaded Save(const Document: variant)
    procedure Save(const Document: RawUTF8; const Params: array of const;
      CreatedObjectID: PBSONObjectID=nil); overload;

    /// modifies an existing document or several documents in a collection
    // - the method can modify specific fields of existing document or documents
    // or replace an existing document entirely, depending on the update parameter
    // - Query and Update parameters should be TDocVariant (i.e. created via
    // _JsonFast() or _JsonFastFmt()) or TBSONVariant (created via BSONVariant())
................................................................................
    // - if Update contains update operators (like $set), it will update the
    // corresponding fields in the document:
    // ! book.insert('{_id:?,item:?,stock:?}',[11,'Divine Comedy',2]);
    // ! book.update('{item:?},['Divine Comedy'],'{$set:{price:?},$inc:{stock:?}},[18,5]);
    // ! // the updated document is now:
    // ! { "_id" : 11, "item" : "Divine Comedy", "price" : 18, "stock" : 7 }
    procedure Update(Query: PUTF8Char; const QueryParams: array of const;
      const Update: RawUTF8; const UpdateParams: array of const;
      Flags: TMongoUpdateFlags=[]); overload;
    /// modifies some fields of an existing document in a collection
    // - by default, Update() or Save() will replace the whole document
    // - this method will expect the identifier to be supplied as a variant -
    // may be via the ObjectID() function
    // - and will replace the specified fields, i.e. it will execute a $set:
    // with the supplied UpdatedFields value
................................................................................
  EMongoConnectionException = class(EMongoException)
  protected
    fConnection: TMongoConnection;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(const Format: RawUTF8; const Args: array of const;
      aConnection: TMongoConnection); reintroduce;
  published
    /// the associated connection
    property Connection: TMongoConnection read fConnection;
  end;

  EMongoDatabaseException = class(EMongoConnectionException)
  protected
    fDatabase: TMongoDatabase;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aDatabase: TMongoDatabase); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(const Format: RawUTF8; const Args: array of const;
      aDatabase: TMongoDatabase); reintroduce;
    {$ifndef NOEXCEPTIONINTERCEPT}
    /// used to customize the exception log to contain information about the Query
    // - it will log the database parameters
    function CustomLog(WR: TTextWriter; const Context: TSynLogExceptionContext): boolean; override;
    {$endif}
  published
................................................................................
    fErrorDoc: variant;
    function GetErrorDoc: variant;
  public
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest=nil); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor CreateUTF8(const Format: RawUTF8; const Args: array of const;
      aConnection: TMongoConnection; aRequest: TMongoRequest); reintroduce;
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest; const aError: TMongoReplyCursor); reintroduce; overload;
    /// initialize the Exception for a given request
    constructor Create(const aMsg: string; aConnection: TMongoConnection;
      aRequest: TMongoRequest; const aErrorDoc: TDocVariantData); reintroduce; overload;
................................................................................
  finally
    W.Free;
  end;
  SetLength(docs,n);
  result := true;
end;

function BSON(const Format: RawUTF8; const Args,Params: array of const): TBSONDocument;
var JSON: RawUTF8;
    v: variant;
begin
  if (Format='?') and (high(Params)>=0) then begin
    VarRecToVariant(Params[0],v);
    if DocVariantType.IsOfType(v) then begin
      result := BSON(TDocVariantData(v));
      exit;
    end;
  end;
  JSON := FormatUTF8(Format,Args,Params,true);
  UniqueRawUTF8(JSON);
  JSONBufferToBSONDocument(pointer(JSON),result);
end;

function BSON(const JSON: RawUTF8): TBSONDocument;
var tmp: RawUTF8; // make a private copy
begin
  SetString(tmp,PAnsiChar(pointer(JSON)),length(JSON));
................................................................................
procedure BSONVariant(JSON: PUTF8Char; var result: variant);
var tmp: TBSONDocument;
begin
  JSONBufferToBSONDocument(JSON,tmp);
  BSONVariantType.FromBSONDocument(tmp,result);
end;

function BSONVariant(const Format: RawUTF8; const Args,Params: array of const): variant; overload;
begin
  BSONVariantType.FromBSONDocument(BSON(Format,Args,Params),result);
end;

function BSONVariant(doc: TDocVariantData): variant; overload;
begin
  BSONVariantType.FromBSONDocument(BSON(Doc),result);
................................................................................
constructor EMongoConnectionException.Create(const aMsg: string;
  aConnection: TMongoConnection);
begin
  inherited Create(aMsg);
  fConnection := aConnection;
end;

constructor EMongoConnectionException.CreateUTF8(const Format: RawUTF8; const Args: array of const;
  aConnection: TMongoConnection);
begin
  inherited CreateUTF8(Format,Args);
  fConnection := aConnection;
end;


................................................................................
constructor EMongoRequestException.Create(const aMsg: string;
  aConnection: TMongoConnection; aRequest: TMongoRequest);
begin
  inherited Create(aMsg,aConnection);
  fRequest := aRequest;
end;

constructor EMongoRequestException.CreateUTF8(const Format: RawUTF8;
  const Args: array of const; aConnection: TMongoConnection;
  aRequest: TMongoRequest);
begin
  inherited CreateUTF8(Format,Args,aConnection);
  fRequest := aRequest;
end;

................................................................................
constructor EMongoDatabaseException.Create(const aMsg: string;
  aDatabase: TMongoDatabase);
begin
  inherited Create(aMsg,aDatabase.Client.Connections[0]);
  fDatabase := aDatabase;
end;

constructor EMongoDatabaseException.CreateUTF8(const Format: RawUTF8;
  const Args: array of const; aDatabase: TMongoDatabase);
begin
  inherited CreateUTF8(Format,Args,aDatabase.Client.Connections[0]);
  fDatabase := aDatabase;
end;

{$ifndef NOEXCEPTIONINTERCEPT}
................................................................................
    oid := doc.Values[ndx];
    result := false;
  end;
  if CreatedObjectID<>nil then
    CreatedObjectID^.FromVariant(oid)
end;

procedure TMongoCollection.Insert(const Document: RawUTF8;
  const Params: array of const; CreatedObjectID: PBSONObjectID);
var doc: variant;
    oid: variant;
begin
  doc := _JsonFastFmt(Document,[],Params);
  EnsureDocumentHasID(TDocVariantData(doc),oid,CreatedObjectID);
  Insert([doc]);
................................................................................
    Document := _JsonFast(VariantSaveMongoJSON(Document,modMongoShell));
  result := EnsureDocumentHasID(TDocVariantData(Document),oid,CreatedObjectID);
  if result then
    Insert([Document]) else
    Update(BSONVariant(['_id',oid]),Document,[mufUpsert])
end;

procedure TMongoCollection.Save(const Document: RawUTF8;
  const Params: array of const; CreatedObjectID: PBSONObjectID);
var doc: variant;
begin
  doc := _JsonFastFmt(Document,[],Params);
  Save(doc,CreatedObjectID);
end;

procedure TMongoCollection.Update(Query: PUTF8Char;
  const QueryParams: array of const; const Update: RawUTF8;
  const UpdateParams: array of const; Flags: TMongoUpdateFlags);
var quer,upd: variant;
begin
  quer := BSONVariant(Query,[],QueryParams);
  upd := BSONVariant(Update,[],UpdateParams);
  self.Update(quer,upd,Flags);
end;

    if U='' then
      continue;
    Check(UnQuoteSQLStringVar(pointer(QuotedStr(U,'"')),res)<>nil);
    Check(res=U);
    Check(not IsZero(pointer(W),length(W)));
    fillchar(pointer(W)^,length(W),0);
    Check(IsZero(pointer(W),length(W)));
    Check(FormatUTF8(pointer(U),[])=U);
{$ifndef DELPHI5OROLDER}
    res := FormatUTF8(pointer(U),[],[]); // Delphi 5 bug with high([])>0 :( 
    Check(length(res)=Length(u));
    Check(res=u);
    Check(FormatUTF8('%',[U])=U);
    Check(FormatUTF8('%',[U],[])=U);
    q := ':('+QuotedStr(U)+'):';
    Check(FormatUTF8('?',[],[U])=q);
    res := 'ab'+U;
................................................................................
  u := VariantSaveJSON(o.Field);
  u2 := VariantSaveJSON(o2.Field);
  Check(u=u2);
  Check(u=REGEX);
  o := _Json('{ tags: { $in: [ /^be/, /^st/ ] } }');
  u := VariantSaveMongoJSON(o,modMongoStrict);
  Check(u='{"tags":{"$in":[{"$regex":"^be","$options":""},{"$regex":"^st","$options":""}]}}');
  b := pointer(BSON(Pointer(u),[],[]));
  u2 := VariantSaveMongoJSON(o,modMongoShell);
  Check(u2='{tags:{$in:[/^be/,/^st/]}}');
  u := VariantSaveMongoJSON(_Json(u),modMongoShell);
  Check(u=u2);
  u2 := BSONToJSON(b,betDoc,0,modMongoShell);
  Check(u=u2);
  b := pointer(BSON('{id:ObjectId(),doc:{name:?,date:ISODate(?)}}',[],['John',NowUTC]));
................................................................................
        Check(MD2.FillOne);
        Check(MD2.ID=dID[i]);
        Check(MD2.Signature=FormatUTF8('% %',[aClient.ClassName,i]));
      finally
        MD2.Free;
      end;
    end;
    Check(MS.FillPrepareMany(aClient,nil,[],[]));
    CheckOK;
    Check(MS.FillPrepareMany(aClient,'DestList.Dest.SignatureTime<>?',[],[0]));
    CheckOK;
    Check(MS.FillPrepareMany(aClient,
      'DestList.Dest.SignatureTime<>% and RowID>=? and DestList.AssociationTime<>0 '+
      'and SignatureTime=DestList.Dest.SignatureTime '+
      'and DestList.Dest.Signature<>"DestList.AssociationTime"',[0],[sID[1]]));

    if U='' then
      continue;
    Check(UnQuoteSQLStringVar(pointer(QuotedStr(U,'"')),res)<>nil);
    Check(res=U);
    Check(not IsZero(pointer(W),length(W)));
    fillchar(pointer(W)^,length(W),0);
    Check(IsZero(pointer(W),length(W)));
    Check(FormatUTF8(U,[])=U);
{$ifndef DELPHI5OROLDER}
    res := FormatUTF8(U,[],[]); // Delphi 5 bug with high([])>0 :( 
    Check(length(res)=Length(u));
    Check(res=u);
    Check(FormatUTF8('%',[U])=U);
    Check(FormatUTF8('%',[U],[])=U);
    q := ':('+QuotedStr(U)+'):';
    Check(FormatUTF8('?',[],[U])=q);
    res := 'ab'+U;
................................................................................
  u := VariantSaveJSON(o.Field);
  u2 := VariantSaveJSON(o2.Field);
  Check(u=u2);
  Check(u=REGEX);
  o := _Json('{ tags: { $in: [ /^be/, /^st/ ] } }');
  u := VariantSaveMongoJSON(o,modMongoStrict);
  Check(u='{"tags":{"$in":[{"$regex":"^be","$options":""},{"$regex":"^st","$options":""}]}}');
  b := pointer(BSON(u,[],[]));
  u2 := VariantSaveMongoJSON(o,modMongoShell);
  Check(u2='{tags:{$in:[/^be/,/^st/]}}');
  u := VariantSaveMongoJSON(_Json(u),modMongoShell);
  Check(u=u2);
  u2 := BSONToJSON(b,betDoc,0,modMongoShell);
  Check(u=u2);
  b := pointer(BSON('{id:ObjectId(),doc:{name:?,date:ISODate(?)}}',[],['John',NowUTC]));
................................................................................
        Check(MD2.FillOne);
        Check(MD2.ID=dID[i]);
        Check(MD2.Signature=FormatUTF8('% %',[aClient.ClassName,i]));
      finally
        MD2.Free;
      end;
    end;
    Check(MS.FillPrepareMany(aClient,'', [],[]));
    CheckOK;
    Check(MS.FillPrepareMany(aClient,'DestList.Dest.SignatureTime<>?',[],[0]));
    CheckOK;
    Check(MS.FillPrepareMany(aClient,
      'DestList.Dest.SignatureTime<>% and RowID>=? and DestList.AssociationTime<>0 '+
      'and SignatureTime=DestList.Dest.SignatureTime '+
      'and DestList.Dest.Signature<>"DestList.AssociationTime"',[0],[sID[1]]));

    WR.Free;
  end;
end;

procedure TSynTestCase.TestFailed(const msg: string);
begin
  {$ifndef DELPHI5OROLDER}
  TSynLogTestLog.DebuggerNotify(sllFail,[fAssertions-fAssertionsBeforeRun,msg],'#% %');
  {$endif}
  if Owner<>nil then // avoid GPF
    Owner.Failed(msg,self);
  Inc(fAssertionsFailed);
end;

procedure TSynTestCase.NotifyTestSpeed(const ItemName: string;
................................................................................
    fConsoleDup.Add('"','}');
    fLogFile.Log(sllCustom1,fConsoleDup.Text);
  end;
  inherited Destroy;
  fConsoleDup.Free;
end;

const
 sFailed: PWinAnsiChar = '%: % "%"';

procedure TSynTestsLogged.Failed(const msg: string; aTest: TSynTestCase);
{$ifdef DELPHI5OROLDER}
var tmp: RawUTF8;
{$endif}
begin
  inherited;
  with TestCase[fCurrentMethod] do begin
    {$ifdef DELPHI5OROLDER}
    tmp := Ident+': '+TestName[fCurrentMethodIndex];
    if msg<>'' then
      tmp := tmp+' "'+msg+'"';
    fLogFile.Log(sllFail,tmp);
    {$else}
    fLogFile.Log(sllFail,sFailed,[Ident,TestName[fCurrentMethodIndex],msg],aTest);
    {$endif}
    {$ifdef KYLIX3}
    fLogFile.Flush(true);
    // we do not have a debugger for CrossKylix -> stop here!
    TextColor(ccLightRed);
    writeln('!!! ',Ident,' - ',TestName[fCurrentMethodIndex],' "',msg,'" failed !!!');
    write('Press [Enter] to continue, or Ctrl+C to abort ');

    WR.Free;
  end;
end;

procedure TSynTestCase.TestFailed(const msg: string);
begin
  {$ifndef DELPHI5OROLDER}
  TSynLogTestLog.DebuggerNotify(sllFail,'#% %',[fAssertions-fAssertionsBeforeRun,msg]);
  {$endif}
  if Owner<>nil then // avoid GPF
    Owner.Failed(msg,self);
  Inc(fAssertionsFailed);
end;

procedure TSynTestCase.NotifyTestSpeed(const ItemName: string;
................................................................................
    fConsoleDup.Add('"','}');
    fLogFile.Log(sllCustom1,fConsoleDup.Text);
  end;
  inherited Destroy;
  fConsoleDup.Free;
end;




procedure TSynTestsLogged.Failed(const msg: string; aTest: TSynTestCase);
{$ifdef DELPHI5OROLDER}
var tmp: RawUTF8;
{$endif}
begin
  inherited;
  with TestCase[fCurrentMethod] do begin
    {$ifdef DELPHI5OROLDER}
    tmp := Ident+': '+TestName[fCurrentMethodIndex];
    if msg<>'' then
      tmp := tmp+' "'+msg+'"';
    fLogFile.Log(sllFail,tmp);
    {$else}
    fLogFile.Log(sllFail,'%: % "%"',[Ident,TestName[fCurrentMethodIndex],msg],aTest);
    {$endif}
    {$ifdef KYLIX3}
    fLogFile.Flush(true);
    // we do not have a debugger for CrossKylix -> stop here!
    TextColor(ccLightRed);
    writeln('!!! ',Ident,' - ',TestName[fCurrentMethodIndex],' "',msg,'" failed !!!');
    write('Press [Enter] to continue, or Ctrl+C to abort ');

'1.18.897'

'1.18.898'