- enhanced TPropInfo.GetLongStrValue/SetLongStrValue methods, now converting
      RawUnicode, WinAnsiString, TSQLRawBlob and AnsiString properties
    - now ensure that no published property named ID or RowID was defined (this
      unique primary key field must be handled directly by TSQLRecord)
    - TSQLModel implementation speed up, in case of a huge number of registered
      TSQLRecord in the database Model
    - added a magic pattern check to ignore broadcasted WM_COPYDATA message






  String usage in the Synopse SQLite3 database framework:
    - RawUTF8 is used for every internal data usage, since both SQLite3 and
      JSON do expect UTF-8 encoding
    - WinAnsiString where WinAnsi-encoded AnsiString (code page 1252) are needed
    - generic string for i18n (in unit SQLite3i18n), i.e. text ready to be
................................................................................

{ ************ classes to access SQLite3 database data }

const
  /// maximum number of Tables in a Database Model
  // - this constant is used internaly to optimize memory usage in the
  // generated asm code
  MAX_SQLTABLES = 64;

type
  /// used to store bit set for all available Tables in a Database Model
  // - with current MAX_SQLTABLES value, uses 8 bytes of memory, therefore is
  // sometimes mapped to an Int64
  TSQLFieldTables = set of 0..MAX_SQLTABLES-1;

  /// a String used to store the BLOB content
  // - equals RawByteString for byte storage, to force no implicit charset
  // conversion, thatever the codepage of the resulting string is
  // - will identify a sftBlob field type, if used to define such a published
  // property
................................................................................

/// special comparaison function for sorting sftDateTime
// UTF-8 encoded values in the SQLite3 database or JSON content
function UTF8CompareISO8601(P1,P2: PUTF8Char): PtrInt;

const
  /// Supervisor Table access right, i.e. alllmighty over all fields
  ALL_ACCESS_RIGHTS = [0..MAX_SQLFIELDS-1];

  /// Supervisor Database access right, i.e. allmighty over all Tables
  SUPERVISOR_ACCESS_RIGHTS: TSQLAccessRights =
    (GET: ALL_ACCESS_RIGHTS; POST: ALL_ACCESS_RIGHTS;
     PUT: ALL_ACCESS_RIGHTS; DELETE: ALL_ACCESS_RIGHTS);

  /// special TSQLFieldBits value containing all field bits set to 1
................................................................................
    end;
    P[-1] := ')';
  end;
  // Assert(P-pointer(result)=length(result));
end;
var F: integer;
    FU: RawUTF8;
    Fields2, Values: array[0..MAX_SQLFIELDS] of RawUTF8;
begin
  result := '';
  if P=nil then
    exit;
  Len := 0;
  if pointer(Fields)=nil then begin
    // get "COL1"="VAL1" pairs, stopping at '}' or ']'
................................................................................
    result := fID;
end;

function TSQLRecord.GetHasBlob: boolean;
begin
  if Self=nil then
    result := false else
    result := Int64(RecordProps.BlobFieldsBits)<>0;
end;

function TSQLRecord.GetSimpleFieldCount: integer;
begin
  if Self=nil then
    result := 0 else
    result := length(RecordProps.SimpleFields);
................................................................................
end;
{$endif}

function TSQLRecord.Filter(const aFields: TSQLFieldBits): boolean;
var f, i: integer;
    Value, Old: RawUTF8;
begin
  result := (Int64(aFields)=0);
  if (self=nil) or result then
    // avoid GPF and handle case if no field was selected
    exit;
  with RecordProps do
  if Filters=nil then
    // no filter set yet -> process OK
    result := true else begin
................................................................................
  aInvalidFieldIndex: PInteger): string;
var f, i: integer;
    Value: RawUTF8;
    Validate: TSynValidate;
    ValidateRest: TSynValidateRest absolute Validate;
begin
  result := '';
  if (self=nil) or (Int64(aFields)=0) then
    // avoid GPF and handle case if no field was selected
    exit;
  with RecordProps do
  for f := 0 to high(Fields) do
  if not(FieldType[f] in [sftUnknown,sftMany]) then begin
    if (Filters<>nil) and (Filters[f]<>nil) then
      for i := 0 to Filters[f].Count-1 do begin
................................................................................
    BlobData: RawByteString;
    i: integer;
