ZMSQL: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# About
2	2
3	3		ZMSQL is an open source and free, TBufDataset SQL enhanced in-memory database for Free Pascal (FPC), operating with semicolon-separated values flat text tables as a persistence store.
4	4
5	5		This means you can use files to store your data but get the speed of in-memory processing. Completely written in Pascal, it has no dependencies on external libraries.
6	6
7	7		ZMSQL package consists of three components:
8	8
9	9		1\. TZMConnection - describes "database" as folder containing CSV files, and some common properties for all datasets.
10	10
11	11		2\. TZMQueryDataset - an in-memory dataset (TBufDataset descendent) capable of loading/saving from CSV files, loading/executing SQL queries (via integrated JanSQL database engine) and loading data from any other datasets. ZMQueryDatasets also have integrated properties for easy setting master/detail filtration.
12	12
13	13		3\. TZMReferentialKey - component that describes relation between master and slave dataset for referential integrity (insert, update, delete).
14	14
15	15		4\. TZMQueryBuilder - visual query builder.
16	16
17	17		ZMSQL offers:
18	18
19	19		- Loading from and saving to flat text tables
20	20		- Use of SQL to query the data
21	21		- Copy data and schema from other datasets
22	22		- Option to predefine fielddefs or create it on-the fly
23	23		- Master/detail filtering
24	24		- Referential integrity
25	25		- Parameterized queries
26	26		- visual query builder (currently does not yet suppport non-standard janSQL statements, only standard SQL)
27	27
28	28		The download contains the source code, some demo applications illustrating the features of the component as well as a readme.
29	29
30	30		# Author
31	31
32	32		\- Zlatko Matić (matalab@gmail.com); includes code from Jan Verhoeven and Martin Waldenburg.
33	33
34	34		Contact Zlatko Matić ("tatamata" in Lazarus forum) by e-mail: matic.zlatko@gmail.com or matalab@gmail.com
35	35
36	36		Contributors:
37	37
38	38		- Mario Ferrari (mario.ferrari@edis.it)
39	39		- Edgar Fernando Rodriguez Pacheco (edgarrod71@gmail.com)
40	40
41	41		# License
42	42
43	43		Modified LGPL and MPL 1.1 license: static and dynamic linking both allowed, even in commercial applications. Please see the individual licenses in the source files for details.
44	44
45	45		Contains:
46	46
47	47		- ZMSQL units, including zmbufdataset.pas, zmconnection.pas, zmquerydataset.pas, zmreferentialkey.pas: FPC modified LPGL
48	48		- JanSQL units, including JanSQL.pas, janSQLExpression2.pas, janSQLStrings.pas, janSQLTokenizer.pas by Jan Verhoeven: Mozilla Public License Version 1.1 (MPL)
49	49		- mwStringHashList.pas by Martin Waldenburg: Mozilla Public License Version 1.1 (MPL)
50	50
51	51		# Download
52	52
53	53		The latest stable release can be found on <http://sourceforge.net/projects/lazarus-ccr/files/zmsql/>.
54	54
55	55		# Published and Public properties and methods of TZMQueryDataset
56	56
57	57		``` pascal
58	58		public
59	59		{ Public declarations }
60	60		procedure QueryExecute; //Executes SQL query defined in SQL property, on .csv files that are placed in folder defined in ZMConnection property. Resultset of select query is loaded into the the zmquerydataset (self).
61	61		procedure PrepareQuery; //Prepares parameterized queries for execution: replaces parameters with parameter values for parameterized queries.
62	62		procedure EmptyDataSet; //Deletes all records from dataset.
63	63		procedure ClearDataSet; //Deletes records, fields and fielddefs.
64	64		procedure CopyFromDataset (pDataset:TDataSet); //Copies schema and data from any TDataset.
65	65		function SortDataset (const pFieldName:String):Boolean; //Ascending/Descending sorting of memory dataset.
66	66		procedure LoadFromTable; //Loads data (or data and schema) from a .csv file (TableName.csv), set in property TableName, from path specified in ZMConnection property.
67	67		procedure SaveToTable;overload; //Saves data and schema to a .csv file (TableName.csv), set in Tablename property, in path specified in ZMConnection property.
68	68		procedure SaveToTable(pDecimaSeparator:Char);overload; //Saves data and schema to a .csv file (TableName.csv), set in Tablename property, in path specified in ZMConnection property.
69	69		procedure CreateDynamicFieldsFromFieldDefs; // Creates fields from predefined fielddefs. To be used in design-time or run-time for memory dataset creation according to predefined fielddefs.
70	70		procedure CreatePersistentFieldsFromFieldDefs; // Creates PERSISTENT fields from predefined fielddefs. To be used in design-time only.
71	71		procedure MemoryDataSetOpen; //Executes CreateDynamicFieldsFromFieldDefs and set dataset to Active.
72	72		constructor Create(AOwner: TComponent); override;
73	73		destructor Destroy; override;
74	74		//Properties needed for master/detail and referential integrity
75	75		property MasterDataSetTo:TList read FMasterDataSetTo write SetMasterDataSetTo; // Defines master/detail relationship for purpose of master/detail filtration
76	76		property MasterReferentialKeys:TList read FMasterReferentialKeys write SetMasterReferentialKeys;//Defines master/detail relationship for purpose of referential integrity
77	77		property SlaveReferentialKeys:TList read FSlaveReferentialKeys write SetSlaveReferentialKeys; //Defines master/detail relationship for purpose of referential integrity
78	78		property DisableMasterDetailFiltration:Boolean read FDisableMasterDetailFiltration write SetDisableMasterDetailFiltration; //Master/detail filrtation should be temporarily desabled during bulk inserts or updates...
79	79		property OldRecord:TZMBufDataSet {TBufDataSet} read FOldRecord; //Last delete/insert/edit is preserved in this property.
80	80		published
81	81		{ Published declarations }
82	82		property ZMConnection:TZMConnection read FZMConnection write SetConnection; //Defines "database" folder path where .csv tables are placed. Instantiates JanSQL database engine.
83	83		property SQL:TStrings read FSQL write SetSQL; //Unprepared SQL query text.
84	84		property QueryExecuted:Boolean read FQueryExecuted write SetQueryExecuted; //"True" executes QueryExecute and loads resultset into dataset.
85	85		property TableName:String read FTableName write SetTableName; //Name of .csv file (without extension) from which is data loaded by LoadFromTable and to which is data and schema saved by SaveToTable.
86	86		property TableLoaded:Boolean read FTableLoaded write SetTableLoaded; //"True" executes LoadFromTable and loads resultset into dataset.
87	87		property TableSaved:Boolean read FTableSaved write SetTableSaved; //"True" executes SaveToTable and saves dataset to .csv file defined in TableName property, placed in folder specified by ZMConnection property.
88	88		property DynamicFieldsCreated:Boolean read FDynamicFieldsCreated write SetDynamicFieldsCreated; //"True" executes CreateDynamicFieldsFromFieldDefs, which creates fields from predefined fielddefs.
89	89		property PeristentFieldsCreated:Boolean read FPersistentFieldsCreated write SetPersistentFieldsCreated; //"True" executes CreatePersistentFieldsFromFieldDefs, which creates PERSISTENT fields from predefined fielddefs.
90	90		property MemoryDataSetOpened:Boolean read FMemoryDataSetOpened write SetMemoryDataSetOpened; //"True" executes CreateDynamicFieldsFromFieldDefs and activates dataset for editing.
91	91		property PersistentSave:Boolean read FPersistentSave write SetPersistentSave; //If "True", insert/delete/edit will immediately be written to underlying .csv file. If "False", then dataset is only in-memory.
92	92		property Parameters: TParams read FParameters write SetParameters; //Parameters for parameterized SQL text.
93	93		//Master/detail filtration
94	94		property MasterFields: TStrings read FMasterFields write SetMasterFields; //Fields in masterdatasource, (separated by ";") to be used for master/detail filtration.
95	95		property MasterSource: TDataSource read FMasterSource write SetMasterSource;//Master datasource for master/detail filtration.
96	96		```
97	97
98	98		# JanSQL SQL language
99	99
100	100		janSQL database engine supports only a subset of standard SQL but the supported statements are sufficient for single-user desktop application.
101	101
102	102		## Table updates
103	103
104	104		janSQL loads tables automatically into memory when needed by a query. Any changes to tables (INSERT, UPDATE, DELETE) are performed in memory. Tables are saved to disk when you use the COMMIT statement. The only exceptions to this are the CREATE TABLE statement, where the new table is saved to disk immediately and the DROP TABLE statement, where the table is immediately deleted from both memory and disk.
105	105
106	106		## Indexes
107	107
108	108		janSQL does not use indexes. You will find that for single-user desktop applications running in memory there is no urgent need for indexes.
109	109
110	110		## Case sensitivity
111	111
112	112		janSQL is case-insensitive for its keywords: you can use both SELECT and select.
113	113
114	114		## Non-standard
115	115
116	116		janSQL has several non-standard SQL statements for manipulation of recordsets.
117	117
118	118		- ASSIGN TO
119	119		- SAVE TABLE
120	120		- RELEASE TABLE
121	121
122	122		Compound Queries
123	123
124	124		You can execute multiple queries in a batch. Query expressions in a compound query must be separated by semi-colon. By using the non-standard ASSIGN TO statement you can store the result of a select query as a named variable that can be used in subsequent queries. This resembles SQL stored procedures in other database systems.
125	125
126	126		SQL syntax
127	127
128	128		A\) Data Definition Language
129	129
130	130		CONNECT TO
131	131
132	132		Connects to a database. In janSQL a database is a folder. Tables are stored in this folder as delimited text files with the .txt extension. Syntax: CONNECT TO 'absolute-folder-path'
133	133
134	134		Example:
135	135
136		-	~~` connect to 'G:' `\~~
	136	+	```text
	137	+	connect to 'G:'
	138	+	```
