• fixed issue in case of GetTickCount() value change
• official version updated to 1.18

• added regression tests for variants parameters in interface-based services
• some fixes about variants parameters in interface-based services

• added process of Variant and WideString types in TSQLRecord properties (as sftVariant and sftRaWUYTF8)
• TSQLPropInfo*.SetValue() now expect an additional wasString: boolean parameter
• TSQLPropInfo*.SameValue() is replaced by more versatile TSQLPropInfo*.CompareValue()

• included some unit tests like TTestLowLevelTypes and TTestBasicClasses, previously included in SQLite3Commons.pas or TTestLowLevelCommon, extracted from SynCommons.pas, or TTestSQLite3Engine from SQLite3.pas
• expose all internal Hash*() functions (following TDynArrayHashOne prototype) in interface section of the SynCommons.pas unit
• added TypeInfo, ElemSize, ElemType read-only properties to TDynArray
• added TSynLogFile.Freq read-only property
• added TDynArrayHashed.HashElement property

• TInterfaceStub.Expects*() rules will now raise an Exception on failure
• NotifyDestroy() callbacks will now raise abort exceptions like EAccessViolation or EInterfaceStub in destructor TInterfacedObjectFake.Destroy
• TInterfaceStub logs text format will avoid adding '=[]' for procedure kind of methods

• added TInterfaceStub.ExpectsCount() methods - to be used mainly for mocking interfaces
• several fixes and enhancements of implementation and tests

* introducing TInterfaceStub and TInterfaceMock classes to define high-performance interface stubbing and mocking via a fluent interface * added dedicated EInterfaceFactoryException * added TServiceMethod.DefaultResult property, to be used for stubs/mocks * TServiceFactory.Create() and its children will now alwyas have an optional aContractExpected parameter (for consistency with TServiceFactoryClient)

• TInterfaceFactory instances are now shared among all interface-based features (e.g. services, callbacks or mocks/stubs), in a thread-safe cache
• new TInterfaceFactory.CreateFakeInstance() method for easy mocking of any interface, via some event callbacks

• speedup of QuotedStr() function
• several speedup in GetJSONField() and JSON parsing: it will now expect true, false or null to be in lowercase only (as in json.org specifications)

• added TSQLModel.URIMatch() method to allow sub-domains generic matching at database model level (so that you can set root='/root/sub1' URIs)
• TSQLite3HttpServer now handles sub-domains generic matching (via TSQLModel.URIMatch call) at database model level (e.g. you can set root='/root/sub1' URIs)

• TSynTableStatement.Create SQL statement parser will handle optional LIMIT clause (in new FoundLimit integer property)
• fixed issue in TSQLRestServerStaticInMemory.GetJSONValues(), and handle optional LIMIT clause in this very same method
• fix samples run issue, introduced by http://blog.synopse.info/post/2012/08/31/Breaking-change-of-%2AFillPrepare%28%29-method-parameters

• huge code refactoring of the ORM model implementation: a new dedicated TSQLModelRecordProperties will contain per-TSQLModel parameters, whereas shared information retrieved by RTTI remain in TSQLRecordProperties - this will allow use of the same TSQLRecord in several TSQLModel at once, with dedicated SQL auto-generation, external DB settings and filter/validation
• added aExternalTableName/Database parameters to TSQLModel.VirtualTableRegister()

• added virtual TSQLRestServer.BeginCurrentThread method
• added new TServiceMethod.ExecutionOptions member, and the new TServiceMethodExecutionOption[s] types - used by ExecuteInMainThread()
• added TServiceFactoryServer.ExecuteInMainThread() method, to force a method to be executed with RunningThread.Synchronize() call on multi-thread server instances (e.g. TSQLite3HttpServer or TSQLRestServerNamedPipeResponse)
• refactoring of TServiceMethod.InternalExecute low-level asm implementation
• added THttpServerGeneric.OnHttpThreadStart property, and associated TNotifyThreadEvent event prototype

• added virtual TSQLRestServer.EndCurrentThread method and TSQLRestServerStaticExternal.EndCurrentThread overriden method which will be called e.g. by TSQLite3HttpServer for each terminating threads, to release any thread-specific resources (for instance, external connections external connection resource as defined by TSQLDBConnectionPropertiesThreadSafe)
• TSQLite3HttpServer will now call virtual TSQLRestServer.EndCurrentThread method in each of its terminating threads, to release any thread-specific resources (for instance, external connections in SQlite3DB)

• new DateToSQL() and DateTimeToSQL() functions, returning a string with a JSON_SQLDATE_MAGIC prefix and proper UTF-8 / ISO-8601 encoding to be inlined as ? bound parameter in any SQL query (allow binding of date/time parameters as request by some external database engine which does not accept ISO-8601 text in this case)
• ExtractInlineParameters() and SQLParamContent() decode ':("\uFFF12012-05-04"):' inlined parameters (i.e. text starting with JSON_SQLDATE_MAGIC after UTF-8 encoding) as sftDateTime kind of parameter
• inlined parameters in any SQL query will bind explicitely TDateTime values if the parameter is transmitted as DateToSQL() or DateTimeToSQL() TEXT
• documentation update about parameter binding (and date/time handling)