begin
  result := false;
  if (Self=nil) or (Value=nil) or (Value.fID<=0) then
    exit;
  with Value.RecordProps do
  if Int64(BlobFieldsBits)<>0 then begin
    URL := FormatUTF8('%/%/%/',[Model.Root,SQLTableName,Value.fID]);
    for i := 0 to high(Fields) do
      if i in BlobFieldsBits then
        // URI is 'ModelRoot/TableName/ID/BlobFieldName' with GET method
        if URI(FormatUTF8('%%',[URL,FieldsName[i]]),'GET',@BlobData).Lo=200 then
          SetLongStrProp(Value,Fields[i],BlobData) else
          exit;
................................................................................
    BlobData: RawByteString;
    i: integer;
begin
  result := false;
  if (Self=nil) or (Value=nil) or (Value.fID<=0) then
    exit;
  with Value.RecordProps do
  if Int64(BlobFieldsBits)<>0 then begin
    URL := FormatUTF8('%/%/%/',[Model.Root,SQLTableName,Value.fID]);
    for i := 0 to high(Fields) do
      if i in BlobFieldsBits then begin
        GetLongStrProp(Value,Fields[i],BlobData);
        // URI is 'ModelRoot/TableName/ID/BlobFieldName' with PUT method
        if URI(FormatUTF8('%%',[URL,FieldsName[i]]),'PUT',nil,nil,@BlobData).Lo<>200 then
          exit;
................................................................................
    exit;
  end;
  if fValue.Count=0 then
    result := 1 else // default ID for a void table
    result := TSQLRecord(fValue.List[fValue.Count-1]).fID+1; // tricky new ID compute
  Rec := fStoredClass.Create;
  Rec.FillFrom(SentData);
  if (Int64(fIsUnique)<>0) and not AreUniqueFieldsOK(Rec) then begin
    result := 0; // mark error
    Rec.Free;
    exit;
  end;
  Rec.fID := result;
  fValue.Add(Rec);
  fModified := true;
................................................................................
     Owner.OnUpdateEvent(self,seAdd,Rec.RecordClass,result);
end;

function TSQLRestServerStaticInMemory.AreUniqueFieldsOK(Rec: TSQLRecord): boolean;
var F, i: integer;
    Val: RawUTF8;
begin
  if Int64(fIsUnique)<>0 then
  // ensure UNIQUE fields correctness
  with fStoredClassProps do begin
    result := false;
    for F := 0 to High(Fields) do
      if F in fIsUnique then begin
        Val := Fields[F]^.GetValue(Rec,false);
        for i := 0 to fValue.Count-1 do
................................................................................
begin
  assert(aTable<>nil); // should not be called directly, but via PropsCreate()
  Table := aTable;
  SQLTableName := GetDisplayNameFromClass(aTable);
  ClassProp := InternalClassProp(aTable);
  assert(ClassProp<>nil);
  nProps := PClassProp(aTable)^.FieldCountWithParents;
  if nProps>=MAX_SQLFIELDS then // for now, we store Fields in an Int64
    raise Exception.CreateFmt('%s has too many fields: %d>%d',
      [aTable.ClassName,nProps,MAX_SQLFIELDS-1]);
  SetLength(FieldType,nProps);
  SetLength(Fields,nProps);
  SetLength(FieldsName,nProps);
  SetLength(ManyFields,nProps);
  SetLength(SimpleFields,nProps);
  MainField[false] := -1;
  MainField[true] := -1;
................................................................................
  inherited;
end;

function TSQLRecordProperties.FieldIndexsFromRawUTF8(const aFields: array of RawUTF8;
  var Bits: TSQLFieldBits): boolean;
var f,ndx: integer;
begin
  Int64(Bits) := 0;
  result := false;
  if self=nil then
    exit;
  for f := 0 to high(aFields) do begin
    ndx := FieldIndexFromRawUTF8(aFields[f]);
    if ndx<0 then
      exit; // invalid field name

    - enhanced TPropInfo.GetLongStrValue/SetLongStrValue methods, now converting
      RawUnicode, WinAnsiString, TSQLRawBlob and AnsiString properties
    - now ensure that no published property named ID or RowID was defined (this
      unique primary key field must be handled directly by TSQLRecord)
    - TSQLModel implementation speed up, in case of a huge number of registered
      TSQLRecord in the database Model
    - added a magic pattern check to ignore broadcasted WM_COPYDATA message
    - MAX_SQLFIELDS default is still 64, but can now be set to any value (64, 128,
      and 256 are optimized) so that you can have any number of fields in a Table
    - MAX_SQLTABLES default is now 256, i.e. you can have up to 256 tables in a
      TSQLModel instance (you can set any other value, on need)


  String usage in the Synopse SQLite3 database framework:
    - RawUTF8 is used for every internal data usage, since both SQLite3 and
      JSON do expect UTF-8 encoding
    - WinAnsiString where WinAnsi-encoded AnsiString (code page 1252) are needed
    - generic string for i18n (in unit SQLite3i18n), i.e. text ready to be