137	139
138	140		Notes
139	141
140	142		This is always the first statement that you use with janSQL. All other SQL statements require that the engine knows which folder to use.
141	143
142	144		CREATE TABLE
143	145
144	146		Creates a new table in the current catalog.
145	147
146	148		Syntax:
147	149
148		-	~~`CREATE TABLE tablename (field1,[fieldN])`~~
	150	+	```text
	151	+	CREATE TABLE tablename (field1,[fieldN])
	152	+	```
149	153
150	154		Example:
151	155
152		-	~~`CREATE TABLE users (userid,username,accountname, accountpassword)`~~
	156	+	```text
	157	+	CREATE TABLE users (userid,username,accountname, accountpassword)
	158	+	```
153	159
154	160		Notes
155	161
156	162		janSQL does not use fieldtypes. Everything is stored as text. Internally janSQL treats all data as variants. This means that in your SQL queries you can use fields pretty much the way you want to.
157	163
158	164		DROP TABLE
159	165
160	166		Drops a table from the database.
161	167
162	168		Syntax:
163	169
164		-	~~`DROP TABLE tablename`~~
	170	+	```text
	171	+	DROP TABLE tablename
	172	+	```
165	173
166	174		Syntax:
167	175
168		-	~~`DROP TABLE users`~~
	176	+	```text
	177	+	DROP TABLE users
	178	+	```
169	179
170	180		Notes
171	181
172	182		Use with care, because it deletes a file from hard disk.
173	183
174	184		ALTER TABLE
175	185
176	186		Allows you to alter the structure of a table.
177	187
178	188		Syntax:
179	189
180		-	~~`ALTER TABLE ADD COLUMN columnname`\~~
181		-	~~`ALTER TABLE DROP COLUMN columnname`~~
	190	+	```text
	191	+	ALTER TABLE ADD COLUMN columnname
	192	+	ALTER TABLE DROP COLUMN columnname
	193	+	```
182	194
183	195		You can only add or drop one column at the time.
184	196
185	197		B\) Data Manipulation Language
186	198
187	199		SELECT FROM
188	200
189	201		Allows you to select data from one or two tables.
190	202
191	203		Syntax:
192	204
193		-	~~` SELECT fieldlist FROM tablename`\~~
194		-	~~` SELECT fieldlist FROM tablename WHERE condition`\~~
195		-	~~` SELECT fieldlist FROM tablename1 [alias1], tablenameN [aliasN]`\~~
196		-	~~` SELECT fieldlist FROM tablename1 [alias1], tablenameN [aliasN] WHERE condition`~~
	205	+	```text
	206	+	SELECT fieldlist FROM tablename
	207	+	SELECT fieldlist FROM tablename WHERE condition
	208	+	SELECT fieldlist FROM tablename1 [alias1], tablenameN [aliasN]
	209	+	SELECT fieldlist FROM tablename1 [alias1], tablenameN [aliasN] WHERE condition
	210	+	```