• added TSQLRecordProperties.HasTypeFields containing set of field types appearing in the record - replaces HasModTimeFields and HasCreateTimeField
• enhanced TJSONObjectDecoder to handle directly prepared SQL statements for external databases (used by SQLite3DB unit)

• fixed ticket [8dc4d49ea9] in TSQLDataBase.GetFieldNames()about result array truncated to 64
• fixed non created index issue in TSQLRestServer.CreateSQLMultiIndex()

• now unique fields are hashed in TSQLRestServerStaticInMemory implementation: "stored: false" properties are now checked for unicity before adding or update, and search will use the hash table for very fast O(1) process - resulting speed is amazing: there is almost no speed penalty in bulk adding, and overall speed beat other DB engines
• new TPropInfo.GetHash and TPropInfo.SameValue methods, with optional case sentivity handling
• new TListFieldHash class for efficient O(1) search using hashing handling
• speed optimization: all TSQLRestServerStaticInMemory search methods will now call a generic FindWhereEqual() for better code speed and maintenance
• "15 - External DB performance" sample updated to test and benchmark the "stored: false" properties speed

• TSQLRestServerStaticInMemory.GetJSONValues will now generate expanded JSON content, if specified (only non-expanded format was implemented)
• several JSON serialization speed-ups

• changed the non expanded JSON format to use lowercase first column names: {"fieldCount":1,"values":["col1"... instead of {"FieldCount":1,"Values":[..
• fixed regression issue about FTS virtual tables not working any more

• new TSQLDBStatement.BindArray() methods, introducing array binding for faster database batch modifications (only implemented in SynDBOracle by now)
• added TSQLDBConnectionProperties.EngineName property
• added TSQLDBConnectionProperties.BatchSendingAbilities property to define the CRUD modes available in batch sending (see e.g. Oracle's array bind, or MS SQL bulk insert feature)
• now TSQLDBOracleConnectionProperties.Create constructor can be used directly
• previous TSQLDBOracleConnectionProperties reintroduced constructor renamed CreateWithCodePage, to specify the code page to be used
• internal cache added in TSQLRest.GetServerTimeStamp method for better speed
• implemented transaction process for (external database) virtual tables
• fixed issue in TSQLDBOracleStatement.ColumnToVarData when retrieving date time fields from Oracle as external virtual tables
• new TOracleDate.From/ToIso8601 methods for direct SQLT_DAT handling

• TSynCache.Reset now returns a boolean stating if something was flushed
• added TSQLRestServerStatic.InternalBatchStart / InternalBatchStop methods to handle fast grouped sending to remote database engine (e.g. Oracle bound arrays or MS SQL bulk insert via SynDB)
• fix FlushInternalDBCache method not properly called with TSQLRestServerStaticInMemoryExternal update/delete/insert calls

• fixed ticket [fdf7158601] - about incorrect null value parsing in JSONToObject when isObj = oCustom (fix by mpv - thanks!)
• fixed ticket [a1d9e9148e] - about incorrect reading empty JSON object by JSONToObject (fix by mpv - thanks!)

• added BlobToBytes() function and TSQLTable.GetBytes/GetStream methods
• enhanced TDataSet generation to properly handle Int64 column content
• enhanced TDataSet generation to properly handle BLOB content under Delphi 2009+

• added ReplaceRowIDWithID optional parameter to GetJSONObjectAsSQL(), in order to allow working with external DB not allowing RowID (e.g. Oracle)
• changed column named 'RowID' into 'ID' since it is reserved e.g. in Oracle

• CopyObject() procedure now handle TCollection kind of object not only as sub properties
• introducing TInterfacedCollection dedicated class, properly handling collection item creation on the Server side, with interface-based services: all contract operations shall use it instead of TCollection

• added ObjectFromInterface() function working also with TInterfacedObjectFake
• introducing SetWeak() function to handle Weak interface assignment
• create generic parent TInterfaceFactory class, for a common way of retrieving interface RTTI

• fixed naming of framework in units header
• fixed incorrect call to FormatUTF8() - see [d74020f7c3]

• allow rest to any class or dynamic array custom JSON serialization to the default serializer (by setting nil to both Reader and Writer callbacks)
• enhanced documentation and regression tests, about custom class JSON serialization

• fix execution issue in TSQLRestServer.AfterDeleteForceCoherency()
• fix screen refresh issue on record deletion in SynFile demo

• now interface based services are responding with GET commands in additional to POST verb
• Custom returned content (i.e. TServiceCustomAnswer) is now handled as expected by the Delphi client (i.e. TServiceFactoryClient class)

• TSQLRestServer.ServiceRegister(aClient: TSQLRest...) for a remote access
• added function IsNotAjaxJSON() function - formerly internal IsExpanded()
• fixed potential issue of misleaded client side remote content

• fixed issues in function IsJSONString() which returned TRUE for '-' or '+', or false positives in some border-line cases (due to wrong uppercase guess): now this function is split into IsString() and IsStringJSON() functions to explicitely handle null/false/true constant recognition
• fixed potential false positives of null/false/true in function GetJSONField
• fix potential formating issue in TSQLTable.GetJSONValues/GetCSVValues methods which may create some wrong formating if TEXT is null/false/true (were formerly recognized as JSON keywords, whereas it should have already been transformed into nil, '0' or '1')

• added TSQLRestServerRemoteDB class to implement a REST server using a remote TSQLRestClient connection for all its ORM process: can be used e.g. to publish services with a dedicated process in a DMZ
• deep refactoring of TSQLRestClient / TSQLRestClientURI methods, for better compliance with the Liskov substitution principle (LSP)

• TSQLRestServerFullMemory class now handling persistence on both JSON and binary files - also updated samples and documentation to take notivce of this new class
• new ReadStringFromStream() and WriteStringToStream() functions in SynCommons.pas

• new RawUTF8ArrayToQuotedCSV() functions
• new TSQLRest.MainFieldIDs() method
• refactoring of all security code in TServiceFactoryServer Allow* / Deny* methods

• new TRawUTF8ListHashed class, with extend TRawUTF8List by using an internal hash table to optimized IndexOf() method call (including case sensitivity)
• introducing security features for our interface-based implementation: a per interface, per method, and per authentication user group security policy can be easily implemented (with associated regression tests)

• TSQLRestServer published method names are now hash-stored for speed
• introduced TSQLRestServerSessionContext structure to include current User and Group ID to the execution context (in addition to the Session ID)

• now the TSQLAuthUser instance retrieved during the session opening will retrieve the Data BLOB field (ready to be consummed on the server side)
• new ServiceContext global threadvar, able to access the server-side remote process which created a service instance
• several bug fixes and enhancements

• JSONDecode() overloaded functions now accept parameter names without case sensibility
• added interface-based remote service implementation tests in order to enhance SOA coverage
• now JSONToObject/ObjectToJSON functions and WriteObject method will handle standard TPersistent class serialization into/from JSON object (and therefore our SOA interfaces can serialize any TPersistent class, in addition to TSQLRecord instances)
• interfaces (aka SOA contracts) shall not inherit from IService any more
• interfaces (aka SOA contracts) can now inherit from other interfaces (all methods will be available remotely)
• server-side implementation class can now be directly inheriting from TObject (not only TInterfacedObject)
• method names are now hashed for faster execution on the server side
• contract layout changed to be less Delphi-dependent (e.g. use "in" or "out" instead of "const" or "var")
• sicClientDriven is now functional (several implementation bugs fixed), with included regression tests
• fixed issue about wrong "self" value transmitted to the server implementation class

• now interface definition allows records within parameters
• fixed issues when floating-point values were returned from an interface method
• much more complete test coverage (and therefore a few bug fixes, including dynamic arrays handling)
• new TRecordType definition, and TTypeinfo.RecordType associated method
• new TTextWriter.WrRecord method for direct adding of a Base-64 record content

• service interface methods now accept enumerations and sets (with explicit type)
• service contract will now include the whole type name for arguments requiring it (e.g. sets, enumerates, objects, dynamic arrays)
• service contract property of TServiceFactory class renamed "Contract" instead of "Signature"
• some code refactoring

• added GetEnumNameTrimed() function
• added the service "contract" feature, to ensure compatibility between client and server

• added dedicated Exception classes (ESynException, ETableDataException) in SynCommons
• added dedicated Exception classes (EORMException, EParsingException, ESecurityException, ECommunicationException, EBusinessLayerException, EServiceException) all inheriting from SynCommons.ESynException
• renamed ESQLException into ESQLite3Exception
• fixed potential GPF issue in Hash32() function
• Client-side implementation of remote Interface access now is able to create "fake" classes in order to emulate native interfaces - the stubbing code (i.e. asm generated on the fly) is IMHO simple and great: it can be proudly compared to Embarcadero's Rio or Rtti unreadable units :)

• added TSQLRestCache.SetCache(aRecord: TSQLRecord) overloaded method;
• updated documentation (general table of contents + CRUD caching)

• optimized CRUD/ORM level Client and Server caching
• updated corresponding documentation
• added some dedicated regression tests

• added TSQLRestClientURI.ServerCacheFlush method to handle remote server side cache
• the TSQLRestServerCallBack method prototype has been modified to supply "var aParams: TSQLRestServerCallBackParams: cardinal" as unique parameter: this is a CODE BREAK change and you shall refresh ALL your server-side code to match the new signature (using a record passed by value as parameter will ensure faster code and seamless evolution of this structure)

• TSQLRestServerStaticInMemory binary format changed: now will store its content per field (to ensure better compression) - magic identifier changed
• introducing TSQLRest.Cache and TSQLRestCache class to handle Client or Server side fast in-memory cache (with tuned configuration and timeout)

• fixed rounding issue in ExtendedToString() and all corresponding wrappers like DoubleToStr*, Add(aDouble)..
• get rid of wrong "Decimal" parameter in float to text conversion

• SynDbExplorer now executes selected text statement (very convenient)
• added UTF-8 BOM to CSV or TXT exports

• fixed issue TSynTableStatement when only one column was retrieved
• fix issue about transactions not working with TSQLRestServerStaticInMemory
• fixed issue in TSQLRestServerStaticInMemory on SELECT with only one column
• now TSQLRestClientURI.BatchUpdate() will set only ID, TModTime and mapped fields when called over a TSQLRecord on which a FillPrepare() was made (and no FillClose was performed)

• the TSQLRestServerCallBack method prototype has been modified to supply an addition aSession: cardinal parameter: this is a CODE BREAK change and you shall refresh ALL your server-side code to match the new signature
• new TSQLRestServer.SessionGetUser method to be used e.g. by any TSQLRestServerCallBack method implementation to retrieve the connected user
• fix issue about abusive session timeout: TSQLRestServer.SessionGet is now renamed SessionAccess and refreshes the session access timestamp each time a session is retrieved

• TSQLRestClient.List and ListFmt methods now use TSQLRecordClass open array instead of TClass (for consistency)
• new global RecordClassesToClasses() wrapper function to convert an array of TSQLRecordClass into the expected array of TClass
• now TSQLRestServer.Auth service returns true JSON response as specified by its content type (for better AJAX compatibility)

• added TSQLOccasion to handle the special case of field type (like TCreateTime) in case of Upate/Insert/Select
• TCreateTime published fields now are not modified at update

• new overloaded TSQLRestServer/TSQLRestServerStatic.UpdateField() method
• fixed TSQLRestServerDB.UpdateField(ByID=true) implementation
• new overloaded TSQLRestServerDB.UpdateField method

• new UnicodeComparison parameter in TSQLTable.SearchValue to handle property non WinAnsi (code page 1252) characters
• fixed potential issue in TSQLTable.SearchValue in case of invalid Client supplied parameter (now checks TSQLRest class type)

• new FormatUTF8() overloaded function, handling both '%' and '?' parameters (inserting '?' as inlined :(...): parameters, with proper string quote) - with associated regression tests
• new TSQLRecord.Create, TSQLRecord.FillPrepare, TSQLRecord.CreateAndFillPrepare, TSQLRest.OneFieldValue, TSQLRest.MultiFieldValues, TSQLRestClient.EngineExecuteFmt and TSQLRestClient.ListFmt overloaded methods, accepting both '%' and '?' characters in the SQL WHERE format text, inlining '?' parameters with :(...): and auto-quoting strings

• new TSQLDBConnection.ServerTimeStamp property, which will return the external database Server current date and time as TTimeLog/Int64 value (current implementation handle Oracle, MSSQL and MySQL database engines - with SQLite3, this will be the local PC time, just as for other DB engines)
• new ColumnTimeStamp method for TSQLDBStatement/ISQLDBRows, returning a TTimeLog/Int64 value for a date/time column
• new sftModTime / TModTime published field type in TSQLRecord, which will be set to the current server time stamp before update/adding
• new TSQLRest.ServerTimeStamp property, which will return the current server time as TTimeLog/Int64 value (will use the new /TimeStamp RESTful service to retrieve the exact server time)

• TSynTests now writes the elapsed time in each test in the final report
• new TSQLDBSQLite3ConnectionProperties.UseCache property (TRUE by default)
• enhanced cache in SynDBSQLite3 unit
• better testing of External DB access via Virtual tables
• statement cache is now shared with SynDBSQLite3, via the new TSQLStatementCached object as defined in SynSQLite3.pas
• now TSQLRestServerDB will unregister any TSQLVirtualTableModuleServerDB to avoid random GPF in TSQLVirtualTable.Destroy
• CreateSQLMultiIndex and CreateSQLIndex methods now working on external DB virtual tables (using SynDB.TSQLDBConnectionProperties.SQLAddIndex)
• enhanced destructor TSQLVirtualTable.Destroy

• TSQLDBStatement class now expects a prepared statement behavior, therefore TSQLDBStatementPrepared class has been merged into its parent class, and inherited classes have been renamed TSQLDBStatementWithParams[AndColumns]
• new TSQLDBConnectionProperties.SQLAddIndex method
• new TSQLDBConnectionProperties.NewThreadSafeStatementPrepared and TSQLDBConnection.NewStatementPrepared methods, able to be overriden to implement a SQL statement caching (used e.g. for SynDBSQLite3)
• SynDBSQLite3 unit now implements an internal cache of SQL statement: this will speed up the queries a lot (but parameters should be bound in order to profit from this cache)
• new overloaded TSQLDBStatement.Bind() method, which can bind an array of const (i.e. an open list of Delphi arguments) to a statement
• new TSQLStatementCached object, for caching of prepared SQLite3 statements
• new TTestSQLite3ExternalDB class to test TSQLRecordExternal records, i.e. external DB access from the mORMot framework (use an in-memory SQLite3 database as an external SynDB engine for fast and reliable testing)

• new overloaded TSQLDBStatement.Execute() method, able to mix % and ? parameters in the SQL statement
• new TSQLDBStatement.BindNull() method
• new overloaded TSQLDBStatement.Bind() method, able to bind values from a TVarDataDynArray (used e.g. for fast binding SQLite3 virtual table columns)
• added TSQLRequest.BindNull method and associated sqlite3_bind_null function
• TSQLRestServer.UpdateField now accepts to search by ID or by value (used e.g. by rewritten TSQLRestServer.AfterDeleteForceCoherency method)
• TSQLRestServer.UpdateField now accepts to search by ID or by value (used e.g. by rewritten TSQLRestServer.AfterDeleteForceCoherency method)
• new ExtractInlineParameters procedure to handle :(1234): SQL statements
• new TSQLRecordProperties.SQLUpdateSet property
• SQLite3DB.pas unit completed and a lot enhanced (especially in speed optimization)

• new TSQLDBConnectionProperties.SQLCreate/SQLAddColumn virtual methods, using protected SQLFieldCreate virtual method to retrieve the SQL field definition from protected fSQLCreateField[Max] properties: SQL statement generation as requested for mORMot is now much more generic than previously
• fix several issues in SynDB/SynOleDB units

• new TSQLDBConnectionProperties.SQLIso8601ToDate virtual method
• SynDBExplorer now add a SQL filter when double-clicking on a grid result cell (with correct text/numerical/date format handling) - very handy ;)

• the shared fTempMemoryStream is not available any more (not thread-safe)
• new TSQLRest.AcquireWrite/ReleaseWrite protected methods, used by TSQLRestServer.URI to safely write to the DB (e.g. for POST/PUT/DELETE...) with TSQLRest.AcquireWriteTimeOut, both thread-safe and transaction-safe
• TSQLRest.TransactionBegin / Commit / RollBack methods now expect a SessionID parameter in order to allow safe concurent access: writing to the database is queued within a single client session
• fixed issue with TAuthSession.IDCardinal=0 after 76 connections
• updated documentation

• new TSQLTable.GetCSVValues method
• GetJSONValues() is now using an internal TRawByteStringStream when the expected result is a RawUTF8 (avoid copying content twice, and is perfectly thread-safe)
• the shared fTempMemoryStream is not available any more (not thread-safe)
• TTextWriter.CreateOwnedStream now create an internal TRawByteStringStream instance for faster process and direct retrieval in the Text method
• JSONEncode*() global functions will use an internal TRawByteStringStream instead of a supplied TMemoryStream
• TSQLRibbon.AddToReport method can work with self=nil
• fixed an endless loop in TGDIPages.DrawTextAcrossCols when wrapping text
• if TGDIPages.WordWrapLeftCols=TRUE, won't wrap column headers

• new TRawByteStringStream class
• more complete TQuery emulation
• fixed '-.3' currency values (into '-0.3') for SynDBOracle
• method TSQLTable.InitFieldTypes return faster and more accurate type for numbers
• now SynDBExplorer can close tabs when double-clicking on it

• new Split() function
• faster GetInt64() function
• Iso8601ToSecondsPUTF8Char() now returns 0 in case of unexpected format
• new TSQLDBStatement.UpdateCount property, used to retrieve the number of updates made by the latest executed statement
• ExecuteDirect method returns the UpdateCount value
• GetSQL*() methods now includes the domain name inside the table name (e.g. 'DOMAIN.TABLE' is the expected table name) - corresponding methods modified in consequence
• fixed issue when reading BLOB/CLOB content with size = 0
• TSQLTable.InitFieldTypes will now also use column type retrieved during JSON parsing

• added GetSQLTableNames method to retrieve all table names
• fixed issue in SynDBOracle when retrieving CBLOB column data
• fixed issue in TPropInfo.GetBinary method with dynamic arrays (used e.g. by TSQLRestServerStaticInMemory.SaveToBinary)
• changed TSQLTable field width computation
• added new TSQLTableToGrid.SetFieldFixedWidth method
• first editable component is now focused by default by SQLite3UIEdit
• SQLite3UIOptions unit now gets rid of TMS components dependency

• TSQLRestServerStaticInMemory now uses a per-Table Critical Section to have its EngineList, EngineRetrieve, EngineAdd, EngineUpdate, EngineDelete, EngineRetrieveBlob, EngineUpdateBlob methods begin thread-safe
• enhanced TSQLRestServer.URI thread-safety (e.g. Sessions access)

- fixed issue in produced JSON stream using '=' instead of ':'

• fixed issues in SQLite3UIEdit
• several small compilation or documentation fixes

• updated documentation
• fix '<' character HTML export in SynProject

code modifications to compile with Delphi 5 compiler (no ORM code compiles yet: so only low-level units like SynCommons / SynCrypto / SynPdf are tested)

• BigTable: fixed potential issue when compiled with THREADSAFE
• enhanced documentation

• added property CommitShouldNotUpdateFile to TSQLRestServerStaticInMemory to have pure in-memory virtual tables (i.e. COMMIT won't write anything)
• now deletes outdated per-user sessions
• custom SQL functions now working as exepected via high-level method TSQLDataBase.RegisterSQLFunction and TSQLDataBaseSQLFunction class
• updated framework documentation

• TZipRead and TZipWrite now handle Unicode file name inside zip (UTF-8 encoded)
• new .synlz file format, used to fast .log compression (with UnSynLz.dpr for uncompressing this efficient but proprietary file format)
• TSynLogFamily.Destroy is now able to archive outdated .log files into .synlz or .zip, in a custom destination directory

• changed the way Virtual Table modules are associated to TSQLRecordVirtual - not by the class name any more
• documentation update

• updated and tested Virtual Tables implementation
• enhanced framework documentation to introduce Virtual Tables + some fixes
• see e.g. TSQLVirtualTableLog and TSQLVirtualTableCursorLog and associated documentation for details and sample code

• Virtual Tables tests added - implementation sounds complete by now, and working as expected
• TSQLRestServerStaticInMemory can now store its content into UTF-8 JSON or an optimized (SynLZ) compressed binary format with variable-length record storage: e.g. a 27 KB Json_Dali.JSON content is stored into a 6 KB Binary_Dali.Binary file (this data has a text redundant field content in its FirstName field); 502 KB People.json content is stored into a 92 KB People.Binary file :)
• fix compilation issue in SQlite3i18n.pas

• introducing in SQLite3Commons TSQLVirtualTableModule / TSQLVirtualTable / TSQLVirtualTableCursor classes for a generic Virtual table mechanism (used e.g. by TSQLVirtualTableModuleDB in the SQLite3 unit)
• new TSQLRecordVirtualTableAutoID and TSQLRecordVirtualTableForcedID classes, used to access any TSQLVirtualTable in our ORM

• new TSQLDataBase.RegisterSQLFunction method and associated TSQLDataBaseSQLFunction classes, for a generic SQL function implementation (including a dynamic array search SQL function)
• added TDynArray.ElemSave/ElemLoad/ElemLoadClear/ElemLoadFind methods

• added regression tests for sftObject kind of properties
• fixed some issues in handling sftObject kind of properties
• written associated documentation for TRawUTF8List/TPersistent/TCollection properties in TSQLRecord

• fixed issue in TSQLRestServerStats.DebugMessage
• introducing LogView sample application

• TSQLRestServerDB now uses fast TDynArrayHashed for its internal prepared statement cache
• added logging in most units

• fixed issue in serializing sftCurrency type in TSQLRecord.GetJSONValue
• update SQLite3 engine to version 3.7.6.2

• .mab file now contain the file name
• TSynLog Enter/Leave speed up

• update SQLite3 engine to version 3.7.6.1
• regression test now exclude fixed auto generated ID sequence (may vary, just like happened for 3.7.6)

• added TMemoryMapText class to fast handle big UTF-8 text files (like logs)
• now TFileVersion is a regular class, not an object/record any more (this was incoherent since Delphi 2010)
• now TSynCache will use faster TDynArrayHashed for its content hashing
• source can now be parsed per all Delphi IDE pre-parser (dual declaration as record or object because of Delphi 2010 and up was not understood)

• added TMemoryMap and TSynMemoryStreamMapped to handle memory-mapped files
• now TTextWriter can have a custom internal buffer size (default 1024 bytes)
• now TFileBufferWriter is a regular class, not an object/record any more
• .mab file is now compressed: a 900 KB .map is reduced into a 68 KB .mab file :)

• all Exceptions can be automaticaly logged on request
• logs can contain serialized objects, dynamic arrays, enumerates and sets values

• buttons are now created in the expected order (added from left to right ;)
• code refactoring, to have common methods shared for future use

• TSQLRecordMany.DestGetJoined* methods now accept generic TSQLRest class
• ExecuteList defined in TSQLRest, so now available also in TSQLRestServer

• dynamic arrays can now be specified for TSQLRecord published properties: a new sftDynArray field kind has been added - will be stored as BLOB in the database (following the TDynArray.SaveTo binary stream layout), and will be transmitted as Base64 encoded in the JSON stream
• dynamic arrays now handled in the JSONToObject and ObjectToJSON functions (will follow TTextWriter.AddDynArrayJSON format, i.e. plain JSON array for common types, but Base64 encoded streom for other arrays)

• 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)

• new FindAndFill / FindAndDelete / FindAndUpdate / FindAndAddIfNotExisting methods for TDynArray
• introducing the new tftDynArray property type for TSQLRecord (not yet finished)

• fixed memory leak in TDynArray.AddArray
• added checksum to binary stream format used by TDynArray serialization (format changed!)
• new TTextWriter.AddDynArrayJSON and TDynArray.LoadFromJSON methods for UTF-8 JSON serialization of dynamic arrays

• new SynTaskDialog unit, implementing the Vista/Seven TaskDialog, and with a native Delphi emulation under XP/2K :)
• start of deep code refactoring of the UI part of the framework, to be independent from the TMS components

new TSQLRestClientURI methods to implement BATCH sequences to speed up database modifications: after a call to BatchStart, database modification statements are added to the sequence via BatchAdd/BatchUpdate/BatchDelete, then all statments are sent as once to the remote server via BatchSend - this is MUCH faster than individual calls to Add/Update/Delete in case of a slow remote connection (typically HTTP over Internet)

• fixed issue for unique field validation in SynBigTable
• new TSynTableData.FilterSBFValue/ValidateSBFValue methods

• record validation now uses the generic TSynValidate mechanism, common with our main ORM framework, compliant with true multi-tier architecture: use Table.Validate method (see e.g. the update CheckConstraints)
• record filtering now uses the generic TSynFilter mechanism, common with our main ORM framework, compliant with true multi-tier architecture: use Table.Filter method
• 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)