................................................................................

{ ************ classes to access SQLite3 database data }

const
  /// maximum number of Tables in a Database Model
  // - this constant is used internaly to optimize memory usage in the
  // generated asm code
  MAX_SQLTABLES = 256;

type
  /// used to store bit set for all available Tables in a Database Model


  TSQLFieldTables = set of 0..MAX_SQLTABLES-1;

  /// a String used to store the BLOB content
  // - equals RawByteString for byte storage, to force no implicit charset
  // conversion, thatever the codepage of the resulting string is
  // - will identify a sftBlob field type, if used to define such a published
  // property
................................................................................

/// special comparaison function for sorting sftDateTime
// UTF-8 encoded values in the SQLite3 database or JSON content
function UTF8CompareISO8601(P1,P2: PUTF8Char): PtrInt;

const
  /// Supervisor Table access right, i.e. alllmighty over all fields
  ALL_ACCESS_RIGHTS = [0..MAX_SQLTABLES-1];

  /// Supervisor Database access right, i.e. allmighty over all Tables
  SUPERVISOR_ACCESS_RIGHTS: TSQLAccessRights =
    (GET: ALL_ACCESS_RIGHTS; POST: ALL_ACCESS_RIGHTS;
     PUT: ALL_ACCESS_RIGHTS; DELETE: ALL_ACCESS_RIGHTS);

  /// special TSQLFieldBits value containing all field bits set to 1
................................................................................
    end;
    P[-1] := ')';
  end;
  // Assert(P-pointer(result)=length(result));
end;
var F: integer;
    FU: RawUTF8;
    Fields2, Values: array[0..MAX_SQLFIELDS-1] of RawUTF8;
begin
  result := '';
  if P=nil then
    exit;
  Len := 0;
  if pointer(Fields)=nil then begin
    // get "COL1"="VAL1" pairs, stopping at '}' or ']'
................................................................................
    result := fID;
end;

function TSQLRecord.GetHasBlob: boolean;
begin
  if Self=nil then
    result := false else
    result := not IsZero(@RecordProps.BlobFieldsBits);
end;

function TSQLRecord.GetSimpleFieldCount: integer;
begin
  if Self=nil then
    result := 0 else
    result := length(RecordProps.SimpleFields);
................................................................................
end;
{$endif}

function TSQLRecord.Filter(const aFields: TSQLFieldBits): boolean;
var f, i: integer;
    Value, Old: RawUTF8;
begin
  result := IsZero(@aFields);
  if (self=nil) or result then
    // avoid GPF and handle case if no field was selected
    exit;
  with RecordProps do
  if Filters=nil then
    // no filter set yet -> process OK
    result := true else begin
................................................................................
  aInvalidFieldIndex: PInteger): string;
var f, i: integer;
    Value: RawUTF8;
    Validate: TSynValidate;
    ValidateRest: TSynValidateRest absolute Validate;
begin
  result := '';
  if (self=nil) or IsZero(@aFields) then
    // avoid GPF and handle case if no field was selected
    exit;
  with RecordProps do
  for f := 0 to high(Fields) do
  if not(FieldType[f] in [sftUnknown,sftMany]) then begin
    if (Filters<>nil) and (Filters[f]<>nil) then
      for i := 0 to Filters[f].Count-1 do begin
................................................................................
    BlobData: RawByteString;
    i: integer;
begin
  result := false;
  if (Self=nil) or (Value=nil) or (Value.fID<=0) then
    exit;
  with Value.RecordProps do
  if not IsZero(@BlobFieldsBits) then begin
    URL := FormatUTF8('%/%/%/',[Model.Root,SQLTableName,Value.fID]);
    for i := 0 to high(Fields) do
      if i in BlobFieldsBits then
        // URI is 'ModelRoot/TableName/ID/BlobFieldName' with GET method
        if URI(FormatUTF8('%%',[URL,FieldsName[i]]),'GET',@BlobData).Lo=200 then
          SetLongStrProp(Value,Fields[i],BlobData) else
          exit;
................................................................................
    BlobData: RawByteString;
    i: integer;