197	211
198	212		fieldlist can be * for selecting all fields or field1\[,fieldN\]
199	213
200	214		field: fieldname \[AS fieldalias\]
201	215
202	216		condition: see the WHERE topic.
203	217
204	218		Notes
205	219
206	220		When you join two or more tables [[you must]] use fully qualified field names: tablename.fieldname in the WHERE clause. Both tablenames and fieldnames can be aliased.
207	221
208		-	~~`SELECT u.userid as mio, u.username as ma, p.productname as muu`\~~
209		-	~~`FROM users u,products p`\~~
210		-	~~`WHERE u.productid=p.productid`~~
	222	+	```text
	223	+	SELECT u.userid as mio, u.username as ma, p.productname as muu
	224	+	FROM users u,products p
	225	+	WHERE u.productid=p.productid
	226	+	```
211	227
212	228		Using a table alias can save you typing.
213	229
214		-	~~` select products.productname as product,count(users.userid) as quantity`\~~
215		-	~~` from users,products`\~~
216		-	~~` where users.productid=products.productid`\~~
217		-	~~` group by product`\~~
218		-	~~` having quantity>10`\~~
219		-	~~` order by product desc`\~~
	230	+	```text
	231	+	select products.productname as product,count(users.userid) as quantity
	232	+	from users,products
	233	+	where users.productid=products.productid
	234	+	group by product
	235	+	having quantity>10
	236	+	order by product desc
	237	+	```
220	238
221	239		The example above shows you that in the WHERE clause you refer to source tables (e.g. products.productid) where as in the GROUP BY, HAVING and ORDER BY clause, you refer to the result table.
222	240
223	241		Always use an aliased field name when using an aggregate function:
224	242
225		-	~~`count(users.userid) as quantity`\~~
	243	+	```text
	244	+	count(users.userid) as quantity
	245	+	```
226	246
227	247		WHERE
228	248
229	249		The WHERE clause can be used together with the SELECT, UPDATE and DELETE clauses.
230	250
231	251		Syntax:
232	252
233		-	~~`WHERE condition`\~~
	253	+	```text
	254	+	WHERE condition
	255	+	```
234	256
235	257		condition:
236	258
237	259		The condition is an expression that must evaluate to a boolean true or false. The following operators are allowed:
238	260
239	261		Arithmetic:
240	262
241	263		\+ - * / ( )
242	264
243	265		Logic:
244	266
245	267		and, or
246	268
247	269		comparison: \< \<= = \> \>=
248	270
249	271		string constants: e.g. 'Jan Verhoeven'
250	272
251	273		numeric constans: e.g. 12.45
252	274
253	275		fieldnames e.g. userid, users.userid
254	276
255	277		IMPORTANT NOTE: Sometimes JanSQL engine can't process WHERE clause if there are several conditions and joins. In that case application will freeze. Therefore, try to simplify WHERE clause of the main expression by filtering one of the joined tables prior the main expression. Split the main query into few steps (use subqueries!). This means you have to split the main expression into, for example, two expressions and assign the first one to a variable (ASSIGN TO) that you will use instead of the original table.
256	278
257	279		IN
258	280
259	281		e.g.
260	282
261		-	~~` userid IN (300,401,402)`\~~
262		-	~~` username IN ('Verhoeven','Smith')`~~
	283	+	```text
	284	+	userid IN (300,401,402)
	285	+	username IN ('Verhoeven','Smith')
	286	+	```
263	287
264	288		LIKE
265	289
266	290		e.g.
267	291
268		-	~~` username Like '%Verhoeven'`~~
	292	+	```text
	293	+	username Like '%Verhoeven'
	294	+	```
269	295
270	296		You can use the % character as a placeholder to match any series of characters:
271	297
272		-	~~` '%Verhoeven' will match Verhoeven at the end of username`\~~
273		-	~~` 'Verhoeven%' will match Verhoeven at the beginning of username`\~~
274		-	~~` '%Verhoeven%' will match Verhoeven anywhere in username`\~~
275		-	~~` `~~
	298	+	``` pascal
	299	+	'%Verhoeven' will match Verhoeven at the end of username
	300	+	'Verhoeven%' will match Verhoeven at the beginning of username
	301	+	'%Verhoeven%' will match Verhoeven anywhere in username
	302	+	```
276	303
277	304		Sub queries
278	305
279	306		You can use a subquery after the IN clause. Only non-correlated sub queries are allowed at the moment. A sub query must select a single field from a table. A sub query is executed at parsing time and returns a comma seperated list of values that replaces the query text in the IN clause. A sub query must be enclosed by brackets. Example: select * from users where productid in (select product id from products where productname like 'Ico%')
280	307
281	308		Notes When using a SELECT with a join between 2 tables [[you must]] use fully qualified names (tablename.fieldname) in every part of the query. In all other cases (UPDATE, INSERT) [[you must]] use the short form fieldname without the tablename. Repeat it once again: if more than one table joined in sql query, you must use tablename.fieldname; if only one table in a query, you must use fieldname without table name (only fieldname).
282	309
283	310		GROUP BY
284	311
285	312		Allows you to group data according grouping fields. Syntax:
286	313
287		-	~~` group by fieldlist`~~
	314	+	```text
	315	+	group by fieldlist
	316	+	```
288	317
289	318		fieldlist is a comma seperated list of one or more fields that you want to grouping to be applied. Example:
290	319
291		-	~~` select count(userid), username, productid`\~~
292		-	~~` from users`\~~
293		-	~~` group by productid`\~~
294		-	~~` order by productid`\~~
	320	+	```text
	321	+	select count(userid), username, productid
	322	+	from users
	323	+	group by productid
	324	+	order by productid
	325	+	```
295	326
296	327		Aggregate functions
297	328
298	329		You can apply the count, sum, avg, max, min, stddev function to an input field. When you use these functions without a GROUP BY clause, the resultset will contain only one row.
299	330
300	331		HAVING
301	332
302	333		Allows you to filter a recordset resulting from a GROUP BY clause. Syntax:
303	334
304		-	~~` HAVING expression `~~
	335	+	```text
	336	+	HAVING expression
	337	+	```
305	338
306	339		Example:
307	340
308		-	~~` select count(userid), username, productid`\~~
309		-	~~` from users`\~~
310		-	~~` group by productid`\~~
311		-	~~` having userid>10`\~~
312		-	~~` order by productid`\~~
	341	+	```text
	342	+	select count(userid), username, productid
	343	+	from users
	344	+	group by productid
	345	+	having userid>10
	346	+	order by productid
	347	+	```
