Synopse

For our native connection to any DB, we developed a set of classes and several units.

We implemented at first OleDB, then native Oracle direct access and SQlite3 static engine.

Now, Microsoft is officially deprecating OleDB, and urge all developers to switch to the open and cross-platform ODBC API for native connection.

To my understanding, the so-called "strong-typing" feature is one big benefit of the Delphi object pascal language.

As stated by wikipedia:

Most generally, "strong typing" implies that the programming language places severe restrictions on the intermixing that is permitted to occur, preventing the compiling or running of source code which uses data in what is considered to be an invalid way. For instance, an addition operation may not be used with an integer and string values; a procedure which operates upon linked lists may not be used upon numbers. However, the nature and strength of these restrictions is highly variable.

Some Delphi users may find this is a limitation of the language, in comparison with other "fashionable" script idioms (like Python, Javascript of Ruby). For me, runtime strong typing (alla Python or Ruby) is not true strong typing. Simon Stuart just proposed a smartstring kind of string, which is in fact a weakstring type. As far as I understood his point, he wanted to get rid of all the warnings emitted by Unicode-version of the Delphi compiler, about explicit string conversion.

In fact, I use to go in the opposite direction. For wide projects, strong-typing is one of the big benefit of using Delphi (like other main "serious" languages like Java, C, C++, Ada or C#).

A nice framework user, named esmondb, did write and publish some JavaScript code to handle our RESTful authentication mechanism.

It seems to work well, and implements all secure hashing and challenging.
Our authentication mechanism is much more advanced than the one used by DataSnap - which is a basic HTTP authentication with the password transmitted in clear (this is the reason why it shall better be used over HTTPS, whereas mORMot can be used over plain HTTP).
Resulting JavaScript code seems not difficult to follow, even for a no JS expert like me.

Our Client-Server ORM framework is now available in revision 1.15.

This is a major upgrade of the framework:

• It is now called mORMot - so please update your T-Shirts or coffee cups
• It is able to use any Database engine back-end - in fact, it is SQLite3 powered, not SQLite3 limited;
• In particular, direct OleDB and native Oracle have been implemented;
• It makes use of the genuine SQlite3 Virtual Table mechanism everywhere to allow mixed access to any database engine;
• New TModTime / TCreateTime kind of fields;
• Enhanced stability, speed and multi-thread implementation;
• Methods and functions have been enhanced, according to user feedback (thanks you all for your interest and forum posts!);
• Extended documentation (more than 700 pdf pages), with new diagrams and a lot of new content;
• New associated tools, like LogViewer or SynDBExplorer;
• The SQLite3 core can now be used without our ORM - it has been updated to the latest 3.7.8 version;
• Open Source (under GPL/LGPL/MPL license), running from Delphi 6 up to XE2.

In computing, internationalization and localization (also spelled internationalisation and localisation) are means of adapting computer software to different languages, regional differences and technical requirements of a target market:

• Internationalization (i18n) is the process of designing a software application so that it can be adapted to various languages; 
• Localization (L10n) is the process of adapting internationalized software for a specific region or language by adding locale-specific components and translating text, e.g. for dates display.

Our framework handle both features, via the SQLite3i18n.pas unit. For instance, resourcestring defined in the source code are retrieved from the executable and can be translated on the fly. The unit extends this to visual forms, and even captions generated from RTTI.

In short, making your software open to any language is handled by the framework, from the bottom-up.

Everybody is buzzing about FireMonkey...

Our little mORMot will like FireMonkey!
Here is why...

Our ORM RESTful Framework is about to access any available database engine.

It will probably change its name (since it won't use only SQlite3 as database), to become mORMot - could be an acronym for "Manage Object Relational Mapping Over Tables", or whatever you may think of...

We'll still rely on SQLite3 on the server, but a dedicated mechanism will allow to access via OleDB any remote database, and mix those tables content with the native ORM tables of the framework. A flexible Virtual Tables and column mapping will allow any possible architecture: either a new project in pure ORM, either a project relying on an existing database with its own table layout.

That's it, our SynOleDB unit seems alive and running well.

OLE DB (Object Linking and Embedding, Database, sometimes written as OLEDB or OLE-DB) is an API designed by Microsoft for accessing data from a variety of sources in a uniform manner. It was designed as a higher-level replacement for, and successor to, ODBC, extending its feature set to support a wider variety of non-relational databases, such as object databases and spreadsheets that do not necessarily implement SQL.

SynOleDB unit implementation has been made with several points in mind:

• Tested with SQL Server 2008 R2 and Oracle 11g providers from Microsoft and Oracle; 
• Ability to be truly Unicode, even with pre-Unicode version of Delphi (like Delphi 7 or 2007); 
• Could access any local or remote Database, from any version of Delphi, since it doesn't use the DB.pas unit or any related part of the VCL (even the Delphi 7 personal or the Turbo Explorer editions), just for free; 
• Handle NULL or BLOB content for parameters and results; 
• Avoid most memory copy or unnecessary allocation: we tried to access the data directly from the retrieved data buffer, just as given from OleDB; 
• Was therefore designed to achieve the best performance possible: most time is spent in OleDB: the code layer added to the OleDB customer is very thin; 
• True OOP architecture, to be used with any OleDB provider (allowing custom parameters or such), and even without OleDB (in the future, direct access to any DB client could be used); 
• Could be safely used in a multi-threaded application/server (with one TOleDBConnection per thread); 
• Allow parameter bindings of requests, with fast access to any parameter or column name (thanks to TDynArrayHashed);
• Late binding of column values in Delphi code;
• Direct JSON content creation, with no temporary data copy nor allocation; 
• Designed to be used with our mORMot ORM, but could be used stand-alone (a full Delphi 7 client executable is just about 200 KB), or even in any existing Delphi application, thanks to a TQuery-like wrapper.

Did you notice the SQLite3Pages units?
It's a reporting unit included in our SQlite3/mORMot framework, but it can be used standalone...