begin
  result := false;
  if (Self=nil) or (Value=nil) or (Value.fID<=0) then
    exit;
  with Value.RecordProps do
  if not IsZero(@BlobFieldsBits) then begin
    URL := FormatUTF8('%/%/%/',[Model.Root,SQLTableName,Value.fID]);
    for i := 0 to high(Fields) do
      if i in BlobFieldsBits then begin
        GetLongStrProp(Value,Fields[i],BlobData);
        // URI is 'ModelRoot/TableName/ID/BlobFieldName' with PUT method
        if URI(FormatUTF8('%%',[URL,FieldsName[i]]),'PUT',nil,nil,@BlobData).Lo<>200 then
          exit;
................................................................................
    exit;
  end;
  if fValue.Count=0 then
    result := 1 else // default ID for a void table
    result := TSQLRecord(fValue.List[fValue.Count-1]).fID+1; // tricky new ID compute
  Rec := fStoredClass.Create;
  Rec.FillFrom(SentData);
  if not IsZero(@fIsUnique) and not AreUniqueFieldsOK(Rec) then begin
    result := 0; // mark error
    Rec.Free;
    exit;
  end;
  Rec.fID := result;
  fValue.Add(Rec);
  fModified := true;
................................................................................
     Owner.OnUpdateEvent(self,seAdd,Rec.RecordClass,result);
end;

function TSQLRestServerStaticInMemory.AreUniqueFieldsOK(Rec: TSQLRecord): boolean;
var F, i: integer;
    Val: RawUTF8;
begin
  if not IsZero(@fIsUnique) then
  // ensure UNIQUE fields correctness
  with fStoredClassProps do begin
    result := false;
    for F := 0 to High(Fields) do
      if F in fIsUnique then begin
        Val := Fields[F]^.GetValue(Rec,false);
        for i := 0 to fValue.Count-1 do
................................................................................
begin
  assert(aTable<>nil); // should not be called directly, but via PropsCreate()
  Table := aTable;
  SQLTableName := GetDisplayNameFromClass(aTable);
  ClassProp := InternalClassProp(aTable);
  assert(ClassProp<>nil);
  nProps := PClassProp(aTable)^.FieldCountWithParents;
  if nProps>MAX_SQLFIELDS then 
    raise Exception.CreateFmt('%s has too many fields: %d>%d',
      [aTable.ClassName,nProps,MAX_SQLFIELDS]);
  SetLength(FieldType,nProps);
  SetLength(Fields,nProps);
  SetLength(FieldsName,nProps);
  SetLength(ManyFields,nProps);
  SetLength(SimpleFields,nProps);
  MainField[false] := -1;
  MainField[true] := -1;
................................................................................
  inherited;
end;

function TSQLRecordProperties.FieldIndexsFromRawUTF8(const aFields: array of RawUTF8;
  var Bits: TSQLFieldBits): boolean;
var f,ndx: integer;
begin
  fillchar(Bits,sizeof(TSQLFieldBits),0);
  result := false;
  if self=nil then
    exit;
  for f := 0 to high(aFields) do begin
    ndx := FieldIndexFromRawUTF8(aFields[f]);
    if ndx<0 then
      exit; // invalid field name

    exit; // nothing new
  if Count=0 then begin
    // no data to refresh
    Table.AddedField.Free; // do it once
    Table.AddedField := nil;
  end else begin
    // some data to refresh: guess field added, and process
    Int64(Fields) := 0;
    for F := 0 to Table.FieldCount-1 do
      if Table.AddedField.IndexOf(Table.Field[F])<0 then
        Include(Fields,F);
    Table.AddedField.Free; // do it once
    Table.AddedField := nil;
    RecreateFileContent(Table.UpdateFieldEvent,Fields);
  end;
................................................................................
  if (self=nil) or (Table.AddedField=nil) then
    exit; // nothing new
  if fMetaDataCount=0 then begin // no data to refresh
    Table.AddedField.Free; // do it once
    Table.AddedField:= nil;
    exit;
  end;
  Int64(AvailableFields) := 0;
  for F := 0 to Table.FieldCount-1 do
    if Table.AddedField.IndexOf(Table.Field[F])<0 then
      Include(AvailableFields,F);
  Table.AddedField.Free; // do it once
  Table.AddedField := nil;
  for i := 0 to Count-1 do
    fMetaDataRecords[i] := Table.UpdateFieldRecord(pointer(fMetaDataRecords[i]),AvailableFields);

    exit; // nothing new
  if Count=0 then begin
    // no data to refresh
    Table.AddedField.Free; // do it once
    Table.AddedField := nil;
  end else begin
    // some data to refresh: guess field added, and process
    fillchar(Fields,sizeof(Fields),0);
    for F := 0 to Table.FieldCount-1 do
      if Table.AddedField.IndexOf(Table.Field[F])<0 then
        Include(Fields,F);
    Table.AddedField.Free; // do it once
    Table.AddedField := nil;
    RecreateFileContent(Table.UpdateFieldEvent,Fields);
  end;