313	348
314	349		Notes
315	350
316	351		Experienced SQL users will notice that janSQL uses a non-standard syntax in the HAVING clause. Instead of the standard having count(userid)\>10, in janSQL you just use the name of the base table field, in this case userid.
317	352
318	353		You should be aware of the difference between the WHERE clause and the HAVING clause. The WHERE clause is applied to table(s) in the FROM clause. The HAVING is applied after filtering with where and grouping with group by have been applied. The same applies to the ORDER BY clause which is also applied to the final result set.
319	354
320	355		ORDER BY
321	356
322	357		Allows you to sort the resulting recordsets. Syntax:
323	358
324		-	~~` ORDER BY orderlist`~~
	359	+	```text
	360	+	ORDER BY orderlist
	361	+	```
325	362
326	363		Example:
327	364
328		-	~~` select * from users order by #userid asc, productid desc `~~
	365	+	```text
	366	+	select * from users order by #userid asc, productid desc
	367	+	```
329	368
330	369		orderlist is a comma seperated list of one or more order by components: component1\[,componentN\] ordercomponent: \[#\]fieldname \[ASC\\|DESC\]
331	370
332	371		By placing the optional \# before a fieldname it will be treated as a numeric field in the sort. Remember that in janSQL all data is stored as text. After the fieldname you can optionally put ASC for an ascending sort, or DESC for a descending sort. When you omit the sort direction the default ascending sort order is used.
333	372
334	373		ASSIGN TO
335	374
336	375		Allows you to assign the result of a SELECT statement to a named recordset that can be referred to in subsequent statements. This is a non-standard SQL statement. ASSIGN TO is like a variable assignment. You can create very complex compound queries with ASSIGN TO.
337	376
338	377		Syntax:
339	378
340		-	~~` ASSIGN TO tablename selectstatement`~~
	379	+	```text
	380	+	ASSIGN TO tablename selectstatement
	381	+	```
341	382
342	383		Example:
343	384
344		-	~~` ASSIGN TO mis SELECT userid, username FROM users`~~
	385	+	```text
	386	+	ASSIGN TO mis SELECT userid, username FROM users
	387	+	```
345	388
346	389		If tablename allready exists in the catalog then an error occurs. When tablename does not exist in the catalog but was allready assigned to then the existing recordset is overwritten.
347	390
348	391		Notes Make sure that you use output field alias names when you ASSIGN TO using a SELECT with joined tables.
349	392
350	393		When you execute the ASSIGN TO the given name will be assigned to the new recordset and the recordset itself will not be released until you use RELEASE TABLE.
351	394
352	395		RELEASE TABLE
353	396
354	397		Allows you to release any open table from memory, including intermediate tables created with ASIGN TO. This is a non-standard SQL statement. Syntax:
355	398
356		-	~~` RELEASE TABLE tablename`~~
	399	+	```text
	400	+	RELEASE TABLE tablename
	401	+	```
357	402
358	403		Example:
359	404
360		-	~~` ASSIGN TO mis SELECT * FROM users`\~~
361		-	~~` RELEASE TABLE mis`~~
	405	+	```text
	406	+	ASSIGN TO mis SELECT * FROM users
	407	+	RELEASE TABLE mis
	408	+	```
362	409
363	410		SAVE TABLE
364	411
365	412		Allows you to save any open table, including intermediate tables, to a file. This is a non-standard SQL statement. Syntax:
366	413
367		-	~~` SAVE TABLE tablename`~~
	414	+	```text
	415	+	SAVE TABLE tablename
	416	+	```
368	417
369	418		When tablename is not open, an error occurs. When you save an intermediate table (created with ASSIGN TO), the intermediate table becomes a persistant table that is also saved with the COMMIT statement.
370	419
371	420		Example: ASSIGN TO mis SELECT * FROM users
372	421
373		-	~~` SAVE TABLE mis`~~
	422	+	```text
	423	+	SAVE TABLE mis
	424	+	```
374	425
375	426		Notes Once you have saved an intermediate table with TABLE SAVE you can not ASSIGN TO anymore.
376	427
377	428		INSERT INTO
378	429
379	430		Allows you to insert data in a table, either row by row or from a recordset resulting from a SELECT. Syntax:
380	431
381		-	~~` INSERT INTO tablename [(column1[,column])] VALUES (field1[,fieldN])`\~~
382		-	~~` INSERT INTO tablename selectstatement`~~
	432	+	```text
	433	+	INSERT INTO tablename [(column1[,column])] VALUES (field1[,fieldN])
	434	+	INSERT INTO tablename selectstatement
	435	+	```
383	436
384	437		Example:
385	438
386		-	~~` INSERT INTO users VALUES (600,'user-600');`\~~
387		-	~~` INSERT INTO users (userid,username) VALUES (601,'user-601');`\~~
388		-	~~` INSERT INTO users SELECT * FROM users WHERE userid>400`~~
	439	+	```text
	440	+	INSERT INTO users VALUES (600,'user-600');
	441	+	INSERT INTO users (userid,username) VALUES (601,'user-601');
	442	+	INSERT INTO users SELECT * FROM users WHERE userid>400
	443	+	```
389	444
390	445		Notes When you insert records using a sub select you must make sure that the output fields of the sub select match the fieldnames of tablename. Only values of matching field will be inserted.
391	446
392	447		UPDATE
393	448
394	449		Allows you to update existing data. Syntax:
395	450
396		-	~~` UPDATE tablename SET updatelist [WHERE condition]`~~
	451	+	```text
	452	+	UPDATE tablename SET updatelist [WHERE condition]
	453	+	```
397	454
398	455		updatelist: field1=value1\[,fieldN=valueN\]
399	456
400	457		condition: see WHERE for the optional condition
401	458
402	459		DELETE FROM
403	460
404	461		Allows you to delete data. Syntax:
405	462
406		-	~~` DELETE FROM tablename WHERE condition`~~
	463	+	```text
	464	+	DELETE FROM tablename WHERE condition
	465	+	```
407	466
408	467		condition: see WHERE clause for the condition.
409	468
410	469		C) Functions
411	470
412	471		In janSQL you can use functions wherever you can use an expression to be calculated (Calculated output fields, WHERE clause, HAVING clause).
413	472
414	473		Use extra brackets around function parameters when you have a function with more than one parameter:
415	474
416		-	~~` SELECT trunc((userid/7),2) as foo FROM users`\~~
	475	+	```text
	476	+	SELECT trunc((userid/7),2) as foo FROM users
	477	+	```