• manual handling of TSQLRecord.ID property serialization
• serialization of parent properties in TJSONSerializer.WriteObject() and ObjectToJSON()

• TSQLFilter* and TSQLValidate* are renamed TSynFilter* and TSynValidate*, and now implemented in SynCommons.pas (this may be used also with TSynTable and Big Table)
• unique field validation is implemented in SQLite3Commons.pas

• now handle TSQLRecord automated filtering (using TSQLFilter classes) and validation (using TSQLValidate classes)
• unique field validation is now in TSQLRecord.Validate (better multi-tier architecture)

• new GetCardinalDef(), IsValidEmail, IsValidIP4Address(), and GetCaptionFromClass() procedures or functions (with associated tests)
• new grep-like IsMatch() function for basic pattern matching
• TSQLRecord field content validation is handled in the new TSQLRecord.Validate virtual method, or via some TSQLValidate classes - see TSQLValidateRest, TSQLValidateIPAddress, TSQLValidateEmail, TSQLValidatePattern, TSQLValidatePatternI, TSQLValidateText, TSQLValidatePassWord e.g.

• now handle TSQLRecord automated filtering (using TSQLFilter e.g.)
• Delphi 2009/2010/XE compatibility fixes

• new ConvertCaseUTF8(), UpperCaseU(), LowerCaseU() functions
• introducing direct content filtering and validation using TSQLFilterOrValidator dedicated classes
• filtering is handled directly in the new TSQLRecord.Filter virtual method, or via some TSQLFilter classes - TSQLFilterUpperCase, TSQLFilterUpperCaseU, TSQLFilterLowerCase, TSQLFilterLowerCaseU and TSQLFilterTrim e.g.