................................................................................
  if (self=nil) or (Table.AddedField=nil) then
    exit; // nothing new
  if fMetaDataCount=0 then begin // no data to refresh
    Table.AddedField.Free; // do it once
    Table.AddedField:= nil;
    exit;
  end;
  fillchar(AvailableFields,sizeof(AvailableFields),0);
  for F := 0 to Table.FieldCount-1 do
    if Table.AddedField.IndexOf(Table.Field[F])<0 then
      Include(AvailableFields,F);
  Table.AddedField.Free; // do it once
  Table.AddedField := nil;
  for i := 0 to Count-1 do
    fMetaDataRecords[i] := Table.UpdateFieldRecord(pointer(fMetaDataRecords[i]),AvailableFields);

  - fixed issue in TSynTableFieldProperties: wrong constraint evaluation and
    index refresh at records update
  - faster implementation of Move() for Delphi versions with no FastCode inside
  - great performance improvement in TSynTableFieldProperties for update process
  - new ConvertCaseUTF8(), UpperCaseU(), LowerCaseU(), Int64ToUInt32(),
    GetCardinalDef(), IsValidEmail, IsValidIP4Address(), PatchCodePtrUInt(),
    GetCaptionFromClass(), GetDisplayNameFromClass(), DateTimeToIso8601Text()
    StrUInt32() and StringBufferToUtf8() procedures or functions (with
    associated tests)
  - new grep-like IsMatch() function for basic pattern matching
  - introducing direct content filtering and validation using
    TSynFilterOrValidate dedicated classes, for both TSQLRecord and Big Table
  - filtering is handled via some TSynFilter classes - TSynFilterUpperCase,
    TSynFilterUpperCaseU, TSynFilterLowerCase, TSynFilterLowerCaseU and
    TSynFilterTrim e.g.
................................................................................
  - dedicated TSynTableFieldProperties.Validate method for validation (e.g. a
    TSynValidateTableUniqueField instance is created if tfoUnique is in Options)
  - dedicated TSynTableFieldProperties.Filter method for filtering (using
    common TSynFilter classes, working at UTF-8 Text content)
  - introducing the GarbageCollector TObjectList for handling a global garbage
    collector for instances which must live during the whole executable process
    (used e.g. to avoid a memory leak for "class var" or such variables)
  - new BinToBase64, Base64ToBin and IsBase64 conversion functions
  - new low-level RTTI functions for handling record types: RecordEquals,
    RecordSave, RecordSaveLength, RecordLoad
  - new TDynArray object, which is a wrapper around any dynamic array: you can
    now access to the dynamic array using TList-like properties and methods,
    e.g. Count, Add, Insert, Delete, Clear, IndexOf, Find, Sort and some
    new methods like LoadFromStream, SaveToStream, LoadFrom and SaveTo which
    allow fast binary serialization of any dynamic array, even containing
    strings or records; a CreateOrderedIndex method is also available to
    create individual index according to the dynamic array content; and any
    dynamic array can be serialized as UTF-8 JSON via TTextWriter.AddDynArrayJSON
    and TDynArray.LoadFromJSON methods 

}


{$I Synopse.inc} // define HASINLINE USETYPEINFO CPU32 CPU64 OWNNORMTOUPPER

interface
................................................................................
function Pos(const substr, str: RawUTF8): Integer; overload; inline;
{$endif}

{$endif LVCL}
{$endif PUREPASCAL}

{$endif ENHANCEDRTL}


/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only usefull if our Enhanced Runtime (or LVCL) library is not installed
function Int64ToUtf8(Value: Int64): RawUTF8;

/// use our fast RawUTF8 version of IntToStr()
................................................................................



{ ****************** text buffer and JSON functions and classes ********* }

const
  /// maximum number of fields in a Table

  // - this constant is used internaly to optimize memory usage in the
  // generated asm code, and to map TSQLFieldBits into an Int64
  MAX_SQLFIELDS = 64;

  /// number of entries in the TSynCache, 256 is big enough on practice
  // - code is somewhat faster and easier with a fixed cache size
  // - don't make the cache too big: may consume too much memory
  MAX_SYNCACHE = 256;

................................................................................
  JSON_BASE64_MAGIC_QUOTE = ord('"')+cardinal(JSON_BASE64_MAGIC) shl 8;

  /// '"' + UTF-8 encoded \uFFF0 special code
  JSON_BASE64_MAGIC_QUOTE_VAR: cardinal = JSON_BASE64_MAGIC_QUOTE;