417	478
418	479		and not:
419	480
420		-	~~` SELECT trunc(userid/7,2) as foo FROM users`~~
	481	+	```text
	482	+	SELECT trunc(userid/7,2) as foo FROM users
	483	+	```
421	484
422	485		Conversion
423	486
424	487		fix(expression,precision)
425	488
426	489		Returns the string presentation of (numeric) expression with precision number of decimals.
427	490
428		-	~~` select fix((userid/7), 2) as bobo from users order by bobo`\~~
	491	+	```text
	492	+	select fix((userid/7), 2) as bobo from users order by bobo
	493	+	```
429	494
430	495		You can also use TRUNC i.s.o. FIX.
431	496
432	497		asnumber(expression)
433	498
434	499		Returns (number or string) expression as number. If expression is not a valid floating point number then the function returns 0.
435	500
436	501		FORMAT function
437	502
438	503		Formats a integer or floating point value to a string in a way specified by a format string. Syntax:
439	504
440		-	~~` format(value,formatstring) `~~
	505	+	```text
	506	+	format(value,formatstring)
	507	+	```
441	508
442	509		Example:
443	510
444		-	~~` update users set userid=format(userid,'%.8d')`~~
	511	+	```text
	512	+	update users set userid=format(userid,'%.8d')
	513	+	```
445	514
446	515		Format strings have the following form: \[literalstring\]"%" \[width\] \["." prec\] type
447	516
448	517		• An optional literal string that is copied to the output • An optional width specifier, \[width\] • An optional precision specifier, \["." prec\] • The conversion type character, type
449	518
450	519		The following table summarizes the possible values for type:
451	520
452	521		d
453	522
454	523		Decimal. The argument must be an integer value. The value is converted to a string of decimal digits. If the format string contains a precision specifier, it indicates that the resulting string must contain at least the specified number of digits; if the value has less digits, the resulting string is left-padded with zeros.
455	524
456	525		u
457	526
458	527		Unsigned decimal. Similar to 'd' but no sign is output.
459	528
460	529		e
461	530
462	531		Scientific. The argument must be a floating-point value. The value is converted to a string of the form "-d.ddd...E+ddd". The resulting string starts with a minus sign if the number is negative. One digit always precedes the decimal point.The total number of digits in the resulting string (including the one before the decimal point) is given by the precision specifier in the format string—a default precision of 15 is assumed if no precision specifier is present. The "E" exponent character in the resulting string is always followed by a plus or minus sign and at least three digits.
463	532
464	533		f
465	534
466	535		Fixed. The argument must be a floating-point value. The value is converted to a string of the form "-ddd.ddd...". The resulting string starts with a minus sign if the number is negative.The number of digits after the decimal point is given by the precision specifier in the format string—a default of 2 decimal digits is assumed if no precision specifier is present.
467	536
468	537		g
469	538
470	539		General. The argument must be a floating-point value. The value is converted to the shortest possible decimal string using fixed or scientific format. The number of significant digits in the resulting string is given by the precision specifier in the format string—a default precision of 15 is assumed if no precision specifier is present.Trailing zeros are removed from the resulting string, and a decimal point appears only if necessary. The resulting string uses fixed point format if the number of digits to the left of the decimal point in the value is less than or equal to the specified precision, and if the value is greater than or equal to 0.00001. Otherwise the resulting string uses scientific format.
471	540
472	541		n
473	542
474	543		Number. The argument must be a floating-point value. The value is converted to a string of the form "-d,ddd,ddd.ddd...". The "n" format corresponds to the "f" format, except that the resulting string contains thousand separators.
475	544
476	545		m
477	546
478	547		Money. The argument must be a floating-point value. The value is converted to a string that represents a currency amount. The conversion is controlled by the CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator, DecimalSeparator, and CurrencyDecimals global variables, all of which are initialized from the Currency Format in the International section of the Windows Control Panel. If the format string contains a precision specifier, it overrides the value given by the CurrencyDecimals global variable.
479	548
480	549		s
481	550
482	551		String. The argument must be a string value. The string is inserted in place of the format specifier. The precision specifier, if present in the format string, specifies the maximum length of the resulting string. If the argument is a string that is longer than this maximum, the string is truncated.
483	552
484	553		x
485	554
486	555		Hexadecimal. The argument must be an integer value. The value is converted to a string of hexadecimal digits. If the format string contains a precision specifier, it indicates that the resulting string must contain at least the specified number of digits; if the value has fewer digits, the resulting string is left-padded with zeros.
487	556
488		-	`Date functions`` `
	557	+	```text
	558	+	Date functions
	559	+	```
489	560
490	561		Several date functions make working with date strings easier.
491	562
492	563		YEAR
493	564
494	565		Extracts the integer year part of a yyyy-mm-dd date string.
495	566
496	567		MONTH
497	568
498	569		Extracts the integer month part of a yyyy-mm-dd date string.
499	570
500	571		DAY
501	572
502	573		Extracts the integer day part of a yyyy-mm-dd date string.
503	574
504	575		WEEKNUMBER
505	576
506	577		Returns the integer weeknumber of a yyyy-mm-dd date string.
507	578
508	579		EASTER
509	580
510	581		Returns the easter yyyy-mm-dd date string of a given integer year.
511	582
512	583		DATEADD
513	584
514	585		Adds a given number of time intervals to a given data and returns the resulting data as a yyyy-mm-dd data string. Syntax:
515	586
516		-	~~` DATEADD(interval,number,datestring)`\~~
	587	+	```text
	588	+	DATEADD(interval,number,datestring)
	589	+	```
517	590
518	591		Interval can be: 'd' (day), 'm' (month), 'y' (year), 'w' (week), 'q' (quarter). Number must be an integer number. datestring must be in the yyyy-mm-dd format.
519	592
520		-	`String Functions`` `
	593	+	```text
	594	+	String Functions
	595	+	```