• wider usage of TSQLRecordProperties, for faster RTTI access, via the new class function TSQLRecord.RecordProps: TSQLRecordProperties: only virtual class function or procedure are now defined in TSQLRecord
• 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 PatchCodePtrUInt() procedure

• with Delphi 2009/2010/XE, you can define any string parameter in your TSQLRecord definition (will be handle as sftUTF8Text field)
• with Delphi 2009/2010/XE, WriteObject, ReadObject and CopyObject functions now handle string (UnicodeString) properties, as TINIWriter.WriteObject method does also: UTF-8 encoding is used at the storage level

• new TPropInfo.SetVariant/GetVariant methods
• new GetFieldValue/SetFieldValue and GetFieldVariant/SetFieldVariant methods for TSQLRecord

fixed issue in TSQLRestServerNamedPipe[Response] multi-thread architecture: FastMM in full debug mode detected that a block has been modified after being freed - now TSQLRestServerNamedPipeResponse is fully stand-alone

• code refactoring in TSynBigTableString: some generic functions were moved into SynCommons
• get rid of the Open/Read/Seek methods: use GetAsStream() instead
• faster GetIterating() method, looping in physical order in disk by default, and optionaly in Numerical ID order
• enhanced coherency checks when loading from file

• now handle our 32/64-bit variable-length integer, via new FromVarUInt32/64 and ToVarUInt32/64 functions * first draft of new SynBigTable format, much faster and using less disk space