type
  /// used to store bit set for all available fiels in a Table
  // - with current MAX_SQLFIELDS value, uses 8 bytes of memory, therefore is
  // sometimes mapped to an Int64
  TSQLFieldBits = set of 0..MAX_SQLFIELDS-1;



  /// simple writer to a Stream, specialized for the TEXT format
  // - use an internal buffer, faster than string+string
  // - some dedicated methods is able to encode any data with JSON escape
  TTextWriter = class
  protected
    B, BEnd: PUTF8Char;
................................................................................
procedure SetBit64(var Bits: Int64; aIndex: PtrInt);
  {$ifdef PUREPASCAL} {$ifdef HASINLINE}inline;{$endif} {$endif}

/// unset/clear a particular bit into a Int64 bit array (max aIndex is 63)
procedure UnSetBit64(var Bits: Int64; aIndex: PtrInt);
  {$ifdef PUREPASCAL} {$ifdef HASINLINE}inline;{$endif} {$endif}









{ ************ fast ISO-8601 types and conversion routines }

/// Date/Time conversion from ISO-8601
// - handle 'YYYYMMDDThhmmss' and 'YYYY-MM-DD hh:mm:ss' format
function Iso8601ToDateTime(const S: RawUTF8): TDateTime;
................................................................................
var tmp: RawUTF8;
    err: integer;
begin
  result := UrlDecodeValue(U, Upper, tmp, Next);
  if result then
    Value := GetExtended(pointer(tmp),err);
end;


































function Hash32(const Text: RawByteString): cardinal;
{$ifdef PUREPASCAL} // this code is quite as fast as the optimized asm below
function SubHash(P: PCardinalArray): cardinal;
{$ifdef HASINLINE}inline;{$endif}
var s1,s2: cardinal;
    i, L: PtrInt;
................................................................................
    Check(UpperCase(U)=RawUTF8(SysUtils.UpperCase(string(U))));
    {$endif}
    Check(StringToUTF8(UTF8ToString(U))=U);
    if U='' then
      continue;
    Check(UnQuoteSQLString(pointer(QuotedStr(U,'"')),res)<>nil);
    Check(res=U);



  end;
  Check(UnQuoteSQLString('"one two"',U)<>nil);
  Check(U='one two');
  Check(UnQuoteSQLString('one two',U)<>nil);
  Check(U='ne tw');
  Check(UnQuoteSQLString('"one "" two"',U)<>nil);
  Check(U='one " two');
................................................................................
  AfterFieldModif;
end;

function TSynTable.CreateJSONWriter(JSON: TStream; Expand, withID: boolean;
  const Fields: TSQLFieldBits): TJSONWriter;
var i, n: integer;
begin
  if (self=nil) or ((Int64(Fields)=0) and not withID) then begin
    result := nil; // no data to retrieve
    exit;
  end;
  // get col max count
  if withID then
    n := 1 else
    n := 0;
................................................................................
function TSynTable.IterateJSONValues(Sender: TObject; Opaque: pointer;
  ID: integer; Data: pointer; DataLen: integer): boolean;
var Statement: TSynTableStatement absolute Opaque;
    F: TSynTableFieldProperties;
    FIndex: cardinal;
begin  // note: we should have handled -2 (=COUNT) case already
  if (self=nil) or (Statement=nil) or (Data=nil) or
     (Statement.WhereValueSBF='') or (Int64(Statement.Fields)=0) then begin
    result := false;
    exit;
  end;
  result := true;
  FIndex := Statement.WhereField;
  if FIndex=0 then begin
    if ID<>Statement.WhereValueInteger then
................................................................................
    GetFieldProp;
    TableName := Prop;
    WhereField := -2;      // mark COUNT(*)
    WhereValue := 'COUNT'; // not void
    exit;
  end else begin
    withID := false;
    Int64(Fields) := 0;
    if not SetFields then
      exit else // we need at least one field name
      if P^=',' then
      repeat
        while P^ in [',',' '] do inc(P); // trim left
      until not SetFields; // add other CSV field names
  end;

  - fixed issue in TSynTableFieldProperties: wrong constraint evaluation and
    index refresh at records update
  - faster implementation of Move() for Delphi versions with no FastCode inside
  - great performance improvement in TSynTableFieldProperties for update process
  - new ConvertCaseUTF8(), UpperCaseU(), LowerCaseU(), Int64ToUInt32(),
    GetCardinalDef(), IsValidEmail, IsValidIP4Address(), PatchCodePtrUInt(),
    GetCaptionFromClass(), GetDisplayNameFromClass(), DateTimeToIso8601Text()
    StrUInt32(), StringBufferToUtf8() IsZero() procedures or functions (with
    associated tests)
  - new grep-like IsMatch() function for basic pattern matching
  - introducing direct content filtering and validation using
    TSynFilterOrValidate dedicated classes, for both TSQLRecord and Big Table
  - filtering is handled via some TSynFilter classes - TSynFilterUpperCase,
    TSynFilterUpperCaseU, TSynFilterLowerCase, TSynFilterLowerCaseU and
    TSynFilterTrim e.g.