521	596
522	597		janSQL comes with a range of functions that work on strings.
523	598
524	599		soundex(expression) Calculates the soundex value of (string) expression. Only usefull with english terms.
525	600
526	601		lower(expression) Converts (string) expression to lower case.
527	602
528	603		upper(expression) Converts (string) expression to upper case.
529	604
530	605		trim(expression) Trims (string) expression from leading and trailing spaces.
531	606
532	607		left(expression,count) Returns the first count characters of expression
533	608
534	609		right(expression,count) Returns the last count characters of expression
535	610
536	611		mid(expression,from,count) Returns count characters of expression starting at from.
537	612
538	613		length(expression) Returns the length of (string) expression. Can be used to e.g. select fields that exceed a given length.
539	614
540	615		replace(source,oldpattern,newpattern) Replaces oldpattern with new pattern in the source string. Is case-insensitive.
541	616
542		-	~~` UPDATE users SET username=replace(username,'user-','foo-')`\~~
	617	+	```text
	618	+	UPDATE users SET username=replace(username,'user-','foo-')
	619	+	```
543	620
544	621		substr_after(source,substring) Returns the part of source that comes after substring. If substring is not found an empty string is returned.
545	622
546	623		substr_before(source,substring) Returns the part of source that comes before substring. If substring is not found an empty string is returned.
547	624
548		-	`Numeric Functions`` `
	625	+	```text
	626	+	Numeric Functions
	627	+	```