• Some speed improvements in JSON parsing and conversion to SQL;
• There was a problem in the sqlite3_bind_text() official documentation: the SQLite site says that the Text_bytes parameter includes the #0 terminator, but in fact, it excludes it. So a #0 was added to the field content on the database, resulting in an error.

• fixed sqlite3_result_text() implementation
• added sqlite3_aggregate_context() and sqlite3InternalFree() functions
• new CONCAT() function available in SQL statements to process fast string concatenation
• now handle automaticaly prepared SQL statements: the parameters must be surrounded with :(...): in order to use an internal pool of prepared TSQLRequest; example of possible inlined values are :(1234): :(12.34): :(12E-34): :("text"): or :('text'): (with double quoting inside the text, just like any SQL statement)

TSQLRecord.ID reader has now a GetID() getter which can handle the fact that a published property declared as TSQLRecord (sftID type) contains not a true TSQLRecord instance, but the ID of this record: you can use aProperty.ID method in order to get the idea - but prefered method is to typecast it via PtrInt(aProperty), because GetID() relies on some low-level windows memory mapping trick

• better non-ascii search handling in TSQLTable.SearchValue
• new TSQLRecordMany.DestGetJoined() method returning a Dest TSQLRecord, ready to retrieve all joined records (i.e. FillPrepare having been called)