................................................................................
  - dedicated TSynTableFieldProperties.Validate method for validation (e.g. a
    TSynValidateTableUniqueField instance is created if tfoUnique is in Options)
  - dedicated TSynTableFieldProperties.Filter method for filtering (using
    common TSynFilter classes, working at UTF-8 Text content)
  - introducing the GarbageCollector TObjectList for handling a global garbage
    collector for instances which must live during the whole executable process
    (used e.g. to avoid a memory leak for "class var" or such variables)
  - new BinToBase64, Base64ToBin and IsBase64 *fast* conversion functions
  - new low-level RTTI functions for handling record types: RecordEquals,
    RecordSave, RecordSaveLength, RecordLoad
  - new TDynArray object, which is a wrapper around any dynamic array: you can
    now access to the dynamic array using TList-like properties and methods,
    e.g. Count, Add, Insert, Delete, Clear, IndexOf, Find, Sort and some
    new methods like LoadFromStream, SaveToStream, LoadFrom and SaveTo which
    allow fast binary serialization of any dynamic array, even containing
    strings or records; a CreateOrderedIndex method is also available to
    create individual index according to the dynamic array content; and any
    dynamic array can be serialized as UTF-8 JSON via TTextWriter.AddDynArrayJSON
    and TDynArray.LoadFromJSON methods

}


{$I Synopse.inc} // define HASINLINE USETYPEINFO CPU32 CPU64 OWNNORMTOUPPER

interface
................................................................................
function Pos(const substr, str: RawUTF8): Integer; overload; inline;
{$endif}

{$endif LVCL}
{$endif PUREPASCAL}

{$endif ENHANCEDRTL}


/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only usefull if our Enhanced Runtime (or LVCL) library is not installed
function Int64ToUtf8(Value: Int64): RawUTF8;

/// use our fast RawUTF8 version of IntToStr()
................................................................................



{ ****************** text buffer and JSON functions and classes ********* }

const
  /// maximum number of fields in a Table
  // - default is 64, but can be set to any value (64, 128 and 256 are optimized)
  // - this constant is used internaly to optimize memory usage in the
  // generated asm code
  MAX_SQLFIELDS = 64;

  /// number of entries in the TSynCache, 256 is big enough on practice
  // - code is somewhat faster and easier with a fixed cache size
  // - don't make the cache too big: may consume too much memory
  MAX_SYNCACHE = 256;

................................................................................
  JSON_BASE64_MAGIC_QUOTE = ord('"')+cardinal(JSON_BASE64_MAGIC) shl 8;

  /// '"' + UTF-8 encoded \uFFF0 special code
  JSON_BASE64_MAGIC_QUOTE_VAR: cardinal = JSON_BASE64_MAGIC_QUOTE;

type
  /// used to store bit set for all available fiels in a Table
  // - with current MAX_SQLFIELDS value, 256 bits uses 64 bytes of memory

  TSQLFieldBits = set of 0..MAX_SQLFIELDS-1;

  PSQLFieldBits = ^TSQLFieldBits;

  /// simple writer to a Stream, specialized for the TEXT format
  // - use an internal buffer, faster than string+string
  // - some dedicated methods is able to encode any data with JSON escape
  TTextWriter = class
  protected
    B, BEnd: PUTF8Char;
................................................................................
procedure SetBit64(var Bits: Int64; aIndex: PtrInt);
  {$ifdef PUREPASCAL} {$ifdef HASINLINE}inline;{$endif} {$endif}

/// unset/clear a particular bit into a Int64 bit array (max aIndex is 63)
procedure UnSetBit64(var Bits: Int64; aIndex: PtrInt);
  {$ifdef PUREPASCAL} {$ifdef HASINLINE}inline;{$endif} {$endif}

/// returns TRUE if all bytes equal zero
function IsZero(P: pointer; Length: integer): boolean; overload;

