VERSION FRANCAISE
Téléchargements
- NOUVEAU Logiciel SQLfast v3.1.1 [dernière maj 2019-05-22]
- SQLfast.zip - SQLfast.rar
- Guide d'installation de SQLfast (en français) [dernière maj 2017-04-01]
- SQLfast_Installation_FR.pdf
- Manuel SQLfast : Database application programming with SQLfast (486 pages, en anglais) [dernière maj 2018-09-07]
- SQLfast-Manual.pdf
- NOUVEAU Dictionnaire des commandes SQLfast (en anglais) [dernière maj 2018-12-04]
- SQLfast-Commands.pdf
- Premiers pas avec SQLfast - Niveau Basic (en français) [dernière maj 2017-04-01]
- Getting_started_BASIC_FR.pdf
- Premiers pas avec SQLfast - Niveau Expert (en français) [dernière maj 2016-08-31]
- Getting_started_EXPERT_FR.pdf
- Guide de survie SQLfast - Modèles typiques de scripts (en français) [dernière maj 2018-10-08]
- Survival_guide_FR.pdf
- NOUVEAU Etudes de cas (en anglais) [dernière maj 2019-02-01]
- SQLfast Case Studies
- Comparaison du code SQLfast et des codes Java / Python (en français) [dernière maj 2016-04-18]
- Code_Comparison_FR.pdf
Versions de SQLfast
|
2. Qu'est-ce que SQLfast ?
|
Le nom SQLfast désigne, d'une part, un langage permettant de rédiger des scripts de manipulation de bases de données relationnelles, et d'autre part, un logiciel permettant à des utilisateurs tant novices qu'experts de développer, tester et exécuter des scripts SQLfast de toute nature et de complexité quelconque. Langage et logiciel SQLfast ont été conçus pour couvrir une large gamme de scénarios d'utilisation, depuis l'apprentissage (autonome ou supervisé) des bases de données et du langage SQL jusqu'au développement et à l'exploitation d'applications complexes.
Le langage SQLfast est une extension de SQL. Ses instructions comprennent, d'une part, les commandes SQL et d'autre part, des instructions d'échange de données avec l'utilisateur (boîtes de dialogue), des variables, des instructions de contrôle (if, for, while, procédures), des métadonnées ainsi que de riches bibliothèques de fonctions et d'interaction avec l'environnement. Un script peut être constitué d'une seule requête SQL mais des scripts complexes, tels que des gestionnaires de bibliothèques ou des générateurs de prototypes, peuvent comporter plusieurs milliers d'instructions.
Le langage SQLfast a été conçu dans un objectif de simplicité d'utilisation. A l'instar de son noyau, SQL, il offre une courbe d'apprentissage linéaire : un problème simple sera résolu en quelques lignes, dont la rédaction ne nécessite que quelques minutes d'apprentissage.
Les arcanes des interactions avec les données (BD, fichiers, images) ainsi que ceux des dialogues avec l'utilisateur sont entièrement cachés car gérés par le moteur SQLfast.
La consultation des données d'une table nécessite 1 instruction en SQLfast (select * from CLIENT) mais près de 40 instructions en Java/JDBC. De même, une boîte de saisie de données constituée de trois champs est définie en 1 instruction SQLfast et exige plus de 100 instructions Python/Tkinter. Ou encore, le téléchargement d'un fichier est obtenu par 1 instruction SQLfast mais par près de 100 instructions Python/urllib2. Un document (Code_Comparison_FR.pdf) compare le code SQLfast avec le code standard dans ces trois cas de figure.
SQLfast est un logiciel dit portable, qui ne nécessite pas d'installation à proprement parler et qui ne modifie pas les paramètres du système sur lequel il fonctionne. Il peut notamment être installé, avec une collection de bases de données et de scripts, sur une clé USB transportable d'une machine à l'autre.
Le logiciel SQLfast offre une interface graphique conviviale permettant aux utilisateurs novices d'apprendre et d'expérimenter le développement de requêtes SQL et plus généralement de scripts SQLfast. Il dispose d'une fonction d'aide programmable permettant la rédaction et l'intégration au logiciel de tutoriels personnalisés. Son interface se décline en deux variantes :
- Basic : familiarisation avec le concept de base de données, apprentissage du langage SQL, utilisation légère et occasionnelle d'une base de données.
- Expert : apprentissage de la programmation sur bases de données à l'aide du langage SQLfast, développement et exploitation d'applications interactives en SQLfast.
Le logiciel SQLfast est économe en ressources. Avec tous ses composants (y compris les bibliothèques graphiques, le SGBD, les fichiers d'aide, des bases de données de test, un jeu de scripts et des tutoriels), il n'occupe guère plus de 15 Mo sur disque et tourne sans accroc sur des machines de faible puissance. Il est cependant évident que l'exploitation intensive de grandes bases de données nécessitera des ressources plus importantes.
SQLfast est développé en Python 2.7, mais son utilisation ne nécessite pas la présence de l'environnement Python. Il inclut le SGBD SQLite 3 et la bibliothèque graphique standard Tkinter. La version actuellement disponible fonctionne sous MS Windows.
Des versions tournant sous OS X et Linux ont été testées avec succès mais ne sont pas diffusées pour l'instant. De même, des versions basées sur MySQL et MS Access existent mais ne sont pas encore disponibles.
|
3. Installation et démarrage
|
Le package d'installation comprend le logiciel SQLfast, y compris sa documentation et les premiers tutoriels.
- SQLfast : le logiciel. Le logiciel SQLfast et ses ressources sont téléchargeables sous la forme d'une archive de 10-12 Mo (SQLfast.zip et SQLfast.rar) qui contient un répertoire nommé (sans surprise !) SQLfast. L'installation consiste à placer ce répertoire sur un support quelconque tel que le disque C ou D, simplement sur le bureau ou encore sur une clé USB. Dès que la copie est réalisée, SQLfast est prêt à fonctionner (exécuter SQLfast.exe). L'archive est disponible ici pour la version zip et ici pour la version rar.
- SQLfast : Guide d'installation. Ce document fournit quelques conseils pour faciliter sa première utilisation. Ce guide est disponible ici.
|
3. Documentation sur SQLfast
|
Il existe deux sources principales de documentation concernant l'outil et les langages SQLfast : la documentation intégrée accessible par la fonction d'aide (Help) du logiciel et le tutoriel de SQLfast.
- 3.1 Bouton Help du logiciel SQLfast au niveau "Basic".
- Ce bouton ouvre un petit menu comportant, en plus de l'écran About SQLfast, trois items.
- Help > Getting started. Ce document décrit brièvement l'environnement offert par la fenêtre principale du logiciel SQLfast, ses fenêtres et leurs principales fonctions. Il introduit pas à pas l'utilisateur à la rédaction, l'exécution et la correction de requêtes SQL. Ce tutoriel a également été traduit en document pdf (voir ci-dessus).
- Help > SQLfast environment. Description détaillée de la fenêtre principale, de ses fenêtres secondaires et de leurs fonctions.
- Help > Tutorials. Portefeuille de tutoriels relatif au langage SQL. Cette collection de documents est régulièrement étendue et mise à jour.
- 3.2 Menu Help du logiciel SQLfast au niveau "Expert".
- Ce bouton ouvre un menu comportant, en plus de l'écran About SQLfast, quatre items.
- Help > Getting started. Ce document décrit brièvement l'environnement offert par la fenêtre principale du logiciel SQLfast, ses fenêtres et leurs principales fonctions. Il introduit pas à pas l'utilisateur à la création, à l'exécution, à la correction et au sauvetage d'un premier script.
- Help > Survival guide. Collection d'une cinquantaine de modèles de scripts commentés permettant d'aborder en confiance la résolution de problèmes de toute nature, depuis la simple consultation d'une base de données jusqu'à la génération de code à partir des métadonnées d'une base de données. Ce document est également disponible au format pdf (Survival_guide_FR)
- Help > SQLfast references. Documents de référence relatifs au logiciel et au langage SQLfast.
- SQLfast environment. Description détaillée de la fenêtre principale, de ses fenêtres secondaires et de leurs fonctions.
- SQLfast commands. Liste des principales instructions du langage SQLfast, accompagnées d'une brève description et d'exemples. Ce document (en anglais) constitue une synthèse du document Dictionary of SQLfast commands and parameters disponible sur le site de l'outil (SQLfast commands)
- SQLtuto language. Description et exemples de SQLtuto, le langage de rédaction de documents Help et de tutoriels. Ce langage permet à l'utilisateur de modifier les documents existants et de développer ses propres documents, notamment des tutoriels personnels.
- Help > Tutorials. Portefeuille de tutoriels relatif au langage SQLfast. Cette collection de documents est actuellement en cours de rédaction.
- 3.3 Le manuel de SQLfast. Un manuel/tutoriel détaillé (en anglais), sous la forme d'e-book, consacré à l'utilisation du langage et à la résolution de problèmes de nature variée est disponible en ligne Ici. Une série d'études de cas sont disponibles [ici].
Les documents d'aide de SQLfast sont disponibles en français et en anglais (du moins le seront-ils lorsque leur rédaction et leur traduction seront terminées). Les documents en français sont localisés dans le répertoire SQLfast/SQLfastHelp_FR.
Les tutoriels intégrés sont localisés dans le sous-répertoire Lev0_Tutorials pour le mode Basic et Lev1_Tutorials pour le mode Expert au sein du répertoire SQLfast/SQLfastHelp_FR. Ces documents peuvent être modifiés et complétés par l'utilisateur en fonction de ses besoins.
ENGLISH VERSION
-
- NEW SQLfast v3.1.1 [last update 2019-05-22]
- SQLfast.zip - SQLfast.rar
- SQLfast installation guide (English) [last update 2017-04-01]
- SQLfast_Installation_EN.pdf
- SQLfast Manual: Database application programming with SQLfast (486 pages) [last update 2018-09-07]
- SQLfast-Manual.pdf
- NEW Catalogue of SQLfast commands (English) [last update 2018-12-04]
- SQLfast-Commands.pdf
- Getting started with SQLfast Basic Level (English) [last update 2017-04-01]
- Getting_started_BASIC_EN.pdf
- Getting started with SQLfast Expert Level (English) [last update 2016-09-04]
- Getting_started_EXPERT_EN.pdf
- SQLfast survival guide - Typical script models (English) [last update 2018-10-08]
- Survival_guide_EN.pdf
- NEW Case studies [last update 2019-02-01]
- SQLfast Case Studies
- Comparing SQLfast and Java / Python codes (English) [last update 2016-04-18]
- Code_Comparison_EN.pdf
SQLfast versions
The name SQLfast denotes, on the one hand, a programming language allowing the rapid and easy development of interactive, data-centered scripts, and, on the other hand, a graphical, user-friendly software environment to develop, test and run SQLfast scripts. The language and its environment have been designed to encompass a wide range of usage scenarios, from database self-study by beginners to the development and exploitation of complex database applications such as library management and prototype generation. They target both novice and professional users
The core of the SQLfast language is SQL, the universal language for database definition and manipulation. Any sequence of SQL statements is a valid SQLfast script, whatever its length. SQLfast also comprises statements that provide for graphical user interaction, text generation, file manipulation, decision, iteration, web access, metadata processing and much more.
The main design goal of the SQLfast language is simplicity. Just like its kernel, SQL, it exhibits a smooth learning curve: a simple problem can be solved by a simple script of 2-3 statements, the writing of which requires a few minutes learning. The complexity of data interaction (DB, web, files, images, etc.) and that of GUI are fully hidden from the script writer. For instance, extracting and formatting data from the database requires about 40 Java/JDBC statements but only one SQLfast statement. A 3-field data entry dialogue box is built through more than 100 Python/Tkinter statements but requires one SQLfast statement only. In the same way, downloading a file from the web needs one SQLfast statement, against more than 100 Python/urllib2 statements.
This document compares the SQLfast code for these three examples with their equivalent standard code.
One of the distinctive features of SQLfast is its tutorial engine. A tutorial (or help document) is a hypertext written in the SQLtuto language (think of it as a nano-HTML). This document is active, in that, any code fragment (SQL queries, SQLfast scripts, GUI, calling a procedure) can be executed from within the tutorial in which it appears. Developing complex, illustrated and active course systems is therefore quite easy.
The SQLfast software is portable and its installation cannot be simpler: folder SQLfast extracted from the .zip or .rar archives, that contain its complete distribution, can be copied anywhere and is ready to run. In addition, SQLfast does not modify any system parameter.
To address the large range of usage it is intended for, SQLfast offers two interfaces:
- Basic: familiarisation with database concepts, direct graphical manipulation of data, learning SQL, analyzing data, solving small problems.
- Expert: learning database programming, developing and running small applications, solving more complex problems, developing and running complex (possibly standalone) applications.
The SQLfast software is both small (15 MB) and self-contained. Its standard distribution includes a graphical library, a RDBMS, a large, extendible, function library, sample databases, help files, tutorials and a large portfolio of example scripts, ranging from two statement elementary scripts to one thousand statements interactive DB interface generator.
SQLfast has been developed in Python 2.7. The current distribution includes SQLite 3, which offers a rich version of SQL2/SQL3 (including recursive CTE and triggers) and GUI library Tkinter. It has been compiled for MS Windows. OS X, Linux, MS Access and MySQL versions have been evaluated with success but they are not available yet.
|
3. Installing SQLfast and Getting started
|
The distribution package comprises the SQLfast software (including tutorials and sample databases and scripts) and the installation guide.
- SQLfast software. The software and its resources can be downloaded as SQLfast.zip or SQLfast.rar archive of about 8 MB. This archive contains a folder named SQLfast. The installation merely consists in extracting this folder and placing it anywhere in the computer. SQLfast is then ready to run: just double-clicking on SQLfast.exe file. The archive is available here for the zip version and here for the rar version.
- SQLfast installation guide. This document provides some hints on how to start with SQLfast. It can be found here.
There are two main sources of documentation describing the SQLfast software and languages:
the documents provided by the integrated Help function of the software (Help button at the Basic Level and Help menu at the Expert Level) and the SQLfast e-book tutorial.
- 3.1 Help button at the "Basic" Level.
- This button opens a short menu with three items, in addition to the Welcome screen (About SQLfast).
- Help > Getting started. This document describes the basic graphical environment and the main functions of SQLfast. It has also been translated into an independent pdf document (see above).
- Help > SQLfast environment. Detailed technical description of the windows of SQLfast and of their functions.
- Help > Tutorials. Portfolio of tutorials on the SQL language.
- 3.2 Help menu at the "Expert" Level.
- This button opens a menu with four items, in addition to the Welcome screen (About SQLfast).
- Help > Getting started. This document describes the expert graphical environment and the main functions of SQLfast.
- Help > Survival guide. A collection of about fifty commented SQLfast programming models, from simple data querying to code generation based on metadata. Can be used, assembled and customized to develop real applications. It has also been translated into an independent pdf document (Survival_guide_FR)
- Help > SQLfast references. Portfolio of reference documents about the SQLfast software and languages.
- SQLfast environment. Detailed technical description of the windows of SQLfast and of their functions at the Expert Level.
- SQLfast commands. Dictionary of the SQLfast statements, functions and parameters. This integrated document is a summary of Dictionary of SQLfast commands and parameters (SQLfast commands)
- SQLtuto language. Description of the tutorial language. This language allows users to modify and develop help documents and tutorials for the SQLfast environment.
- Help > Tutorials. Portfolio of tutorials about the SQLfast language. These lessons are derived from the SQLfast Manual.
- 3.3 The SQLfast Manual. This e-book is a manual/tutorial on the SQLfast language and on database programming. It is available Here.. A series of case studies is available [here].
Most Help documents are available in English and in French. The tutorial documents are distributed in directory Lev0_Tutorials for the Basic Level and in directory Lev1_Tutorials for the Expert Level.
SQLfast versions
-
- bug fixed in drop view execution (incorrect processing of view metadata).
- bug fixed in import from dbf files (last field incorrectly decoded if variable-length numeric).
- bug fixed in createDB InMemory in Basic level.
-
- Multidatabase scripts: secondary databases can be attached to the main database.
- New temporal system variables: clock (hh:mm:ss), dateclock (YYYY-MM-DD hh:mm:ss)
- System tables: three new system tables: SYS_CHECK (check constraints), SYS_TRIGGER (the properties of triggers) and SYS_TRIGGER_COMP (the SQL statements of the body of triggers).
- New properties: key and constraint names, autoincrement columns.
- Generating the SQL-DDL schema
- Expert level menu: new menu item to force the rebuilding of the full schema of the current database.
- Generation process: now generates check constraints, views, triggers, key and constraint names.
- Case study and documentation: new case study on Blockchains.
- Documentation: Principles of Blockchains and description of an experimental Blockchain toolkit (in English). Text: [].
- Scripts: The code of the toolkit is available in SQLfast/Scripts/Case-Studies/Case_BlockChain of the standard distribution.
- System: upgraded to SQLite v.3.25.03. (includes, a.o., window function and an upsert variant of the insert query)
- Cryptography: cryptographic functions have been added to the LStr library: secure hashing (hash, miningHash), symmetric cryptography (generateSYMkey, encryptSYM, decryptSYM), asymmetric cryptography (generateRSAkeys, encryptRSA, decryptRSA); document SQLfast-commands.pdf updated.
- Blockchain application
- Scripts: a didactic Blockchain toolkit has been added in directory Scripts/BD-2018/Chapitre-10/Blockchain. Dialogues in French. An English version is ongoing as an SQLfast Case Study.
- Documentation: the documentation of the Blockchain toolkit has been added to Appendix 10 of the reference book (Chapitre 10, Annexe). In French. An English version is ongoing as an SQLfast Case Study.
-
- List processing: complete module, including (multi-)set operators and predicates, joins (joining two lists) and list-based loop (for e = [items A;B;C;D];). This feature simplifies complex queries based on set-algebra and speed up their execution.
- Dynamic columns: the basis of NoSQL databases. An undeclared column is created as soon as it receives a value (through insert or update). For instance, the following sequence is valid: create table T(A int, B int); insert into T(A,B,C) values (1,2,3); update T set D = 4 where E is null; select A,B,C,E,F from T;. Metadata functions return the list of non null dynamic columns of a row or of a table.
- import statement: CSV import is more robust: now copes with values including end-of-lines and with record comprising a variable number of fields.
- Basic level: in-memory databases can now be created.
- composite dialogue boxes: now stretchable; their resizing is propagated to their elementary boxes.
- result sets of select queries and Show Data windows now correctly display text values including end-of-lines.
- Summary schema: now shows not null constraints.
- Full schema: when missing, the SQL-DDL code is automatically rebuilt.
- Survival guide: available in English (both *.help and *.pdf version)
- Survival guide: extended to list processing and dynamic columns
- SQLfast manual (formerly SQLfast Tutorial): new Chapter 24 - Transient data: the SQLfast lists
- SQLfast manual: new Chapter 25 - Schema-less tables and dynamic columns
- SQLfast manual: Appendix - A basket of examples: new applications added (Simulation of all (multi-)set operators, Computing the powerset of a set, The relational division, Computing set inclusion relation, etc.)
- several bugs fixed and minor improvements.
- UDF functions (for SQLfast and SQL):
- list processing: set-like operators ("itemUnion", "itemExcept", "itemInter") similar to SQL set operators "union", "except" and "intersect". Multiset-like operators ("itemUnionAll", "itemExceptAll", "itemInterAll") similar to SQL multiset operators "union all", "except all" and "intersect all".
- list processing: set-like predicates ("itemEqual", "itemInclude"). Multiset-like predicates ("itemEqualAll", "itemIncludeAll").
- Error box more readable: stretchable and in "courier' font
- Stretchable dialogue boxes: all the elementary boxes (showMessage, askData, askText, selectOne, selectMany, showData, showText, showPicture, showDrawing) now are stretchable.
- "print" can be used instead of "write"; Christmas gift for Python programmers!
-
- UDF functions (for SQLfast and SQL):
- Clarification of UDF architecture. "UserUDFlib_for_SQL.py" is the module in which new UDF to be used in SQL queries must be written by users. Similarly, new UDF for SQLfast statements ("if", "while", "compute") must now be written in module "UserUDFlib_for_SQLfast.py". The source and compiled versions of these modules are integrated to the distribution. NOTE: Chapters 10 and 22 of the tutorial are not updated yet.
- New UDF functions (for SQLfast and SQL):
- list processing: itemSlice (extracting sublist) + itemSliceS; itemDelete (remove elements) + itemDeleteS; item and itemSlice now allow backward positions; itemSort, itemNSort,itemSortS and itemNSortS receive a new parameter to remove duplicates
-
- New case study Interactive SQL interpreters available. Its scripts have been included in the distribution.
- New UDF functions (for SQLfast and SQL):
- list processing: itemSort (sorting items), itemNSort (numeric sorting of items) + itemSortS, itemNSortS
- pretty printing of select queries: LStr:PrettyPrint
- execApp: arguments are passed by reference instead of by value (avoid "newline" problems)
- exceptions in UDF: specific exception messages now transmitted in clear
- data and text dialogue boxes: now stretchable (except in askCombo)
- background color in predefined values: the ugly gray color is back! Now fixed.
- New architecture of UDF functions. Built-in and user libraries are now distinct.
- Several bugs fixed
- The text of nine case studies have been rewritten and extended. Their scripts have been redeveloped and integrated in the distribution (new directory SQLfast/Scripts/Case-Studies). They are available as complete, standalone, applications, ready to run.
- New functions (for SQLfast and SQL):
- date/time processing: normDate, datePattern, julianDate
- types: isDate, isNotDate, isInteger, isNotInteger, utf8Compliant, latinCompliant, hexCompliant, base64Compliant
- string analysis and reduction: startsWith, endsWith, countInst, deaccent, reduce, simplify, shrink
- format: thousandSep
- path/url processing: urlExists, normalizePath, lastPathNode, pathPrefix, nodeExtension, pureNodeName
- structured text analysis: ExtractTaggedString, NextSection
- list processing: itemLen, item, itemIndex
- secure hashing (based on SHA256): hash (string digest), hashFile (file digest)
- group_concat2: full group_concat aggregate function, equivalent to MySQL version. For SQL only.
- web interaction: webfileToFile, webpageToVariable
- multi-variable assignment: set
- csv and dbf data exchange: import
- secure hashing: hashFile (file digest), from small to very large files
- SQLfast: openSMTPserver, sendMessage, closeSMTPserver, sendMessageImmediate
- SQL: sendMail
- New coding statements and functions:
- hash signature: hash, hashFile
- encode/decode: b64encode, b64decode, b64encode<source>To<target>, b64decod<source>To<target>, char2hex, hex2char, HEXencode<source>To<target>, HEXdecode<source>To<target>
- cryptography: encrypt, decrypt
- Data windows: improved readability through new background, update/delete through double-click, showing temporary tables and views, coping with binary data
- Miscellaneous:
- Displaying binary data in result sets.
- GUI: name of standard buttons can be customized
- "About" box, more information and links, startup settings.
- Welcome screen = "About" box.
- system: upgraded to Python 2.7.12 and SQLite 3.17.
- system: Bug fixed: the system path (where SQLfast directory is located) may now include non-ASCII characters.
- Data windows: Data windows in Show data receive a new button: Select. Allows row filtering. Four filter building modes are provided (smart, strict, SQL condition, SQL predicate).
- Data windows: New sorting criterion: natural (= unsorted).
- Schema window: In addition to the standard Summary format, a new Full schema option is provided. It also shows data types and all integrity constraints. If missing, the Full schema can be regenerated through script SQL-DDL-generation.sql.
- SQLfast language: New statements displayHelp and closeHelp. Allow help documents to be displayed/closed dynamically from within a script.
- SQLfast language: Concise version of ask, askData, ask-u, askData-u, showData. We can now write: ask A,B,C instead of ask A,B,C = A|B|C;
- SQLfast language: New SQL and SQLfast UDF functions: to provide approximate comparison (simplify, shrink); to manipulate paths and urls (normalizePath, lastPathNode, pathPrefix, nodeExtension, pureNodeName); to align a string in a fixed frame (frame)
- SQLfast language: Web processing is now allowed through statements webpageToVariable (download the HTML code of a page) and webfileToFile (download a file). New LStr functions NextSection and ExtractTaggedString can be used to extract data from HTML code.
- SQLfast language: New time processing functions: julianday or jd (convert a date-time value into julian day code), addToDate (add/subtract days to a date), nextDate (next date), prevDate (previous date).
- GUI: All secondary windows (Help, Schema, Data) are now persistent and independent of Main and Output windows.
- GUI: Menu function and button Save have been split into Save and Save as.
- GUI: Useless buttons are now disabled (e.g., Show schema disabled when no database is opened).
- system: Various bugs fixed.
- Data windows: Fixing horizontal synchronization of title and data text areas in wide data windows.
- Data windows: Geometry parameters of data windows can now be set in SQLfast.ini and modified in user scripts: maxTableNbr (initial maximum number of tables opened), maxRowNbr (maximum number of rows extracted per table), WmaxRowWidth (max width of data area), WmaxRowNbr (max height of data area).
- SQLfast language: SQLite detects DDL errors involving more than one table in DML queries only. Foreign key errors are now coped with in statement createDictionary.
-