• new TSQLRecord.FillPrepare(const aIDs: TIntegerDynArray) overloaded method, which can be handy to loop into some records via an IDs set
• new TSQLRecordMany.DestGetJoined method, in order to retrieve all Dest items IDs associated to the current or specified Source ID, adding a WHERE condition against the Dest rows

• new TSQLRecord.FillClose method
• new TSQLRecord.CreateAndFillPrepare() methods, to makes loop into records easier (an hidden TSQLTable is created and released by TSQLRecord.Destroy)
• new TSQLTable.OwnerMustFree property for generic owning of a TSQLTable by a record - used for both CreateAndFillPrepare and TSQLRecordMany.FillMany

• added sqlite3_result_error() call to make wrong parameter count error explicit during SQL statement internal functions calls
• handles new FTS4 extension module - see http://sqlite.org/fts3.html#section_1_1 - which is available since 3.7.4
• new RANK() function available in SQL statements for ranking FTS3/FTS4 with best performance (used by the new TSQLRest.FTSMatch() overloaded method) - see http://www.sqlite.org/fts3.html#appendix_a
• new class function TSQLRecord.SimpleFieldsCount
• FTS3Match method renamed FTSMatch, in order to be used without hesitation for both FTS3 and FTS4 classes
• new overloaded FTSMatch method, accepting ranking of MATCH, using the new RANK internal function - see http://www.sqlite.org/draft/fts3.html#appendix_a
• new TSQLRecordFTS4 class, to handle new FTS4 extension module - see http://sqlite.org/fts3.html#section_1_1 - which is available since 3.7.4