/// returns TRUE if no bit inside this TSQLFieldBits is set
function IsZero(Fields: PSQLFieldBits): boolean; overload;
  {$ifdef HASINLINE}inline;{$endif}


{ ************ fast ISO-8601 types and conversion routines }

/// Date/Time conversion from ISO-8601
// - handle 'YYYYMMDDThhmmss' and 'YYYY-MM-DD hh:mm:ss' format
function Iso8601ToDateTime(const S: RawUTF8): TDateTime;
................................................................................
var tmp: RawUTF8;
    err: integer;
begin
  result := UrlDecodeValue(U, Upper, tmp, Next);
  if result then
    Value := GetExtended(pointer(tmp),err);
end;

function IsZero(P: pointer; Length: integer): boolean;
var i: integer;
begin
  result := false;
  for i := 1 to Length shr 4 do // 16 bytes (4 DWORD) by loop - aligned read
    if (PCardinalArray(P)^[0]<>0) or (PCardinalArray(P)^[1]<>0) or
       (PCardinalArray(P)^[2]<>0) or (PCardinalArray(P)^[3]<>0) then
      exit else
      inc(PtrUInt(P),16);
  for i := 1 to Length and 15 do
    if PByte(P)^<>0 then
      exit else
      inc(PtrUInt(P));
  result := true;
end;

{$warnings off}
function IsZero(Fields: PSQLFieldBits): boolean; overload;
begin
  result := (Fields<>nil) and
  {$if MAX_SQLFIELDS=64}
    (PInt64(Fields)^=0)
  {$elseif MAX_SQLFIELDS=128}
    (PInt64Array(Fields)^[0]=0) and (PInt64Array(Fields)^[1]=0)
  {$elseif MAX_SQLFIELDS=256}
    (PInt64Array(Fields)^[0]=0) and (PInt64Array(Fields)^[1]=0) and
    (PInt64Array(Fields)^[2]=0) and (PInt64Array(Fields)^[3]=0)
  {$else}
     IsZero(Fields,sizeof(TSQLFieldBits))
  {$ifend}
end;
{$warnings on}

function Hash32(const Text: RawByteString): cardinal;
{$ifdef PUREPASCAL} // this code is quite as fast as the optimized asm below
function SubHash(P: PCardinalArray): cardinal;
{$ifdef HASINLINE}inline;{$endif}
var s1,s2: cardinal;
    i, L: PtrInt;
................................................................................
    Check(UpperCase(U)=RawUTF8(SysUtils.UpperCase(string(U))));
    {$endif}
    Check(StringToUTF8(UTF8ToString(U))=U);
    if U='' then
      continue;
    Check(UnQuoteSQLString(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)));
  end;
  Check(UnQuoteSQLString('"one two"',U)<>nil);
  Check(U='one two');
  Check(UnQuoteSQLString('one two',U)<>nil);
  Check(U='ne tw');
  Check(UnQuoteSQLString('"one "" two"',U)<>nil);
  Check(U='one " two');
................................................................................
  AfterFieldModif;
end;

function TSynTable.CreateJSONWriter(JSON: TStream; Expand, withID: boolean;
  const Fields: TSQLFieldBits): TJSONWriter;
var i, n: integer;
begin
  if (self=nil) or (IsZero(@Fields) and not withID) then begin
    result := nil; // no data to retrieve
    exit;
  end;
  // get col max count
  if withID then
    n := 1 else
    n := 0;
................................................................................
function TSynTable.IterateJSONValues(Sender: TObject; Opaque: pointer;
  ID: integer; Data: pointer; DataLen: integer): boolean;
var Statement: TSynTableStatement absolute Opaque;
    F: TSynTableFieldProperties;
    FIndex: cardinal;
begin  // note: we should have handled -2 (=COUNT) case already
  if (self=nil) or (Statement=nil) or (Data=nil) or
     (Statement.WhereValueSBF='') or IsZero(@Statement.Fields) then begin
    result := false;
    exit;
  end;
  result := true;
  FIndex := Statement.WhereField;
  if FIndex=0 then begin
    if ID<>Statement.WhereValueInteger then
................................................................................
    GetFieldProp;
    TableName := Prop;
    WhereField := -2;      // mark COUNT(*)
    WhereValue := 'COUNT'; // not void
    exit;
  end else begin
    withID := false;
    fillchar(Fields,sizeof(Fields),0);
    if not SetFields then
      exit else // we need at least one field name
      if P^=',' then
      repeat
        while P^ in [',',' '] do inc(P); // trim left
      until not SetFields; // add other CSV field names
  end;