549	628
550	629		Numeric functions work on strings as if they were numbers. Although janSQL is based on strings you can still enter values like 1234, which can be treated like numbers.
551	630
552	631		sqr(expression) Calculates the square of (numeric) expression.
553	632
554	633		sqrt(expression) Calculates the square root of (numeric) expression.
555	634
556	635		sin(expression) Calculates the sin of (numeric) expression.
557	636
558	637		cos(expression) Calculates the cos of (numeric) expression.
559	638
560	639		ceil(expression) Returns the lowest integer greater than or equal to (numeric) expression.
561	640
562	641		floor(expression) Returns the the highest integer less than or equal to (numeric) expression.
563	642
564	643		# Dependencies / System Requirements
565	644
566	645		- None
567	646
568	647		Status: Alpha
569	648
570	649		# Open issues/improvement ideas
571	650
572	651		Below is a list of open issues (or bugs, if you want) and improvement ideas. If you have any patches/fixes for the code (not limited to these issues), please let use know via the ZMSQL thread on the forum: [1](http://lazarus.freepascal.org/index.php/topic,13821.0.html) Of course, ZMSQL is part of the Lazarus CCR repository, so you can post bug reports/patches on Mantis using the CCR category.
573	652
574	653		1\. TBufDataset bug Currently TBufDataSet (ancestor of TZMQueryDataSet) has a bug (http://bugs.freepascal.org/view.php?id=19631 is solved!) that causes Refresh method to delete all records
575	654
576	655		2\. Slow query execution in JanSQL Extremely slow query execution when more than one table joined in query when there is an additional where clause in the query. It can be overcome with the "ASSIGN TO variable" non-standard expression First execute query on a table with where clasue, assign resultset to a variable and then use the variable in a second query (instead of the table).
577	656
578	657		Thus, instead of: "SELECT ordrs.ordr AS order, ordrs.ordr_type AS order type,ordrs.prdct AS product,ordrs.prdct_dscr AS product description,ordrs.prdct_targ_qty AS order quantity,ordrs.prdct_targ_qty_unt AS order unit,rqrmts.cmpnt AS component,rqrmts.cmpnt_dscr AS component description,rqrmts.cmpnt_rqrd AS required quantity of component FROM ordrs,rqrmts WHERE ordrs.ordr=rqrmts.ordr AND ordrs.prdct=10010356;", use this non-standard SQL expression: "ASSIGN TO temp_ordrs SELECT * from ordrs WHERE prdct=10010356; SELECT temp_ordrs.ordr AS order, temp_ordrs.ordr_type AS order type,temp_ordrs.prdct AS product,temp_ordrs.prdct_dscr AS product description,temp_ordrs.prdct_targ_qty AS order quantity,temp_ordrs.prdct_targ_qty_unt AS order unit,rqrmts.cmpnt AS component,rqrmts.cmpnt_dscr AS component description,rqrmts.cmpnt_rqrd AS required quantity of component FROM temp_ordrs,rqrmts WHERE temp_ordrs.ordr=rqrmts.ordr;"
579	658
580	659		3\. JanSQL has problems with typecasts. It can be tricky to guess how to cast values. Use 'ASNUMBER(some_value) AS something' whenever you do something with numerical values.
581	660
582	661		4\. Parameter support is currently quite limited. Basically, named parameters must be used and they are replaced by its values as literal strings. You must enclose parameter identifiers in SQL string by quotes!
583	662
584	663		5\. Multiline support Investigate setting the sdfdata.AllowMultiline property to true when required to allow CSV data that contains line breaks. See <http://bugs.freepascal.org/view.php?id=17285> Not sure whether JanSQL database engine is able to handle this? The parameters set for SdfDataset in zmsql corresponds to the csv format that JanSQL uses
585	664
586	665		6\. Missing outer (lef and right) joins in SQL queries Absence of outer joins in sql queries siriously limits sql capabilities. It can be partially overcomed by using non-standard 'ASSIGN TO variable' statement, which means that you can create subqueries to be used in further sql statement. However, improving janSQL engine to be able to execute left and righ outer joins should be solved till beta.
587	666
588	667		# Installation
589	668
590	669		- Unpack
591	670		- Compile
592	671
593	672		You may also need to add LCLPlatformDef to the implementation uses list of unit QBuilder. ZMSQL uses some constants defined in LCLPlatformDef. At least under Lazarus 1.7 development version.
594	673
595	674		# The Demo Applications
596	675
597	676		Installation
598	677
599	678		- Open the applications in TestProject and TestProject1
600	679		- compile
601	680		- run
602	681
603	682		# See Also
604	683
605	684		- [[CSV]]
606	685		- [[JCSV (Jans CSV Components)]]
607	686
608	687		# Change Log
609	688
610	689		For more details, see zmquerydataset.pas
611	690
612	691		Current version 0.1.20: 19.08.2017\
613	692		ZMSQL version 0.1.20, 19.08.2017: various improvements by Edgar Fernando Rodriguez Pacheco (edgarrod71@gmail.com)
614	693
615	694		ZMSQL version 0.1.19, 08.02.2015: by Zlatko Matić
616	695
617	696		- New component TZMQueryBuilder, based on Open QBuilder Engine, is added to the zmsql package.
618	697
619	698		TZMQueryBuilder uses TOQBEngineZmsql, which is TOQBEngine descendant. TOQBEngineZmsql is in based on code of the Open QBuilder Engine for SQLDB Sources created by Reinier Olislagers, modified and adapted for the ZMSQL by Zlatko Matić. It incorporates QBuilder visual query builder(Copyright (c) 1996-2003 Sergey Orlik , Copyright (c) 2003 Fast Reports, Inc.)
620	699
621	700		- Added procedure TZMConnection.GetTableNames(FileList: TStrings);
622	701		- Added procedure TZMQueryDataSet.LoadTableSchema;
623	702
624	703		ZMSQL version 0.1.18, 10.04.2014: by Zlatko Matić
625	704
626	705		- Bugfix release. There was funny bug in zmquerydataset destroy method - dataset would be saved prior destroying if persistent save was enebaled.
627	706
628	707		This was wrong, causing saving CSV file copy in wrong directory.
629	708
630	709		ZMSQL version 0.1.17, 07.03.2014: by Mario Ferrari
631	710
632	711		- Error situations that used ShowMessage now raise a generic exception containing the message itself. Only one ShowMessage remains for a design-time case.
633	712
634	713		ZMSQL version 0.1.16, 28.01.2014: by Zlatko Matić
635	714
636	715		- Internal optimizations and bugfixes.
637	716		- Creation of JanSQL instances moved from ZMConnection to ZMQueryDataset, in order that ZMQueryDataset can be used in multithreaded applications.
638	717		- New properties (ReferentialUpdateFired, ReferentialDeleteFired, ReferentialInsertFired) that tells that a referential action is in progress.
639	718
640	719		ZMSQL version 0.1.15, 28.01.2014: by Zlatko Matić
641	720
642	721		- Internal optimizations and bugfixes.
643	722		- Autoincrement fields (ftAutoInc) are now working.
644	723		- Improved visibility of TDataset methods and properties.
645	724		- ZMQueryDataset now works with TBufDataset as ancestor (as in CodeTyphon v.4.70). ZMBufDataset upgraded to the current TBufDataset in CodeTyphon v. 4.70.
646	725		- Added property MasterDetailFilter: Boolean which switches master/detail filtration on/off.
647	726		- Removed property DecimalSeparator. ZMSQL now use system settings for decimal and thousand separator.
648	727		- ZMQueryDataset can handle float value even if thousand separator is present (in a .csv file).
649	728		- Better handling locale settings and conversion from ANSI to UTF8.
650	729		- Persistent fields are working now.
651	730
652	731		(Solved by a trick: persistent fields loaded from .lfm are recreated, propertie from old fields are copied to new fields and old fielsa are deleted.
653	732
654	733		Current version 0.1.14: 01 January 2014\
655	734		ZMSQL version 0.1.14, 01.01.2014: by Zlatko Matić
656	735
657	736		- Internal optimizations.
658	737		- Based on TZMBufDataset instead TBufDataset, because problems with current TBufDataset version.
659	738		- ZMQueryDataset now loads from and saves to files with .csv extension, instead of .txt extension.
660	739		- Added ManageFields method, which decides what to do with Fields and FieldDefs.
661	740		- Reworked InspectFields procedure, better deduction of FieldDefs and Fields status.
662	741		- Enabled automatic creation of persistent fields objects from predefined fielddefs.
663	742		- New published properties: DynamicFieldsCreated, PeristentFieldsCreated, MemoryDataSetOpened,
664	743		- New public methods: CreateDynamicFieldsFromFieldDefs, CreatePersistentFieldsFromFieldDefs;
665	744		- Added "\$DEFINE ZMBufDataset" compiler directive.
666	745
667	746		ZMSQL version 0.1.13, 13.01.2013: by Zlatko Matić
668	747
669	748		- Few bug fixes.
670	749		- TZMbufdataset replaced with current TBufDataset as ancestor. Tested with current FPC 2.7.1 in CodeTyphon v. 3.10.
671	750
672	751		If this does not work for your FPC version, then replace TBufDataSet with TZMBufDataset as ancestor. The TZMBufDataset will stay present latent inside the package, just in case that further development od TBufDataSet goes in direction incompatible with zmsql.
673	752
674	753		- Added procedure InternalRefresh;override;
675	754
676	755		TBufDataSet's InternalRefresh does troubles, so it is overriden to do nothing. It seems that all functionalities which ZMQueryDataset needs are implemented inside TDataSet's Refresh method and that InternalRefresh is not needed at all.
677	756
678	757		ZMSQL version 0.1.12, 12.02.2012
679	758
680	759		- Critical bug in DoBeforeDelete solved: The bug was causing referential deletion of all records, even those not related.
681	760		- Few enhancements regarding persistent save functionality.
682	761
683	762		ZMSQL version 0.1.11, 05.02.2012
684	763
685	764		- DoAfterScroll call added to DoFilterRecord,in order to referesh detail dataset after filtering master dataset.
686	765		- FormatSettings.QuoteStrings:=\[qsAlways\] added in SaveToCSV method, so that strings are saved enclosed in double guotes.
687	766		- FloatDisplayFormat property added to ZMConnection. If set, it will be applied to all connected zmquerydatasets and override TFloatField's settings defined in zmquerydatasets.
688	767		- SetFloatDisplayFormat method added. This method takes formatting from FloatDisplayFormat property of ZMConnection, if set. Call to SetFloatDisplayFormat added in FieldsFromScratch and FieldsFromFieldDefs.
689	768		- Since in Jansql DecimalSeparator:=SysUtils.DefaultFormatSettings.DecimalSeparator has been added, so that jansql takes-over system decimal separator, the same is added to SaveToCSV method. It means that now zmquerydataset executes queries, loads data from CSV and saves dataset to csv using system settings for decimal separator. System settings can be, however, overriden by changing values of ZMConnection's properties DecimalSeparator and FloatDisplayFormat.
690	769		- ZMFieldsFromFieldDefs renamed to FieldsFromFieldDefs; ZMFieldsFromScratch renamed to FieldsFromScratch.
691	770
692	771		ZMSQL version 0.1.10, 20 January 2012
693	772
694	773		- procedure CopyFromDataset rewritten in way that now it uses ZMFieldsFromScratch and ZMFieldFromFieldDefs methods for dynamical fields creation.
695	774
696	775		In case of previously defined fielddefs, they will be used, otherwise, fielddefs from a dataset will be copied to ZMQueryDataset.
697	776
698	777		- FSourceData expanded to sdOtherDataset. FOtherDatasetImport added.
699	778
700	779		ZMSQL version 0.1.9, 15 January 2012
701	780
702	781		- Bug fixes in DoFilterRecord and SetMasterSource procedures, to enable custom filtration working correctly.
703	782		- In procedure TZMQueryDataSet.ZMFieldsFromScratch added formula for setting MaxIndexes count.
704	783
705	784		The formula is: MaxIndexesCount:=(2*(self.FieldDefs.Count)+3).This default value includes ascending and descending index on every column, two default TBufDataset indexes and one spare index. The formula is used in cases when LoadFromCSV or QueryExecute is called without prior FiedlDefs definition. You can still set MaxIndexesCount to any value before calling CreateDataset. Note that in zmsql you can use function SortDataset (const pFieldName:String):Boolean that creates indexes on the fly.
706	785
707	786		- Bug fix in EmptyDataset method, so that it delete all records in case of active filter.
708	787
709	788		ZMSQL version 0.1.8, 08 January 2012
710	789
711	790		- Since there was no visible improvement in BufDataSet regarding "Refresh bug" for a very long time, and it seems that TBufDataset is not maintained successfully any more, I have decided to base zmsql on last stable TBufDataset version that performed Refresh method correctly,which appears to be present in fpc 2.2.4.
712	791
713	792		Therefore, new zmbufdataset.pas and zmbufdatasetparser.pp units are now actually downgraded to fpc 2.2.4. This choise will not change anymore and this is starting point for further independent development of zmbufdataset unit as direct ancestor of zmquerydataset. However, we can always come back to TBufDataset as direct ancestor of zmquerydataset (while preserving zmbufdataset as an alternative) if following criteria is met:
714	793
715		-	~~` 1. DoFilterRecord method is virtual and protected.`\~~
716		-	~~` 2. Refresh method works correctly `~~
	794	+	```text
	795	+	1. DoFilterRecord method is virtual and protected.
	796	+	2. Refresh method works correctly
	797	+	```
717	798
718	799		Until then, zmbufdataset remains direct ancestor of zmquerydataset and will fork from TBufDataset development.
719	800
720	801		- Reconnecting of ZMConnection is added in QueryExecute and LoadFromCSV methods, each time data is loaded by query or import from csv.
721	802
722	803		This prevents peculiar inconsistences observed during query execution in some circumstances. This odd behavior of jansql has to be throughly investigated...
723	804
724	805		- In previous versions regular filtering was broken by DoFilterRecord everriding. It is solved now by adding:"if not Acceptable then exit;" after "inherited DoFilterRecord(Acceptable);". this way normal filtering functionality with Filter and Filtered properties is preserved.
725	806
726	807		ZMSQL version 0.1.7, 01 January 2012
727	808
728	809		- FDoReferentialUpdate:Boolean field added to signalize dsEdit state in DoBeforePost, which is then used in DoAfterPost as signal to perform referential update. This solved bug that caused referential update of all records in case of insert.
729	810
730	811		- Added public read-only property OldRecord. This can be useful during run-time.
731	812
732	813		ZMSQL version 0.1.6, 28 December 2011
733	814
734	815		- Referential update logic moved from DoBeforePost to DoAfterPost procedure, in order to solve problems with multilevel referential integrity.
735	816
736	817		- UpdateFOldRecord triggering moved from DoAfterScroll and DoAfterPost to DoBeforeInsert, DoBeforeDelete and DoBeforeEdit.
737	818
738	819		- Inspecting and matching of referential conditions for referential update changed from custom filtering to iteration and inspection for referential conditions for every record of SlaveDataset.
739	820
740	821		- Bugs in PrepareQuery and DoFilterRecord, as well as few other small bugs are solved.
741	822
742	823		- ZMBufDataSet updated with recent bufdataset changes.
743	824
744	825		- ZMBufDataSetParser added to package.
745	826
746	827		- Bug in Disconnect procedure solved.
747	828
748	829		Change commit: 4 September 2011
749	830
750	831		- Added some things to JanSQL tokenizer and expression evaluator. Still needs implementation of those expressions (outer joins, select distinct etc.)
751	832
752	833		Version 0.1.5: 12 August 2011
753	834
754	835		- Two small demo projects are included in the zip. First one demonstrates referential integrity, master/detail filtration, parameterized queries and difference between using predefined FieldDefs and FieldDefs created on the fly. The second one demostrates loading and saving to CSV table.
755	836
756	837		- Improvements: ZMSQL now enables decimal separator to be chosen (new property in TZMConnection) for ftFloat field type. It does not influence default CSV save format, but only data representation.
757	838		- Caution: Changing value of a ZMConnection.DecimalSeparator will change SysUtils.DefaultFormatSettings as well, so this will influence on the whole application!
758	839		- If you leave ZMConnection.DecimalalSeparator empty, default format settings are going to be used
759	840		- Added overloaded procedure, procedure SaveToCSV (pDecimalSeparator);overload; so that you can save a dataset with custom decimal separator. The regular SaveToCSV uses dot as decimal separator, because JanSQL database engine uses that format.
760	841
761	842		Version 0.1.4: 8 August 2011
762	843
763	844		- Successfully implements REFERENTIAL INTEGRITY!
764	845		- A simple test project is provided inside the package folder and demostrates new features from zmsql 0.1.3 and 0.1.4:
765	846		- queries with joined tables
766	847		- master/detail filtration/synchronization
767	848		- referential integrity (insert/update/delete)
768	849		- parameterized queries
769	850
770	851		Version 0.1.3: 2 August 2011
771	852
772	853		- This version brings master/detail synchronization.
773	854		- The test project now also demonstrates master/detail synchronization and parameterized queries.
774	855
775	856		Version 0.1.2: 28 July 2011
776	857
777	858		- This version brings initial support for parameterized queries (it borrows TParams collection from SQLDB).
778	859		- Currently, this support is very basic, parameters must be passed by name (ParamByName) and their values are passed as string literals to SQL string before query execution.
779	860		- There is a Test project included in the package, where you can see how parameters are used.
780	861
781	862		Version 0.1.1: 26 July 2011
782	863
783	864		- QueryExecute method fixed. SqlText TStrings property must be transformed to String prior to passing it JanSQL engine and spaces must be inserted between Sqltext lines.
784	865
785	866		Version 0.1.0: 13 July 2011
786	867
787	868		---
788	869		From the Free Pascal wiki, page "ZMSQL", as it stood on 2023-10-20 after a change by Bart, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
789	870		Category: Components
790	871		Category: Databases
791	872		Category: Lazarus
792	873		Category: Lazarus-CCR

Back to history