• new TSQLRecord.SimplePropertiesFill() method, to fill the simple properties with a given list of const parameters, following the declared order of published properties of the supplied table
• new TSQLRest.Update(aTable: TSQLRecordClass; aID: integer; const aSimpleFields: array of const) overloaded method to update a record from a supplied list of const parameters

• sftMany/TSQLRecordMany field type handled as a not simple field
• new TSQLRest.Add(aTable: TSQLRecordClass; const aSimpleFields: array of const) method to add a record from a supplied list of const parameters, following the declared order of published properties of the supplied table

• TSQLRecord.FillRow method has been made virtual, so that some calculated field can be initialize during table content enumeration
• corrected possible GPF error in TSQLRestServer.Retrieve

• renamed TSQLRecordMany.DestAdd into TSQLRecordMany.ManyAdd
• new TSQLRecordMany.ManySelect and ManyDelete methods
• fixed some issues when TSQLRecordMany.FillMany is used together with standard FillPrepare (e.g. in a TSQLRest.Retrieve method)
• unitary testing enhanced for the new methods

• TSQLRestServer.AfterDeleteForceCoherency now handles specifically TRecordReference, TSQLRecord (fixed) and new 'has many' Source/Dest fields (this is our internal "FOREIGN KEY" implementation - we choose not to rely on the database engine for that, in order to be engine-independent... and SQLite3 introduced FOREIGN KEY in 3.6.19 version only)
• TSQLRestServer.AfterDeleteForceCoherency now synchronizes as expected TSQLRestServerStatic table content
• new TSQLRestServerStatic.SearchField method, for fast retrieval of all IDs matching a field of a TSQLRestServerStatic table (faster than using any OneFieldValues method, which creates a temporary JSON content)

• now handles User Defined Functions, via sqlite3_create_function_v2 and corresponding sqlite3_result_* functions: as sample, the MOD() function is defined in any database opened via TSQLDataBase (it was needed to have compatibility with Oracle/MySQL/MSSQL/PostGreSQL engines for our TSQLRecordMany implementation)
• protect the TSQLDatabase methods called when self is nil, which could occur if the database is not yet initialized (could occur if only a TSQLRestServerStatic exists, like in TTestSQLite3Engine._TSQLRestClientDB)
• new TSQLRecordMany to handle "has many" and "has many through" relationships

• Range Checking forced OFF to avoid problems with some projects
• fFile type modified to THandle, instead of integer

• WriteObject and CopyObject functions now handle Int64 properties, as TJSONWriter.WriteObject method does now also
• new TSQLRestServerStatic.GetOne and TSQLRestServerStatic.UpdateOne methods, methods available since a TSQLRestServerStatic instance may be created stand-alone, i.e. without any associated Model/TSQLRestServer
• diverse fixes in TSQLRestServerStatic which could occur in not expected behavior if security events are enabled for this table (wrong IDToIndex)
• new TSQLRecordLog.CreateFrom method used to append some log records to an existing JSON log content

• custom queries can now handle standard operators, following a specified set
• TSQLQueryEvent() usage has therefore been modified for custom queries

• handle now RowID as a valid alias to the ID field (needed for TSQLRecordFTS3)
• handle TSQLRecordFTS3 record, for using FTS3 virtual tables natively inside the Framework, i.e. easy implementing full-text search (including dedicated regression tests)

• some code rewrite in order to avoid any implicit conversion from/to integer/cardinal after new definition of PtrInt/PtrUInt (matching NativeInt/NativeUInt types, available since Delphi 2007)
• updated TSQLRibbonTabParameters object, with some new fields dedicated to the automatic edition of records, via the new SQLite3UIEdit unit
• new sftSet SQL field kind, handling a TSQLRecord published property with a set of enumeration as Delphi type (stored as bit-mapped INTEGER)

• new direct methods to handle BLOB fields from clients or servers
• new URI to GET or PUT BLOB fields: ModelRoot/TableName/ID/BlobFieldName

• update engine to version 3.7 latest draft (snapshot as of 2010-06-26 19:03 UTC)
• sqlite3.c: #define SQLITE_THREADSAFE 2 is better than 0 which could be usafe

• update engine to version 3.7 draft (snapshot as of 2010-06-25 11:35 UTC)
• SetWALMode() method for enabling Write-Ahead Logging for the database
• the RTREE extension is now compiled by default into the engine
  See http://synopse.info/forum/viewtopic.php?id=31