Compare commits

...

306 Commits

Author SHA1 Message Date
dan f5f0e43a6d Update script tool/mksqlite3c.tcl to avoid duplicating the SQLITE_API
qualifier when copying sqlite3rbu.h into the amalgamation.

FossilOrigin-Name: 61ab112f326a51d2d524a6371d8c93851ca2c6917414a802ac72d7cf5a2413fb
2017-08-04 08:23:33 +00:00
dan f48d4ef8bc Add SQLITE_API qualifiers to public API functions in header file sqlite3rbu.h.
FossilOrigin-Name: d8637badf63b90b650e9d6dc970c7e1ce46669ce8272f46f01fac9bd97c1b0fc
2017-08-03 15:50:10 +00:00
dan 0c2e5cfda5 Fix some problems in RBU test cases. Also update RBU source code to better
handle the trivial case where an RBU update is applied to a database zero
pages in size.

FossilOrigin-Name: 7676b39bc120ae23da0c6a14452eb99a58901ee45c3d43b8beae426f9e4dc0c3
2017-08-03 15:43:55 +00:00
drh 5859636fb1 Optimization to the comparison opcodes in the byte-code engine.
FossilOrigin-Name: 654935c7737f1a9e08fde9b220c543e86ff6e05910e2f08973a2f93ab2b3e028
2017-08-03 00:29:23 +00:00
drh a485ad191f In the KeyInfo object, refactor the nField and nXField elements into
nKeyField and nAllField, which are more useful and run a little faster.

FossilOrigin-Name: aea5990eab5e85f92df966aa641db2271c81052010ad2d80982475c4275a1284
2017-08-02 22:43:14 +00:00
drh 754ee285fa Avoid redundant calls to sqlite3ApiExit() in sqlite3_step().
FossilOrigin-Name: 527974d4caba8bce7c89a28ea04a573b14c558657c14d9ad3c64bf1e0884caf8
2017-08-02 19:04:37 +00:00
drh 59533aa5e0 Only attempt to invoke WAL callbacks when a transaction has committed.
FossilOrigin-Name: bcc6dacb9114df709ef1bde24264c2193d9e39fc7fab024d5ebfc6056033274c
2017-08-02 18:28:26 +00:00
drh 60172a5a93 Minor optimization on clearCell()
FossilOrigin-Name: f3c39c2986be08683c2af4df610bc12e3c6bc6bec265c94ce01b94a950723524
2017-08-02 18:27:50 +00:00
drh 85ef630fde Optimizations associated with error handling in btree cursors.
FossilOrigin-Name: 49ba54e26731ed371745d4bdd9dd1dfeb73357b6d206c85a4252ec866be971d0
2017-08-02 15:50:09 +00:00
drh 57498ae9cf Remove unused token codes.
FossilOrigin-Name: c45078c062f41f43c71965b2e5a97932ff79123eeb017ba853314987bebc2bca
2017-08-02 12:38:10 +00:00
drh 13aa88d956 Rearrange some of the added token codes for a very slight size decrease and
performance increase.

FossilOrigin-Name: cb3742f51f4b3aa0fd8dc373af771e93ddb4100787115705955f2008aef92745
2017-08-02 11:36:16 +00:00
drh 6a8700b97b Rearrange integer token values in the parser and logic in the
resolveP2Values() routine for a small size reduction and performance increase.

FossilOrigin-Name: 1cad2926ad88b83becab1326bd189d7bac8ba6d470b36ba5d29af5c9fb016014
2017-08-02 11:04:00 +00:00
drh a02860511d Show which opcodes are jumps in the comments when generating
the opcodes.h header file.

FossilOrigin-Name: eef643a369250f1acac4c01a9b3d29068a510e5bf7fa843d565df5e2523e4dd9
2017-08-02 03:21:52 +00:00
drh 59c435a015 Add the "%token" control to the lemon parser. Not currently used by SQLite.
FossilOrigin-Name: a6e4c5ae8f29bc2e7f2088426341254e9281d19db9dc9a14abc376d56dad4c4b
2017-08-02 03:21:11 +00:00
drh 0019881e08 Faster implementation of resolveP2Values().
FossilOrigin-Name: 82e46fe0d497f871e652a579f25e77de7ef05d56484418961a1296f65f19415e
2017-08-02 02:46:43 +00:00
drh 6903bf6d49 Slightly smaller and faster by allocating Parser objects on the stack.
FossilOrigin-Name: 436a89b91901851ce21bf0cb997291b48888c52788b904822083d8dfac32b84b
2017-08-01 20:59:41 +00:00
drh 86b40dfd33 Split the OP_Last opcode into OP_Last and OP_SeekEnd. Use OP_SeekEnd to
position a cursor prior to appending.  Ticket [cb91bf4290c211d].

FossilOrigin-Name: 3e02474c7bbe16891a7cfc8771cf72f64cd2c0692779037982d7d307512a4f23
2017-08-01 19:53:43 +00:00
drh b7673ede37 Take advantage of atomic-write capabilities in the F2FS filesystem when the
database is stored on such a filesystem.  This is a compile-time option
activated using SQLITE_ENABLE_BATCH_ATOMIC_WRITE.

FossilOrigin-Name: 24190b221f73472dafaead6de101b4debc2c91c1ca28d70b45a38df5bb61fb39
2017-08-01 14:16:15 +00:00
drh e9e1074d27 Allow ATTACH and DETACH inside of a transaction.
FossilOrigin-Name: 95e8f31658254dd2df3eeaae337aff0fe2125d170ae966c74f4fc70400e099b1
2017-08-01 00:20:34 +00:00
mistachkin 334d163e41 Recognize 'AMD64' as 'x64' in the TclKit batch tool for MSVC.
FossilOrigin-Name: 0c77935cf9949099d834ec51384c1d4dcdaf7b4422c859c9fce6d3cb3bde2645
2017-07-31 19:39:34 +00:00
mistachkin 5b54259873 Sync up the MSVC autoconf makefile.
FossilOrigin-Name: b3b89f4ff92ee4b76f467d4e70fb42267470aef77af645f1ce71f9b1a675aabb
2017-07-31 19:26:06 +00:00
drh ab2eca0965 Fix a windows-compatibility issue in the recently added schema6.test script.
FossilOrigin-Name: 14e6c302ec3bc0e012b3c01aabee2d32e81389e1a4d834d1c57dd60bfbc97f29
2017-07-31 17:51:49 +00:00
drh 93bbfbe539 Prevent OSSFuzz from using debugging pragmas that are disabled in default builds
and which generate lots of excess output.

FossilOrigin-Name: cdc6494c050d821908087e6fd9b1e44ba92d81f363494a80b54647f19e5675f7
2017-07-31 17:06:34 +00:00
drh c644980c4d Move the generation of output column names earlier, to right after
name resolution and before query transformations such as flattening. 
This prevents the names from getting mangled by query transformations, 
and obviates hacks in the query flattener that attempt to work around 
the name mangling. The resulting code is smaller and faster and gives
more consistent output. Fix to ticket [de3403bf5ae5f72ed].

FossilOrigin-Name: ade7ddf1998190b2b630715774963150d86bed3211b7fd600cbf3068427e1531
2017-07-31 16:42:46 +00:00
drh ea2844f153 Add the schema6.test module for demonstrating schemas that generate identical
and different content.

FossilOrigin-Name: ac1da06a829051d393ccb8bb986e78f5bd35b060687688f6b3661913b13c9a5a
2017-07-30 19:50:42 +00:00
drh df94966c8b Correctly handle an "INTEGER PRIMARY KEY UNIQUE" column in a WITHOUT ROWID
table.  This is a fix for ticket [bc115541132dad136], a problem discovered
by OSSFuzz.

FossilOrigin-Name: 5216bfb73f1a49bdd879d470de139bf46a212474eaf6f38ad2390536d66a2afd
2017-07-30 18:40:52 +00:00
drh ce00d05a7b New test cases for column name generation interacting with the query flattener.
FossilOrigin-Name: 0c38dde4543d6183a6ab0b7b3b75819f56c47704756a2426d54d3f20468d78d8
2017-07-29 17:02:22 +00:00
drh f35f2f92ed Move the generation of output column names earlier, to right after name
resolution and before query transformations such as flattening.  This prevents
the names from getting mangled by query transformations, and obviates hacks
in the query flattener that attempt to work around the name mangling.
The resulting code is smaller and faster and gives more consistent output.
This is an alternative fix to ticket [de3403bf5ae5f72ed].

FossilOrigin-Name: 09834279aeca3bda63de684a369ed64f2cbf587b5f5df1454c0a3c009a1337ad
2017-07-29 16:01:55 +00:00
mistachkin 7751deb3e2 Update Tcl version used by the TclKit batch tool for MSVC.
FossilOrigin-Name: bcec155e0d6c6b17ae09d5a366c080723d01ff40dbc1a0ad0bb669a91db1b850
2017-07-28 22:22:15 +00:00
mistachkin f6285fab68 Fix harmless compiler warning.
FossilOrigin-Name: 3286e1a07b0693049a07f0865bf93749c461ea8f6d1175ec2d1642886673d8ac
2017-07-28 22:13:26 +00:00
drh 2fc2f92ed6 Disable the writecrash.test module on Windows.
FossilOrigin-Name: 4c0520d4df7473eb4cc764774df7d99bb96cf067ac224755e09f0df47fb2a810
2017-07-28 20:49:02 +00:00
drh 9e61104c68 More precise determination of when an in-memory journal needs to be
spilled to disk.

FossilOrigin-Name: 6a505bdd9347783d3d8105cb8185aa787801bad0c855b623cfd780fb406f0e7b
2017-07-28 18:16:14 +00:00
drh 344f763f72 Add new extended error codes for the atomic write file-controls.
FossilOrigin-Name: 94a2004756ffe027b3495be91366750135c294a9c460edc9a1b4b9422dcc33bd
2017-07-28 13:18:35 +00:00
dan 2912da0283 Add new test file test/atomic.test.
FossilOrigin-Name: f9213e4864d0542be5489e03cf40c47d9127a86bbbbbabd963aa08525d5dc97b
2017-07-28 11:05:33 +00:00
drh a66632d83a Add the SQLITE_ENABLE_BATCH_ATOMIC_WRITE macro to ctime.c
FossilOrigin-Name: 67bad7fb9b2fdb29b63308f22062444084dc28191a542e08076dc2e39caf6f62
2017-07-28 01:53:32 +00:00
drh 1d42ea71c2 Enhance the like optimization so that it works with an ESCAPE clause.
FossilOrigin-Name: f5d330f495d07a704e115595bbdf5422ddb68fd8191114c5a12c9c873d983f7c
2017-07-27 20:24:29 +00:00
drh 01d837df9c Increase the version number to 3.21.0 in anticipation for changes to go
into the next release.

FossilOrigin-Name: 0645f25c79c1b2af1fd3a02b44090329d456e373d91f6c284b8fbcb929e03a5d
2017-07-27 19:59:37 +00:00
drh 2036833a66 Merge the pointer-passing interface changes from the 3.20 branch.
FossilOrigin-Name: c63903a4c5d52a490e3f26707aa85fb54d4e2e8a3ce31ca26a9c615fe7a51e97
2017-07-27 18:49:19 +00:00
drh 761decbb50 Simplified documentation for the pointer passing interface.
FossilOrigin-Name: 2dfcd9a8ecdf0ddd8e044d820639830c6171141c588cf0224255af85c64cf79c
2017-07-27 18:43:13 +00:00
dan 77b4f528fa Do not set device-capabilities flags SEQUENTIAL or SAFE_APPEND for f2fs
file-systems.

FossilOrigin-Name: 4477e60cd801dab7a8aec12c5bc5e81e774bedbfed38abbc8eb8b37336141a44
2017-07-27 18:34:00 +00:00
drh 05cccc2848 Add destructor functions for the pointer argument (NB: not the type string)
to the sqlite3_bind_pointer() and sqlite3_result_pointer() interfaces.  Use
this new capability to resolve a pointer leak in the custom geometry function
mechanism of the RTREE extension.

FossilOrigin-Name: 5a2340b81faf0a29deb5b7c9a2ba6a7697d646de6cc4e9b2e6e5e6463fa394bd
2017-07-27 17:45:08 +00:00
drh 34fcf36d62 In sqlite3_bind_pointer(), invoke the destructor if the bind index is
out of range, like sqlite3_bind_blob() does.

FossilOrigin-Name: d6684d2a744e6e04b8796c3b5ecb81c6577728b698c1ab5f4a828b2ac114b8a2
2017-07-27 16:42:36 +00:00
drh a0024e6c99 Improved implementation of the destructor on pointer-passing interfaces.
FossilOrigin-Name: 601ad6795927fff8c3cc1711a2fd90912499573e94aa5bc8f18cbd4b89778f58
2017-07-27 15:53:24 +00:00
drh 22930062d5 Add a destructor argument to sqlite3_bind_pointer()
and sqlite3_result_pointer().

FossilOrigin-Name: 3d9e841f6011480ebb8a6d860da72af7fa545983e08835ddef2cac96e5f5cd4b
2017-07-27 03:48:02 +00:00
drh 8257aa8dbe Add the new sqlite3.mDbFlags field. Factor out bits of sqlite3.flags that
do not interact with PRAGMA statements into sqlite3.mDbFlags.

FossilOrigin-Name: 3808a00f06d372cc531da039d97bd974e4a6576a30cf63bf562f83f186b313b3
2017-07-26 19:59:13 +00:00
drh cf201488a5 Allow ATTACH and DETACH to occur inside of a transaction.
FossilOrigin-Name: ac1fd6beb6c804af5faf1e06a51177a8316007ff9e718c398bd7a24d2ecc4ed3
2017-07-26 18:26:44 +00:00
drh 61ffb2cda6 Fix a comment on the UnpackedRecord.r1 and UnpackedRecord.r2 fields.
No changes to code.

FossilOrigin-Name: 622b108915c7982b29ca9920abde941fff55234b70af9ac4122e4827b35d985c
2017-07-26 10:04:51 +00:00
drh 1fc376bfd1 Release candidate 2 for 3.20.0.
FossilOrigin-Name: f39cb76b3347baba22f2c329e74036710b64620414433a952de8d44da79ba8d9
2017-07-25 15:12:01 +00:00
drh e8cf1ab9aa Fix a bug in the deterministic date/time function logic that can only appear
with STAT3 or STAT4.

FossilOrigin-Name: 1ca707a4fb8db7aa85430413164265607ce727fc8a5afc3424b3abfb59921b39
2017-07-25 01:34:05 +00:00
dan b67abfc463 Do not attempt to run test file unionvtabfault.test with SQLITE_OMIT_VIRTUAL_TABLE builds.
FossilOrigin-Name: 1a632a9a6c85b78abe0351ef91c7478b26299c4c1c269d5796afb1e172084517
2017-07-24 20:01:36 +00:00
dan fb920e7eb0 Do not attempt to run test file unionvtab.test with SQLITE_OMIT_VIRTUAL_TABLE
builds.

FossilOrigin-Name: 9a5a3d60a5c6ce23bbdab5832f706bee8acdc4b1767aeed82b1aceb294f050f7
2017-07-24 19:25:45 +00:00
drh e8e0eda95d Handle a real OOM condition when incrblob2.test is run on a low-memory machine.
FossilOrigin-Name: f483d06a9af8d6771090551d911831e1df13bb05a6b7780499594703c28ebbb2
2017-07-24 17:37:35 +00:00
drh 1d8536bc0f Additional documentation on sqlite3_bind_pointer() and sqlite3_result_pointer().
No changes to code.

FossilOrigin-Name: b1572d4e05934a0dc1b73092acba652fa50e97552eb6e9a1cedea7c71055804b
2017-07-24 15:29:16 +00:00
drh caf8cc1b4b Compiler warning fix associated with date/time functions.
FossilOrigin-Name: a98f07d942f0b8cc15da57b84e6340efae72ff19516fa04624242240af43a697
2017-07-24 14:44:15 +00:00
dan 33447e7793 Add a test for the outcome of a process crash within an xWrite VFS method
call.

FossilOrigin-Name: eb8718006cb23ba9304da5c30d19863d688495f0eaae3794c5ad870e481866f8
2017-07-22 20:12:31 +00:00
dan 4da30f8888 Add the "atomic-batch-write" permutation to permutations.test. This
permutation fails if not run on a file-system that supports
atomic-batch-writes.

FossilOrigin-Name: 9f1b83fae9c973eee80eefefe7bd3a1eb7bba8af4cd919d7a2ce911900dd9087
2017-07-22 16:58:47 +00:00
drh 2df9478f5f Keep batch-atomic-writes turned on for journal_mode=MEMORY, but turn them
off for synchronous=OFF.  Refuse to compile with both SQLITE_MMAP_READWRITE
and SQLITE_ENABLE_BATCH_ATOMIC_WRITE.  Fix up some comments in the commit
logic.

FossilOrigin-Name: 2e80e19e4faac30947ed56aa3601c45c758cafb27f84780df255fdbcdc9a6999
2017-07-22 16:32:33 +00:00
drh d76dba7eb5 Omit unused batch-atomic-write code if SQLITE_ENABLE_BATCH_ATOMIC_WRITE is
not defined.

FossilOrigin-Name: a89b62c4966cd297326e8712da40e0962d2328d7ba1f201d5abcec911eeef347
2017-07-22 16:00:34 +00:00
dan 9d70954094 Use ioctl(F2FS_IOC_GET_FEATURES) to determine whether or not atomic batch
writes are available.

FossilOrigin-Name: 532bbf1f2b1028db4e581c756533aa660e482d833caaed4eafb299ef9b584f3a
2017-07-21 21:06:24 +00:00
mistachkin 07c3a1a358 Remove stray (and incomplete) comment from a test file. No changes to code.
FossilOrigin-Name: 8de20fc72a9b55fabd2444b2d73c88c65658430d6d182da9f0e2f3432373ab51
2017-07-21 20:31:31 +00:00
mistachkin 172861be76 Fix typo in comment. No changes to code.
FossilOrigin-Name: 65ec077ba63ab84ab8da91033adcf4a57bb9269ebcdd10f9e6c97c265512a80c
2017-07-21 20:29:06 +00:00
drh d080e3d7ac Additional documentation on the new VFS interface. No changes to code.
FossilOrigin-Name: 83077ec8b5804e6c709fa4f0b50afec9eae6d5b603cc4c3e8a408ed6b2bfaf28
2017-07-21 14:49:58 +00:00
drh 35270d2604 Add the documentation text for the new VFS interfaces used by batch-atomic
writes.

FossilOrigin-Name: 5e944eea5a32cb4d27a2d5ae283b9ce6fe08c1bc584256e8e8c78583c415eb2a
2017-07-20 21:18:49 +00:00
drh 94e32acb56 Transform two #ifdef statements into #if statements.
FossilOrigin-Name: f2c6b5845028ef25dcd17e23e11b93c9f7296c26c7a21718fdae8f4b48c4e1da
2017-07-20 21:01:53 +00:00
dan d67a97705c Split SQLITE_ENABLE_ATOMIC_WRITE into two options - the original and
SQLITE_ENABLE_BATCH_ATOMIC_WRITE.

FossilOrigin-Name: 7eb9bf2c5b42c39901fd571553c1f70aa5a9dac71fdc8e318b3063b928ad58f7
2017-07-20 21:00:03 +00:00
drh 5acc3bdbdf Fix a harmless typo, but one that would show up in the documentation if not
fixed.

FossilOrigin-Name: e4b1dd36838c4a35913b393b5aad948db9eccfb89b2cd456a0227470d7ac4a26
2017-07-20 20:49:41 +00:00
dan efe1697191 Add support for F2FS atomic writes. Untested at this point.
FossilOrigin-Name: 416973ede3bde8567d1f2699728f72352979e054ef988d1c1e1cfe4290f6f8b8
2017-07-20 19:49:14 +00:00
drh 4562d0db0d Enhance the built-in date/time functions so that they can be used in
CHECK constraints, in the WHERE clause or partial indexes, and index
expressions, provided that none of the non-deterministic keywords
("now", "localtime", "utc") are used as arguments.

FossilOrigin-Name: a90c062d46c63a1e6f83064b1c5afb26a16e93b6ee8620ca46d169fdb325c488
2017-07-20 15:08:43 +00:00
drh 2fbeb7e8f0 New test cases for date/time functions in indexes on expressions, in the
WHERE clause of partial indexes, and in CHECK constraints.

FossilOrigin-Name: b7f70c7fcabc10b8b3e62fe5ac68476cec23acaee037c7250ff70bca3f3ab541
2017-07-20 14:36:26 +00:00
drh 6e97f8ec84 Combine the Parse.ckBase and Parse.iSelfTab fields into just Parse.iSelfTab.
This fixes a problem with date/time functions in check-constraints.  Add
some test cases for date/time functions in index expressions and check
constraints.

FossilOrigin-Name: 22eda0985ecd1f456c073e6ad735a8417f3ff1fb6aaad1640e1cec01e50c51d8
2017-07-20 13:17:08 +00:00
drh 3e34eabcdf Allow indexes to be created on date/time functions as long as the 'now'
date and the 'localtime' and 'utc' modifiers are not used.

FossilOrigin-Name: 0a5e1c04d9d07bb7fd6546a9ddac1bf42b19ea19c2b79570aea6cd4226887a27
2017-07-19 19:48:40 +00:00
mistachkin 885f410472 Remove some 'breakpoint' commands in test files.
FossilOrigin-Name: d14fc621e918915bbf8e04597eb238ea78dff3d9c5eb4402cb88692d00dbdfee
2017-07-19 18:01:42 +00:00
dan d4603a2cab Add further tests to unionvtab.test.
FossilOrigin-Name: c93284cd65b6471bffc38696e14dc24a2170698faf566cf91b727ba272f88c25
2017-07-19 11:52:25 +00:00
drh 466004d5a4 Add VFS interfaces needed to make use of batch atomic write capabilities
in the underlying filesystem.

FossilOrigin-Name: 929bc46b8be0111a7b6e3d6fe129f0cad869c6a551bd47569c122742597b9f1c
2017-07-19 11:20:32 +00:00
dan 7f3d20acec Fix a crash in unionvtab caused by a misconfiguration. Add other test cases
for the same.

FossilOrigin-Name: 255d6b99de2bb210c09ebee9f9481ba3d1130fda47e6e01b4cc8411d00679d09
2017-07-18 21:19:17 +00:00
drh 5a75dd86c1 Fix shell.c.in so that it aligns with shell.c.
FossilOrigin-Name: 505fdc8ff5150276d3c6ab6135a542b791e9e79e2f76323e592b73b3fdc9bc2a
2017-07-18 20:59:40 +00:00
dan ff0a4edb72 Add test cases and fix minor error-handling issues in unionvtab.c.
FossilOrigin-Name: deadaad2a0801b3c30d2a076d8eb006b62d8557cff820e0939741c078477c83f
2017-07-18 20:49:15 +00:00
mistachkin aecd438737 Fix duplicate test name. No changes to code.
FossilOrigin-Name: 47b80ecc679e656ef865e73809d6a9aa485eceeacab86d10d405881c5d9872bd
2017-07-18 20:30:55 +00:00
drh 3935ce8e28 Fix another harmless compiler warning. Get the MSVC makefile working with unionvtab.
FossilOrigin-Name: d49639c208ac366f6c675ac5671accc2a597558b62a51520194276c61f32d406
2017-07-18 20:28:34 +00:00
drh 65e0f11451 Suppress harmless compiler warnings in union-vtab.
FossilOrigin-Name: 4d147a1e28b93e267889fcb01b538d6a2a58d6b1655512c883fa5b53ddcc60a4
2017-07-18 20:22:12 +00:00
dan a18532353c Remove an unused variable from unionvtab.c.
FossilOrigin-Name: a447fdf182c9090ca5b6c9c13147ae4b78d22d67f416ee7a0436ca408284c8fe
2017-07-18 20:17:52 +00:00
dan 859e4a73b7 Improve the readability of the unionvtab code.
FossilOrigin-Name: 5bcf0f86ea7fbbc31a13b2d5b1cf93a92e46fb65fe8e779b3d7e4a98d60d7061
2017-07-18 20:03:49 +00:00
dan 090f68a390 Have unionvtab support constraints on the column that corresponds to the
INTEGER PRIMARY KEY field of the underlying source tables in the same way as
rowid.

FossilOrigin-Name: 4a6c416fa025a34116ea30923a673cbb108b251b2676734ec8f603600e38e50e
2017-07-18 19:51:11 +00:00
dan 8342aa0d81 Add test cases to unionvtab.test.
FossilOrigin-Name: 6c9128e1a53f8cf26de9ef1bc07051f2c94287531edacfcfb69d3cd7590240b3
2017-07-18 18:50:37 +00:00
drh 53e86ab36f Add the union-vtab extension - still experimental and under active
development.

FossilOrigin-Name: 948f95046b7eaa8c68617b36625a7500dd0e69e52425ac6d748f2a311eb2474a
2017-07-18 18:19:35 +00:00
dan 46133d98a6 Do not use the flattening optimization for a sub-query on the RHS of a LEFT
JOIN if that subquery reads data from a virtual table. Because it prevents the
planner from creating an automatic index on the results of the sub-query, the
flattening optimization sometimes slows things down in this case.

FossilOrigin-Name: 9dbae1df75219e2accd8993015ce0ffc21966d7e69d04178b1a2cc46207fe260
2017-07-18 17:34:41 +00:00
dan bbccd52143 Avoid creating an automatic index on the RHS of a LEFT JOIN to optimize an IS
term. Fix for [ce68383b].

FossilOrigin-Name: d2f0b2e859a8a413ee4e4bd7040e450ccd604069e4ea8dbc9ff924718c2b14d7
2017-07-18 17:13:41 +00:00
drh 80f134c8aa Change the default command-line shell history depth to 2000 lines.
FossilOrigin-Name: 0b69aa7e37495f15c3fcc36969b650262b5aa5500fb40800de9a5c56a03f309d
2017-07-18 14:41:44 +00:00
dan 16bab5a7d9 Add test cases to test/unionvtab.test.
FossilOrigin-Name: f2c4a584e83ffcc1cedd39460eb06d6f231a1a87f269bb3e75055232a866067e
2017-07-17 21:03:13 +00:00
dan bcd303ac7d Enhance error detection and fix other issues in unionvtab code.
FossilOrigin-Name: 9c3f1b9a82e500e015deb0cc669fbb32e7f0cdc69f926ceff383ab946f8d8d18
2017-07-17 20:25:21 +00:00
drh b98ca04529 Merge all changes from branch-3.20. Improvements to the fts5() extension
interface.  Work around a gcc/valgrind bug in the sqlite3_value_pointer()
interface.

FossilOrigin-Name: e0aca7d2c60d9859750a6e98d3e3b87f79779a45920348fc1bda7f1cb93ef996
2017-07-17 18:45:23 +00:00
drh 06d4940a48 Interchange to branches within an "if" statement in sqlite3_value_pointer()
in order to work around a bug in gcc.

FossilOrigin-Name: 8a606e4abab4efa03f2e5ffc33d7c5faa3c663f339da87b4ce9f3feed5dc7194
2017-07-17 17:46:29 +00:00
drh 72495b44e0 Improved the interface to the fts5() extension mechanism for enhanced
security.

FossilOrigin-Name: bc78235f547977f1a821342ca8f3e03103a0eb351f8b3115ac10b43dd9c7044d
2017-07-17 15:38:57 +00:00
drh bd3028d7e3 Merge the pointer-type enhancement from the 3.20 branch.
FossilOrigin-Name: 9e8e1c4aa14bcda165b392d1d8af2ce394a56a8e7b67e4c73c742d8da75e73e2
2017-07-17 13:37:07 +00:00
drh aabebc27b7 Comment changes clarifying details of the pointer-type parameter. No
changes to code.

FossilOrigin-Name: e4579e50a1ece4f65dfdae39d5c1670f0e3f7d4824e7d242f07ec9859d15155f
2017-07-17 12:41:29 +00:00
drh 0357713225 Add the pointer-type parameter to sqlite3_bind_pointer(),
sqlite3_result_pointer(), and sqlite3_value_pointer().  The pointer type is
a static string that must match (according to strcmp()) or else the pointer
is passed as a NULL.  This is a security measure to prevent crossing pointers
between different extensions.

FossilOrigin-Name: e1196567fcbc313657836262ed9f71668b1c47f26e4bc57c7880ff40079d66cc
2017-07-17 12:27:43 +00:00
drh 9a541c0361 Improve the sqlite3_result_pointer() interface so that it cannot be faked
using sqlite3_result_null() and sqlite3_result_subtype().

FossilOrigin-Name: c13264d5ef0470fb24e09f7bc12f19be3b77eab06d41f55607b38dddb532a132
2017-07-17 11:39:46 +00:00
drh ae3ec3f920 Add an experimental "pointer type" parameter to sqlite3_bind_pointer(),
sqlite3_result_pointer(), and sqlite3_value_pointer().  The pointer type is
a string that must compare equal using strcmp() or else the pointer comes
through as a NULL.

FossilOrigin-Name: 211cce04e97d2e325a6ea3e99738fc71115d673dc13daeffb03ac3140deb11de
2017-07-17 00:40:19 +00:00
dan d8ecefa5ab Add the "unionvtab" virtual table extension in ext/misc/unionvtab.c.
FossilOrigin-Name: 62a86aa6c0519cf1fa232169122d3d6ae8d2f66b20530fb934a82a15712bd2f0
2017-07-15 20:48:30 +00:00
drh fe8eadc94d Merge the fix for ticket [a4e06e75a9ab61a12] from trunk.
FossilOrigin-Name: b64d64c84484162d1822430036ba0483365a39ef4cf82cd6a7b9436d9e9f50c8
2017-07-15 20:44:33 +00:00
drh 3963e584b4 Fix a register allocation problem in PRAGMA integrity_check that caused
the same register to be used for two different purposes on the first
ATTACHed database if the schema for the ATTACHed database was noticable
more complex than the schema for the first database.
Fix for ticket [a4e06e75a9ab61a1].

FossilOrigin-Name: 253945d480b052bfe311888022b5eb0be91c8c80cda05036e58207d57520262c
2017-07-15 20:33:19 +00:00
drh e7c6f97b1d Fix a missing \n at the end of a comment causing a line to be too long.
No code changes.

FossilOrigin-Name: 687bd478710eb827e041533eea67115464f5a0de767bb6cfdbe36a0d3c597fa1
2017-07-15 20:25:22 +00:00
drh a4e54e868e Enhance the showstat4 utility program to show the full precision of
floating point values in sqlite_stat4 tables.

FossilOrigin-Name: 5ec37c62f65b2870dcd7a906912da787367f3912a96b6f3536355fad65903575
2017-07-15 17:57:31 +00:00
drh a4d770cf60 Minor change to one of the command-line shell test scripts to make that
script compatible with Tcl 8.5.

FossilOrigin-Name: 47cf83a0682b7b3219cf255457f5fbe05f3c1f46be42f6bbab33b78a57a252f6
2017-07-15 13:49:56 +00:00
drh 13c6fc5c6c First release candidate for version 3.20.0.
FossilOrigin-Name: 035a86ec3e4abd2173bfd0d8666ec86bd85af414cb791e68e6334447ecd35b84
2017-07-15 13:35:17 +00:00
dan cb0d3ba862 Fix another minor problem in test file like.test.
FossilOrigin-Name: 0953e74612358f48a9c9e3772876b514bc79784f277497121c59302a3106110c
2017-07-15 08:02:10 +00:00
dan a50b309187 Fix test problems causing the "prepare" permutation test to fail.
FossilOrigin-Name: b61cc5a0f9f2c2d2175ad30fc3fa4cb2086dbb948d5a5cc538ac43b871bb5221
2017-07-15 06:35:15 +00:00
dan 04ed43d64d Fix test problems with stmtvtab1.test under some permutations.
FossilOrigin-Name: ad6699d476b93131887e30475517764e281647f94df4a8248e2b88f1f14da91d
2017-07-14 20:53:21 +00:00
drh 858205d8bd Fix a typo in a comment used to generate documentation. No code changes.
FossilOrigin-Name: 65f9f29c58f61646d700eee6610ce85b572306f0ce2f19bebfd37632523019e5
2017-07-14 19:52:47 +00:00
drh 749e4a9fd1 Identify requirements text in the SQLITE_DBCONFIG_ENABLE_QPSG documentation.
Add some implementation marks for SQLITE_DBCONFIG_MAINDBNAME requirements.
No code changes.

FossilOrigin-Name: ab165dcf35ae7385c9366853ce5648294bf5dc9aa9ffe1af84243e6fac3472fc
2017-07-14 19:47:32 +00:00
drh 3cef364966 Add requirements marks for some of the new features in the 3.20 release.
FossilOrigin-Name: 264238671379306b14d62a6ddaefd2a20acd34ca77276b6ce872253160fe0146
2017-07-14 19:22:08 +00:00
dan 380c7ce460 Tweak Makefile.in so that testfixture can be built with the
--disable-amalgamation configure switch.

FossilOrigin-Name: 394c6f4f4376bc3d7796ea4157ba2ae230b0ca950774eff127ae6ef8a7b08602
2017-07-14 19:12:26 +00:00
dan 0e6b83088f Modify mkopcodeh.tcl so that it can handle "same as" opcodes with values
larger than the total number of opcodes.

FossilOrigin-Name: 1eb56fe0305f0841b14865b7560add3da529b211328f5fa171b9628418a6ed49
2017-07-14 17:50:11 +00:00
drh c9fb27bfa8 In the LSM1 virtual table, dequote the filename before opening the file.
FossilOrigin-Name: 6ed4ef03ff6f22ae83a14facc48ce594911d7d7b37446436b68af3a822578fae
2017-07-14 15:57:56 +00:00
mistachkin 59541d70a8 Changes to the LSM1 Tcl tests to make things work on Win32.
FossilOrigin-Name: 7dc5e70ef1faa0b51a04abdfe1ee2f9ea5c2d0f99ea8ef6260b9de02500cf8b2
2017-07-14 15:45:27 +00:00
drh a199ffca58 Include a hint in the header comment of the LSM1 makefile about how to
set the LSMOPTS variable.

FossilOrigin-Name: b5e3b264814cde9572130b70fc0d21ccebc2d7f5f0e7db50b6395cb63723383e
2017-07-14 15:42:11 +00:00
drh aa15168983 Update the Makefile for LSM1 so that the LSMOPTS can be set prior to
including the Makefile, in order to add platform arguments such as -fPIC.

FossilOrigin-Name: fe319bcd7f85e9997babdb024ab350514524f5901903600fa9780bdcd1805098
2017-07-14 15:32:11 +00:00
drh 3eddffd8bb Fix a typo in the header comment to the remember extension. No code changes.
FossilOrigin-Name: 604b9664f4dd6e8d188b5c57407edbbe0639345f8d30bf2d19016f8324934840
2017-07-14 15:18:51 +00:00
drh e83b847b75 Change the name of the STMT virtual table to SQLITE_STMT. Also remove the
first column of that virtual table, which was a pointer leak.

FossilOrigin-Name: 1bc4e93407b7894b0271fbde3720930dcaadda6070e871d9719c4e8dc65b915f
2017-07-14 15:14:21 +00:00
drh 923260c865 Minor updates to requirements marks and documention. No changes to code.
FossilOrigin-Name: 8f6dd5e2907d6df230fcbceadd226496bcc35a33c117da58215f7d333c1cc7b8
2017-07-14 13:24:31 +00:00
dan 4b8035e69b Add very simple tcl tests for the lsm1 extension.
FossilOrigin-Name: 5e0a97930b08fff1c3a29f5c8b2962b856e3302209228c0e71b9f1a1bd2a4be3
2017-07-14 11:40:48 +00:00
drh 17ca22616b Minor tweaks to documentation. No code changes.
FossilOrigin-Name: d8cd0434f3451e27aefe38a1a9efdc4dfded2ea33baf25d82814c89264f3afff
2017-07-14 04:16:03 +00:00
drh 968d8715fd Fix harmless compiler warnings in the readline tab-completion logic of the
command-line shell.

FossilOrigin-Name: 271ca4acfcff448cf863045595d2c2616decd13b6015d7db481c91e2ad5bb92a
2017-07-14 00:28:28 +00:00
drh 33b46eeb35 Improved documentation for the new sqlite3_bind_pointer() interface and its
cousins.

FossilOrigin-Name: 889968bdbf1c258238cb68d82f059e16366c4a40c2d541dd4a1811ab72e693cb
2017-07-13 22:39:15 +00:00
drh 4ba5f33f39 Improvements to the documentation for SQLITE_PREPARE_PERSISTENT.
No code changes.

FossilOrigin-Name: 265778142485882f39edfb5756175b2675c1993f0d6395dabbcbbb3767c6ec77
2017-07-13 22:03:34 +00:00
drh 06aecf0954 Fix documentation typo. No changes to code.
FossilOrigin-Name: 9319f7b71f68c9dc64c22c60b90650955b72f6bd9852d5ea86fa96a5c6fede37
2017-07-13 20:11:52 +00:00
drh c9407508b1 Update header comments on the carray() and remember() extensions to bring
out the fact that the pointer arguments must be bound using
sqlite3_bind_pointer().

FossilOrigin-Name: 55f5396576d186f310cb0fa66fbdb8ea68c18a3d0fe5de4b395ea03c7aa04c9e
2017-07-13 19:11:13 +00:00
drh 96b10030e9 Add new interfaces sqlite3_bind_pointer(), sqlite3_result_pointer(), and
sqlite3_value_pointer() used to safely move pointer values through SQL without
exposing underlying memory address information.

FossilOrigin-Name: 72de49f204277191f62601cce70d5013ec30b564a01063f1e841019c78ae6c77
2017-07-13 18:09:36 +00:00
drh 4c997c6e75 Fix an incorrect type signature for the loadable extension pointer
for sqlite3_result_pointer().

FossilOrigin-Name: 0bd7875bd9948836a14061275eb8ddac627f562a49f59f400ec98c00e2be82c5
2017-07-13 17:56:52 +00:00
drh 5587d86ddd Add the three new pointer interfaces to the loadable extension mechanism.
Update sqlite3_value_subtype() documentation to remove the statement about
it not being used internally.

FossilOrigin-Name: e5a518038fcb23376d2b17d4d70648320bc5540c5bd8b164201044ebe1ce45c5
2017-07-13 17:54:12 +00:00
drh d43748aa98 Update the FTS3 extension to use sqlite3_result_pointer() and
sqlite3_value_pointer() for passing FTS3 cursor objects from the table
into functions such as snippet().

FossilOrigin-Name: 0fa2e170e5e078d155c98b212ade36bd8424502ae07f2d82ebf77a76f57586ba
2017-07-13 17:48:14 +00:00
drh 3fb406083a Merge the latest changes from trunk.
FossilOrigin-Name: a54be6e041a9185787a22b86603dcb0654e5e4af71225b556d1b6279f8520ad8
2017-07-13 17:34:46 +00:00
drh 0c2433003d Smaller and faster implementation for vdbeFreeOpArray() and freeP4().
FossilOrigin-Name: 0c80593520d30958231be41fc443209eb39e0b3ee0e66308c3ef3a0f4cb8ea66
2017-07-12 20:43:23 +00:00
drh 7ccf95dbab Fix harmless compiler warnings about incomplete structure initializers.
FossilOrigin-Name: 604c11d1a39f09e47b6fcee0f8b1c1054f9dbbc7b2c1cf93312aeaa4b7095018
2017-07-12 18:05:54 +00:00
drh 980a89e630 Remove unnecessary EP_Leaf settings on the Expr object.
FossilOrigin-Name: f951c8b71b2369da62a329c792af5e3d3087bbe020f38c68ca1d0a594b904c08
2017-07-12 17:26:44 +00:00
drh 971ecd7eaa The EP_Resolved flag on the Expr object is not required for correctness nor
performance, so remove it.

FossilOrigin-Name: 54f55d3b7973e326541a81bfb2e752a2f6618e4fec9a3631b95f28e12e9c6e34
2017-07-12 17:08:24 +00:00
drh ec360a8d01 Clarification and simplification and result column naming logic.
FossilOrigin-Name: 68824a439b76a4cca05609a02de7abdc42bd1d26afbfcd047b90001c610d3c56
2017-07-12 14:10:19 +00:00
dan 47ebd4cadd Fix a problem in an lsmtest test case caused by writing data in "text" mode
instead of "binary".

FossilOrigin-Name: 3e56a79ad8754e6da3181883154fa1c8b227a8d16c9b2a3eba925371595ae1f9
2017-07-12 14:03:13 +00:00
drh f0f44b79c9 Compile cleanly with SQLITE_OMIT_UTF16.
FossilOrigin-Name: 783100b801703577e35ec12fe7623e1797e49699f3b8deb0694ef061a142b844
2017-07-12 12:19:33 +00:00
dan 1cd523cf0f In lsm, attempt to unmap the database file before truncating it when
disconnecting. A mapped file may not be truncated on win32.

FossilOrigin-Name: 39069941e98605bc8c7c736819781761760ee2b83363471ceb6f19e5eb06b13a
2017-07-11 20:36:35 +00:00
dan 416b8694fa Simplify the way in which the database file is truncated when the last
connection disconnects. Also ignore the error code from the xTruncate call -
as truncating a database file is always optional.

FossilOrigin-Name: b0a49d90fc91acca1306cf6145adc83acd368686768b7eb4a3b27515b3237396
2017-07-11 19:55:38 +00:00
drh 8999798e60 Fix harmless compiler warnings in the core.
FossilOrigin-Name: 55e93f256018757e5e1cb3b10ef48abf5914e7687419eae58b00998a37061261
2017-07-11 18:11:33 +00:00
mistachkin ba334bb20d Make win32GetTimeOfDay() in the lsm1 test code more portable.
FossilOrigin-Name: 2fe3a84330063378ca9fc5bfc8efe486c52d50b5c40be4f402a4f2318be69436
2017-07-11 17:54:27 +00:00
drh db3e0456d2 Enabled the new sqlite3_prepare_v3() and sqlite3_prepare16_v3() interfaces
for loadable extensions.

FossilOrigin-Name: b9debd626a68c4bc0e5fdeb8d15a991cfe6f62f9586eda76c07a1c18e498e3c2
2017-07-11 17:28:27 +00:00
mistachkin b7bfc3b12d Fix a whitespace alignment issue in lsm1.
FossilOrigin-Name: a8e651e0e52b016c3939df3ee23b4981f1a8841c7ddd2981c1ef391feb559a5e
2017-07-11 17:06:42 +00:00
mistachkin 36c68234d6 Fix more harmless compiler warnings in lsm1, seen with MSVC 2015.
FossilOrigin-Name: 0f1307f1f5638c1c4f1ce2b89cdef7ce8b76dc2a38685cd1ca152cde9e8727da
2017-07-11 16:46:41 +00:00
mistachkin 1be5051923 Fix harmless compiler warnings seen with MSVC for lsm1.
FossilOrigin-Name: cf6da4a52f7f9047e653ef2972e4c0910b29d7182d789a9e30225dc1849e8779
2017-07-11 16:36:10 +00:00
drh 56eb09bc23 Add support for tab-completion (using the ext/misc/completion.c virtual table)
to the command-line shell.

FossilOrigin-Name: 95cd1d9f8baa6be305c9a8bfa26fef2a403f2d5b3b5c9c55382ec04f0bc98d40
2017-07-11 13:59:07 +00:00
drh 2ce15c3f4c Change the src/shell.c file so that it is generated from a new script at
tool/mkshellc.tcl and the template file src/shell.c.in, and automatically
includes the extensions it needs out of ext/misc.

FossilOrigin-Name: 17e0bb12d82b510b86b6886b9fd0faf39b60b1374027344f89d7b89a32b842b9
2017-07-11 13:34:40 +00:00
drh e2b01012bc Fix a backup2 test case so that it works on FreeBSD.
FossilOrigin-Name: 724819b456ca7a5ca6d68415b3b3554741c3ddbb5c416cb6b6b5fc54177f426e
2017-07-11 02:53:38 +00:00
drh f3c0009d8b Add the "phase" output column on the COMPLETION table-valued function, for
debugging.  Improved comments on the implementation.

FossilOrigin-Name: 0e2135552757cc6566ac959475d3b87254b6d462425ee6c457c743001f3370e2
2017-07-11 02:05:21 +00:00
drh dc4dde6bd9 The COMPLETION virtual table now looks at the names of databases, tables,
and columns in addition to SQL keywords.

FossilOrigin-Name: 1cc97711fa86a3938f0930200476d1b0991e4b893a8be3a19015423a3de56bef
2017-07-11 01:38:45 +00:00
drh 3265b5649e Incomplete implementation of the COMPLETION table-valued function. So far it
only works for SQL keywords.

FossilOrigin-Name: caefbc723b5f67afc5ef10b92b20400cbb76cb03e7e75e18d2726cc552083e09
2017-07-11 00:09:44 +00:00
mistachkin b2950c48e1 Fix harmless compiler warnings in lsmtest.
FossilOrigin-Name: bd8a1fb9b33418717c786a7275f636cd4d5facd66de9a416f948b61c6490c743
2017-07-10 21:32:11 +00:00
drh 4a9e14077e Fix errors in comments in the STMT virtual table. No code changes.
FossilOrigin-Name: 9a8f045d62f5c6593a5a2842e817b49fa9d00c74e329a15a326f74e583c1f767
2017-07-10 20:39:59 +00:00
mistachkin 240e7ef4bb Minor cleanup and refactoring of the Win32 VFS for lsm1.
FossilOrigin-Name: bf7eda67c8124c3cd5d9150f2f2694cd3f991b20e0a527398885976d0d787242
2017-07-10 20:33:50 +00:00
drh a868639656 Another spelling error in the README.md file.
FossilOrigin-Name: 0512937425df6f274153f1d822fc4fe358601c2944745c0039c40e645ebedd82
2017-07-10 19:54:48 +00:00
drh e1869a91d6 Spelling error in README.md
FossilOrigin-Name: 12bc47c50252f1307b224d171069b93192d0c905aadf480829bba390c059aee4
2017-07-10 19:08:59 +00:00
drh 764fb30330 Yet another typo in README.md
FossilOrigin-Name: 75c9327b551d072effbb37efebf5fbe1a45965f89fe285df364dda06ca866cd7
2017-07-10 19:07:11 +00:00
drh 67d5bf9118 Fix another README.md typo.
FossilOrigin-Name: 20b1f0eff175aa8be9a7a631ede0a434f6c340fcdb931633e1f228d1fb35abde
2017-07-10 19:05:58 +00:00
drh 14d5ff4202 Fix an obsolete statement about Lemon in the README.md file.
FossilOrigin-Name: 4f6ce7a38baef24e00818926b9b8dc852334e3d4011f1d3a577c8c7e5f7ed93e
2017-07-10 19:03:04 +00:00
mistachkin 91ea8cf4ac Cleanup header usage in lsmtest for files that require _O_BINARY.
FossilOrigin-Name: f3a6a64ec90e6cf24aadf62aef4f92104be5ba6790f7fca040eff7abc31f1061
2017-07-10 18:57:03 +00:00
drh 7ff64dc2bc Updates to the repository README.md file.
FossilOrigin-Name: 7bfd3ab7996bf869eb2705495f3f2cd8bd6d1f4d029a1f26041e95049a9bfd3b
2017-07-10 18:52:29 +00:00
dan ff7733db52 In LSM, avoid calling the VFS xTestLock method to test for a lock that
conflicts with one held by the same process. The results of such a call are
considered undefined (since they are different under win32 and posix).

FossilOrigin-Name: a82a9bea624caf6b24d8e3f3c596817968b258f06e54288022f6df8226281057
2017-07-10 18:33:41 +00:00
drh dbc26722cd Add the "--newlines" option to the ".dump" command in the shell to disable
the newline escaping mechanism.

FossilOrigin-Name: bde431b1e332feaeb516dc46d180e2b2f42820c471feed7eda89452ada898dc9
2017-07-10 18:04:41 +00:00
drh 90e39ec349 When multiple constraints need to be evaluated for a row, do any constraints
that involve correlated subqueries last.  Hence, the priority is index-covered
constraints first, correlated subquery constraints last, and all others in
the middle.  This is a
follow-on and improvement to the push-down optimization of check-in [d7bb79ed].

FossilOrigin-Name: c4cb90487f34937605732c3959891075e2aabfb0bd05e55c44565d65867093ea
2017-07-10 17:00:31 +00:00
drh 66a0bf31cc Additional debugging Noop-comment in the constraint generator when
wheretrace is enabled.

FossilOrigin-Name: 0ca7474f05e9f27f53f8c71f5a3ff99963ffef9be9c147869e096246d552d6f1
2017-07-10 16:38:14 +00:00
drh e24b92bce7 Small performance optimization in sqlite3WhereExprUsage().
FossilOrigin-Name: 38edc6770e54e456500e77389d42fdf39e9a7ed258a4e1fed3c6dd8fdf4dfcb7
2017-07-10 15:26:09 +00:00
dan d3930b1266 Fix another problem on this branch.
FossilOrigin-Name: a4fc98113aeb10860834f68a2fdcef690ea15d8303d23b6dd416994a4b7edab6
2017-07-10 15:17:30 +00:00
dan 8674ec5a7f Fix a problem causing non-covered WHERE terms to be evaluated before covered
WHERE terms.

FossilOrigin-Name: 7d3cb39f60951dcec1ff87da2c4ec998f993de5edf49ee5e5f480c6fe4e5a052
2017-07-10 14:39:42 +00:00
dan ebc63013b7 When testing non-indexed WHERE constraints, test those that involve
correlated sub-queries last of all. This increases the chances of not having
to run the sub-query at all.

FossilOrigin-Name: 1f9c1f359e4693954ba7e2bc7b172ef34eb046e4ca2796df8336975b9d6aa92b
2017-07-10 14:33:00 +00:00
drh 9f6e14c1ef For sqlite3TreeView() debugging output, show the Expr.flags field on
scalar subqueries.

FossilOrigin-Name: dc857a96b00f13ffdf77bc222bc5acbbe14a36ca51e5368b568b3177d1be737a
2017-07-10 13:24:58 +00:00
drh ff4fa772f5 Update error message text for standard error codes to better describe the
latest usage of those error codes.  Modify sqlite3_open_v2() so that it does
return a valid sqlite3 object in the event of SQLITE_MISUSE due to bad
open flags, so that sqlite3_errmsg() does not report "out of memory" in that
case.

FossilOrigin-Name: f27b6370407842e2c175ea4aa9ce018723c57eaac0cccc1f8399bc20f33324be
2017-07-10 12:07:53 +00:00
drh e75be1aedb Remove the error message text from disused error codes such as
SQLITE_EMPTY and SQLITE_FORMAT.

FossilOrigin-Name: 871752f2925ee14bdd3e994c00832d00860c03f6f28e63504aa6d35978b7f37c
2017-07-10 11:17:51 +00:00
drh 155507b344 Always make "column%d" column-names 1-based, never 0-based.
FossilOrigin-Name: 70096c505d702a9646da24613da387cee19afcf395d0294b3797c5ab50bb3ee2
2017-07-09 18:55:29 +00:00
drh d7ca600ede Make sure the columns of a VALUES() clause are named "column%d" even if
the VALUES() clause is a subquery in the FROM clause of an outer query.

FossilOrigin-Name: acf3b9cc9c3932431979995a1dceacc06c659ab400fad95ce3728ff8895a022b
2017-07-09 00:30:58 +00:00
drh 2aa31333c2 Add the --icc, --gcc7, and --orm options to the speed-check.sh test script.
FossilOrigin-Name: 70dae08a9a6e35416f7268b9a95f3c8562b74697918bd1e9d5b5cf4719b9d075
2017-07-08 22:30:30 +00:00
drh 12ca0fc259 Basic test cases for PRAGMA secure_delete=FAST.
FossilOrigin-Name: 0c246017b45c5290f3a7932dfce649f1a6d8f9afc00c6c3edf2ef06c17dbca1d
2017-07-07 22:47:32 +00:00
mistachkin 50963c9da8 Fix comment in the Win32 VFS for lsm1.
FossilOrigin-Name: 12a421bcacf72128426eeafed8663accd8f2ac7edb46f620b60b8239065e657e
2017-07-07 21:20:26 +00:00
mistachkin 85bd1cd52b For lsmtest, use a more portable means of setting open() files to binary.
FossilOrigin-Name: aea6e0ffd33f41482f1b53b9f21b77add2865abda4eec1d9ee197177f74f43d0
2017-07-07 21:15:24 +00:00
mistachkin 1d91e9f26a Adjust copy_file() lsmtest function so it works properly for locked database files on Win32.
FossilOrigin-Name: 54a3855583deac93c955ed77fe82be6a6b7aadd3fdb7e6b895888e2a4ff530bd
2017-07-07 20:35:14 +00:00
drh 08f1efeb16 Add the "PRAGMA secure_delete=FAST" option, which overwrites most deleted
content without increasing the amount of I/O.  Deleted content might persist
on the free page list, however.  And extra CPU cycles are used for zeroing,
of course.

FossilOrigin-Name: 38978ce65b280bb7cba3fc08ba91485fb1b84cd9fbba2e950ecf41c021ff452a
2017-07-07 20:06:28 +00:00
drh a690ff360b Change the error message text for SQLITE_ERROR to omit the part about
"missing database" as that meaning is now obsolete (since approx SQLite 2.0).

FossilOrigin-Name: 732f90d6327c5c6368fc8b4cc207bd644ef08e3ae6d2e7295258ab099deaba63
2017-07-07 19:43:23 +00:00
mistachkin b11c650c01 Fix typos in Win32 VFS for lsm1.
FossilOrigin-Name: 0961ec873b78ad2da0ea9cdf2934bc8f08276375a153fe5d9fa8d4280328deef
2017-07-07 19:22:35 +00:00
mistachkin 73518c5876 Fix the memcpy calls in the lsmWin32OsShmMap function for lsm1.
FossilOrigin-Name: aa4890b9f9e9698c61d6ca0e24c26280f5e0a87a8c02865933ad483a1fd44d84
2017-07-07 19:12:55 +00:00
mistachkin a2d85cbbfa Enhance the MSVC makefile 'clean' target to handle lsm1.
FossilOrigin-Name: 2d6faebc319aefeab796c5f2ead4c3c3e2a9dd25c979a16bdb555a109135b13c
2017-07-07 19:02:51 +00:00
mistachkin 9a7a77ad36 Add support for LSM_DEBUG to the MSVC makefile for lsm1.
FossilOrigin-Name: 277a7fedafbe5b43d44086f3cb73e952873913bdc4b51041f45b6571b386d7d9
2017-07-07 18:31:51 +00:00
drh a7a0bfab91 In the command-line shell, when running ".schema" give a sensible error when
the database file is locked.

FossilOrigin-Name: cc329eb8d65171f3f4fcb39b0e55ef85c97a77f3510cf864bbc1537f993d0074
2017-07-07 18:06:49 +00:00
mistachkin 9b8c5f6819 Fix the usleep() macro in the Win32 test code for lsm1.
FossilOrigin-Name: 63599fa524a7c72ffa5362041f2ec394d9af9c43025d8b6d5a34e98eb423d5ff
2017-07-07 17:57:21 +00:00
drh d5eae667f4 Add new PRAGMAs: "function_list", "module_list", and "pragma_list". All are
enclosed within #ifdef SQLITE_INTROSPECTION_PRAGMAS.  The compile-time option
is not on ctime.c yet, since these are still experimental and one can always
test "PRAGMA pragma_list" and see whether or not it returns an empty set.

FossilOrigin-Name: e0b6ae92adfae46f64fc2e2719e22e5467c34d49c1aeaec5cc5faf04258de0f7
2017-07-07 17:43:30 +00:00
drh 8ae11aac93 Add the "Pragma_list" pragma. Put all three pragmas created on this branch
inside of #ifdef SQLITE_INTROSPECTION_PRAGMAS.

FossilOrigin-Name: 2f3c3781ef3d66ecafef083d7144287ff23eea5a6d93b014dfeb2a8ac71f757e
2017-07-07 17:33:07 +00:00
mistachkin e60092b90c Improve clarity in the Win32 VFS for lsm1.
FossilOrigin-Name: 9c7a9e805d95d3d4a3f7e2d608280b7ca0dda01114e32cd366b1deb14e6e6839
2017-07-07 16:46:08 +00:00
mistachkin baebf3cc4b Add support for LSM_DEBUG_MEM to the MSVC makefile for lsm1.
FossilOrigin-Name: 3340de83df8c4fb19f729e6ff0838a9a03a1e701cdb40cb830e76f294198024a
2017-07-07 16:29:37 +00:00
dan 45158fa5d9 Remove a block from the Win32 VFS for lsm1 that is now superfluous.
FossilOrigin-Name: 5f726f2830dcf91f5e5c010b10761757f746d39b9dd2b8c9770452ce65bb1652
2017-07-07 16:27:43 +00:00
dan 3bc909b0af In lsmtest, use an empty string instead of ":memory:" when requesting a
temporary database from SQLite. This prevents other test code from trying to
unlink() ":memory:", which fails on win32.

FossilOrigin-Name: 281ad505d7a112c5524ea9fb195dfc46f819a58f79f42b37b12fbfe46a089ff2
2017-07-07 16:09:24 +00:00
mistachkin 5bd9e61f05 Remove a block from the Win32 VFS for lsm1 that is now superfluous.
FossilOrigin-Name: db4a41408eff450ee429b936847313c2c92ba1f5b1fcbadaacaff3c08bfdd589
2017-07-07 16:07:53 +00:00
mistachkin d429ec222c Memory reallocation fix for the Win32 VFS for lsm1.
FossilOrigin-Name: 5a3140e4dedace6de4366a3c52e41b818b6d19f356fdab738c6605afc1b674fa
2017-07-07 16:06:30 +00:00
drh 40cf27cb63 Enhance the sqlite3VdbeMultiLoad() interface to automatically generate the
OP_ResultRow opcode on PRAGMA implementations, for a small reduction in the
library footprint.

FossilOrigin-Name: c46f0f076c674891e20240bad56693d891aedc43004bcf980a5d199515f23413
2017-07-07 16:00:53 +00:00
drh ab53bb635c Add new pragmas: "function_list" and "module_list"
FossilOrigin-Name: e5f01d7fde05fdb547f35816ff15c31a92c170b31877f4c640b7bc2be3f580b3
2017-07-07 15:43:22 +00:00
drh 4676462f92 Merge recent enhancements from trunk.
FossilOrigin-Name: 73d0fc027ddcc24e55cdc8c54443a96083cc9a29e57c0abe97e8586ff8a7f4c5
2017-07-07 14:26:43 +00:00
drh d10866798d Exploit the fact that Expr.pRight and Expr.x are never used at the same time
for a small performance gain.

FossilOrigin-Name: aacbb9a461fdb34c7f9c8ce348e44c3e96c93334f210d438d92bfac1794dc686
2017-07-07 13:59:34 +00:00
drh c2d14a9a33 More efficient and compact implementation of walkExpr().
FossilOrigin-Name: 115d4b83392d346634866dd959bef30fca50db2e526df17eaeb3d94da7fc895e
2017-07-07 12:58:30 +00:00
drh b98a2e351e More aggressive use of EP_Leaf on expression nodes, to help prune searches.
FossilOrigin-Name: c1a1d68c8219c8072e60af5c46a30849ae9a04fa1a6b2a8b22b82fec069d691d
2017-07-07 12:43:57 +00:00
drh 3da70a6112 Very slightly smaller and faster sqlite3WalkSelect().
FossilOrigin-Name: 9bc65635b29a4991c7821ef0939975d007f9ac23716717699353ef3246e27791
2017-07-07 11:49:48 +00:00
drh 0db5bfe5de Small adjustment to main.mk that facilitates giving non-standard compile-time
options to the shell.

FossilOrigin-Name: 7c7d53a9bbc27fde2dcc028cb7765c76cad0a784e53095b652c90d371968c53d
2017-07-06 22:43:41 +00:00
drh a0c3927510 Change the (machine-generated) keywordhash.h file to increase the scope of the
tables used for keyword matching, so that the tables are accessible to
functions other then keywordCode().

FossilOrigin-Name: c5ed5ebdf660501fde7cc8aefaaaeae2a68e5899a64ac93f26684842a235281d
2017-07-06 16:33:14 +00:00
drh 9d8e401c2d More compact implementation of the typeof() SQL function.
FossilOrigin-Name: efb4aab0caa4145732a5438cc2a193bc12c455b4007220564d240e75900ea8ad
2017-07-06 13:51:50 +00:00
drh ebaaa67db2 Avoid unnecessary upper-to-lower case conversion for function names when
registering the built-in functions.

FossilOrigin-Name: 06269257647db51fbc9f8cda88abac5db28b6f917a509768af7686dfa2b94511
2017-07-06 13:23:26 +00:00
drh 3b02e0f615 Small size reduction in findCollSeqEntry().
FossilOrigin-Name: 55ecd30304517acd23f89b3450fd6a5e18ac2f79aa24a4ff693f8d71a49f7837
2017-07-06 03:06:20 +00:00
drh 666e86625c Avoid unnecessary calls to sqlite3GetCollSeq() for a small performance gain.
FossilOrigin-Name: 503ba172e4c32e288abf006fc5cb53fd2b0313c4ee4c526c2d9c4c21b7178f2d
2017-07-06 02:49:26 +00:00
drh 07a3b11a50 Slightly more compact implementation of the byte-code generator for
the COMMIT and ROLLBACK commands.

FossilOrigin-Name: 4da663d9863004d8cef58259a043fdcf4f466f80d3714cf58321a52485be8766
2017-07-06 01:28:02 +00:00
drh 169a689f7b Small performance increase in sqlite3SrcListAppend().
FossilOrigin-Name: 7b2623f1994384484cf31ae9e443ee20f19b278bf2e91898dbc01828822ddf91
2017-07-06 01:02:09 +00:00
drh a35d851892 Make the hash table implementation a little smaller and faster.
FossilOrigin-Name: f762f1effe1ce893d6b67815ad8b585bae2c1621d9199dac9c85d39dad16e774
2017-07-05 23:33:33 +00:00
dan adea0d1c39 Have fts3 virtual table cursors free internal resources when they reach EOF,
instead of waiting until the xClose method is called.

FossilOrigin-Name: b6b14ab6c8f9758a64e5fd29203f8fa610b5c4ef917de9be51ae55e072fad4ed
2017-07-05 18:48:07 +00:00
dan 7181395a4d Fix a problem in lsmtest causing one test to fail for multi-threaded LSM
connections.

FossilOrigin-Name: 2bce64c8864b616f9ab0063f64d0ceb2f83e53e110970c6b3b11003cba5c8804
2017-07-05 14:29:04 +00:00
drh 269ba80469 Add the count-of-view optimization when compiled using
SQLITE_COUNTOFVIEW_OPTIMIZATION.

FossilOrigin-Name: d1ba200234f40b84327c7fc28c2584ed069da80e97578df71114d1a9ba9c559c
2017-07-04 19:34:36 +00:00
dan 431a53fde2 Fix further OOM handling cases in LSM.
FossilOrigin-Name: ca757c8665e27de884086b2aab2bd1db481e2d12f2afe136ec151bf5a0e65b91
2017-07-04 19:23:32 +00:00
dan 038af0bdc6 Fix a couple of problems in handling OOM conditions within LSM.
FossilOrigin-Name: 989a5c1745a7145c14c6d9b713176ecba6b99296de8bdd09f666eeef10da9c2e
2017-07-04 17:25:45 +00:00
drh 92395c59ff Fix a problem in the lempar.c Lemon template for YYSTACKDEPTH<=0 introduced
by check-in [36e54cd8b1fb37]

FossilOrigin-Name: 268a40f44cea6c3f561b7f54c90d631877be44292911424bac24f72c5ee87d60
2017-07-04 12:50:00 +00:00
drh 518ee8f06f Fix compiler warnings in LSM1, especially in the test logic.
FossilOrigin-Name: 9bd3be92b8add7bd0d7bc4b0742b2dd227ebb8d67a839b78f26f2b06b47490f2
2017-07-03 21:09:28 +00:00
dan 45408a108f Fix a bug in lsm queries on levels undergoing incremental an merge that
contain range-delete markers.

FossilOrigin-Name: b2c2487928becbea5a932895d153709c98a057a3c71c2600e165478562e9f7c5
2017-07-03 20:19:28 +00:00
drh cde336e0dc Attempt to improve documentation on sqlite3_column_ and sqlite3_value_
interfaces.

FossilOrigin-Name: 9111ac69bf307997e590bc9459222661fc79f549b3c493168a654a5046e6e4ad
2017-07-03 17:37:04 +00:00
dan 05dda7ba8e Add more tests for LSM log file recovery. Fix a problem in recovering log
files that contain range deletes.

FossilOrigin-Name: e34eafd4c5b2bbf2735e136ad69b67bb4288ad4d01a0128d8e107ac46209a182
2017-07-03 09:00:18 +00:00
dan 24f6904e99 Fix a memory management problem in lsm log recovery code.
FossilOrigin-Name: dd55af30b4440bba1b97c2155b9f499d791cd7d8bae8341972c41439fdc41edc
2017-07-01 20:59:06 +00:00
drh c7b1ee5f6e Enhance the RTree module to detect node truncation early and report an error.
FossilOrigin-Name: 66de6f4a9504ec2670b7273de8fb6955c80e03f7f73414ea6b80fd8a99f75976
2017-07-01 15:21:17 +00:00
drh 3561dd4afe Update the carray() and remember() extension functions so that they user
the new sqlite3_value_pointer() interface.

FossilOrigin-Name: a99fa94db7185b8eaf3c9b184cb1479f8b3d5781f71f1717a4b3f2dd1d184fe4
2017-06-30 23:46:16 +00:00
drh 3a96a5d919 Add APIs for binding pointers that can be used by app-defined functions.
FossilOrigin-Name: d9f4a831ba957ead3890b36d0e33e30cfa4c79b7de6400e623b9746a0a5a02d0
2017-06-30 23:09:03 +00:00
drh fd76b71cac Improved documentation for sqlite3_value_type().
FossilOrigin-Name: 0db20efe201736b3ebb177948f6a440ce28e62454536a8496fae64a3b55cb702
2017-06-30 20:11:45 +00:00
mistachkin 04222ce52e Add some assert() statements in the Win32 interface for lsm1.
FossilOrigin-Name: d076d58ff108d286f7ac1f81e1ce945d6f4a4f5f97e3b8d5cee6f8d9a6c48d8f
2017-06-30 19:22:33 +00:00
mistachkin 88f769f967 Fix some minor typos in lsm1.
FossilOrigin-Name: 0ef777d7474383c0211b19baa4a161cf7fce6570f384dfef368cdab45c1a0f01
2017-06-30 18:12:09 +00:00
dan a5b55e370f Avoid constantly freeing and reallocing small internal buffers associated with
LSM cursors. Instead, allow them to persist for the lifetime of the cursor if
they are LSM_SEGMENTPTR_FREE_THRESHOLD (default 1024) bytes or smaller.

FossilOrigin-Name: bacfe8cb3e4d3be736c6789b2ce55ef5603e5c7a289b05b37cae2203cd7f2290
2017-06-30 11:44:11 +00:00
drh a501f7dab4 In the command-line shell, add the -quote option to start up in quote mode.
Enhance the ".mode" command so that it reports the current output mode if
given no arguments.

FossilOrigin-Name: 5e3f9ea5c4fad35fe02a12d59114e94ee00e0a09c1840c88908a4c282e2f4625
2017-06-29 21:33:25 +00:00
drh c31b79d2a4 Remove the ".explain" command from the ".help" output of the command-line
shell, though keep the implementation around for backwards compatibility.

FossilOrigin-Name: 7782c04e9b2c0e95b5ac2a38876c1a233becfd892140bc6844790d62aeaff4f7
2017-06-29 21:11:27 +00:00
drh e755072c3b Some simple tests for the STMT virtual table.
FossilOrigin-Name: a26e17ee56d3c019fc4772fcf95480b4515eea6cfc74c3d494be0d1941e49666
2017-06-29 20:31:01 +00:00
dan d681d3472d Avoid reading or writing the 32 locking bytes at the end of the first meta-page of an LSM database.
FossilOrigin-Name: 3ed6877f89106131fd030c183fac036fed7231cd92dc4715e87a34a045500bdf
2017-06-29 20:23:32 +00:00
dan 28508ddb42 Avoid reading or writing the 32 locking bytes at the end of the first
meta-page of an LSM database.

FossilOrigin-Name: 2b5df3e8a80ae5c0415081dd9b29acaad1464be2e7971399e52c1c98408322d9
2017-06-29 20:13:44 +00:00
mistachkin 97e8b3ea32 Fix issues in the POSIX and Win32 interfaces for lsm1.
FossilOrigin-Name: 38ec41416679e8280d77c8a4913aa6a321784b1237a3fe409b8e256c5f4513de
2017-06-29 19:08:52 +00:00
drh 1d1982c324 Edit comments in sqlite.h.in used for generating documentation, to improve
the description of the new sqlite3_prepare_v3() interfaces, and other
miscellaneous cleanup.  No changes to executable code.

FossilOrigin-Name: 284707a7b3514a55cce24292e45632b7033d6edcff5b27deac5118b27c7b2954
2017-06-29 17:27:04 +00:00
mistachkin de680efbc3 More updates to the Win32 interface for lsm1.
FossilOrigin-Name: cae647696769c9fcdc3beafdfdf74d8384217f4b22820e4545093bea7be58f7c
2017-06-29 16:51:52 +00:00
mistachkin c2586f77ad Correct typo in the Win32 interface for lsm1.
FossilOrigin-Name: 1b4facb1ad0085aa52e63d4d432179467ddc2a69b668d49d86e65ead66a73f57
2017-06-29 15:57:42 +00:00
drh 01e6d540a7 Add interfaces sqlite3_prepare_v3() and sqlite3_prepare16_v3() with the
extra prepFlags argument. Add the SQLITE_PREPARE_PERSISTENT option as 
one bit in that argument.  Use the new option in FTS3, FTS5, and RTREE.

FossilOrigin-Name: 03977248e6fdaa9b35c15e5dd9bb89552f2f0a913cc31609b5af1e2347b67d38
2017-06-29 15:24:57 +00:00
mistachkin 14e61df283 Further corrections to the Win32 interface for lsm1.
FossilOrigin-Name: 4df6e2476ce93b9ca7a6959c8c2d6ef2c30395984b007d74166031dcf09d54b4
2017-06-29 15:13:48 +00:00
drh c6603af755 Rename the "stmts" virtual table to just "stmt" without the final "s".
FossilOrigin-Name: adfdb80105c46ac42b71132c80a91dbd5b1c9ff241fb4fbb5d04641a88898d90
2017-06-29 14:33:51 +00:00
mistachkin 3881d23c72 A couple fixes for the Win32 interface for lsm1.
FossilOrigin-Name: ebbd98e941d8a8ea97b434c29b70095515af0adab1977aa4d37fe74a7401f846
2017-06-29 14:17:48 +00:00
drh c79983312f Add the stmts virtual table to testfixture builds. Add new compile-time
options SQLITE_ENABLE_QPSG and SQLITE_ENABLE_STMTSVTAB to ctime.c

FossilOrigin-Name: 60c628293a1d8a1505e1a36dbd01b1f62bcfd7915e144044c92385423cbf8e07
2017-06-29 13:41:59 +00:00
mistachkin 2ca62cb102 Compilation fix for lsm1 using MSVC.
FossilOrigin-Name: b7794cc5d5abc13c6301c8d5c1b330405432c047f154083430fd15823221e552
2017-06-29 13:35:44 +00:00
drh e4b45f536e Add the LSM1 extension.
FossilOrigin-Name: 824e83274c04d24fd854bc7376c958ea6b05862efc562a3dfed0fc888fd96cc2
2017-06-29 13:19:55 +00:00
drh 366050e89a Add the "stmts" virtual table to the amalgamation, activated when compiled
using -DSQLITE_ENABLE_STMTSVTAB.  Add the SQLITE_STMTSTATUS_REPREPARE and
SQLITE_STMTSTATUS_RUN statistics outputs from sqlite3_stmt_status() and add
corresponding columns to the stmts virtual table.  Change the numeric value
of SQLITE_STMTSTATUS_MEMUSED to get it out of the way of counter values.

FossilOrigin-Name: 88976ae31c2cbc8b75f162140d1356132f69e5b30786e39ad8ca5a1774b03621
2017-06-29 13:13:33 +00:00
drh 3039e3698d The query planner examines the values of bound parameters to help determine
if a partial index is usable.  Reprepares may happen if the bindings change.
This behavior is disabled by the QPSG setting.

FossilOrigin-Name: c322bfa27e88fc9e2c969c1e4ce12a7d541bd2f30e133d267eb2d15fd3477fde
2017-06-29 12:59:40 +00:00
mistachkin d90dbb8c1c Implement xUnlink, xShmMap, and xShmUnmap for lsm1 on Win32.
FossilOrigin-Name: 680cc064c9e809ddc643074b5e65677f484d904b3d52826f6def480ddaa8f0ab
2017-06-29 12:54:58 +00:00
drh 00d11d400b Add the SQLITE_STMTSTATUS_REPREPARE and SQLITE_STMTSTATUS_RUN options to
sqlite3_stmt_status().  Use this for two new columns in the stmts virtual
table.

FossilOrigin-Name: b0b0c8f8d548ef78584ab714ab120b01c1b83fc0d8ae2fd7626b970bab9fca58
2017-06-29 12:49:18 +00:00
drh 5aa307e2a6 Fix the exprCompareVariable() routine so that it works for non-UTF8 text.
FossilOrigin-Name: 25acd9658be792d686b3ebfaa8c3692f9830e043538ed0afecf97110a07758a4
2017-06-29 01:23:12 +00:00
mistachkin cffbd543d3 Implement xRemap for lsm1 on Win32. Also, zero file handle when closing it.
FossilOrigin-Name: 93c9aa7d9aea46b331c53ff579ef704e88ce90f96600b69479a87a4bb4ca2a91
2017-06-29 00:20:42 +00:00
drh c080422642 Alternative implementation of exprCompareVariable(). Need to run tests on
both this branch and the original to see which one to go with.

FossilOrigin-Name: b959c6297c151150ea2dca24aa1f68f3bd76dd6620eb6c03f8dfa59fdd5c13b2
2017-06-28 21:47:16 +00:00
mistachkin 44ab70db7e Implement xLock and xTestLock for lsm1 on Win32.
FossilOrigin-Name: 9112117dad8085c385aa614cd982b307f5822761607ba358f34df7848c549134
2017-06-28 21:36:40 +00:00
drh 3e380a4485 Make the query planners use of partial indexes based on bound variables
responsive to the SQLITE_DBCONFIG_ENABLE_QPSG setting.

FossilOrigin-Name: a934dd14ac55177ac541423f4a077484bb3b461b60c9c2e88d067cca922fa2bc
2017-06-28 18:25:03 +00:00
drh 37f906087b Merge the in the latest enhancements from trunk.
FossilOrigin-Name: 8f63c5863231eba7f853f9587b58a81102c31708402fa9962a6e91aa622fad13
2017-06-28 18:07:29 +00:00
drh d0bbe4e9c2 Incorporate recent trunk changes.
FossilOrigin-Name: 62b8269ba2ff71e2daaa86688698896badd6f6e34ab42fbf92dda7fcda73a230
2017-06-28 15:56:58 +00:00
drh f00f530b7d Build the "stmts" virtual table into the amalgamation. It is active only
when compiled using SQLITE_ENABLE_STMTSVTAB.  That option is supplied to the
command-line shell.

FossilOrigin-Name: 0ff057d86e42e518fda22bfbf5f1977ab6bd0a74a9211ff259ee7e8a7ce98b58
2017-06-28 15:47:29 +00:00
drh 2fb960b545 Fix harmless compiler warnings in the CSV extension.
FossilOrigin-Name: f02a54599de7620438aecd3753199fc52ce8919d7503bb8b2f5592b0e51dbf8c
2017-06-28 15:17:31 +00:00
drh 8b471e7e79 Faster parser stack overflow detection.
FossilOrigin-Name: 36e54cd8b1fb374fd41e3e09b34b86e34327bf07c9e4bfec58382163c5c5d279
2017-06-28 15:01:35 +00:00
drh 6559e2cec7 Minor tweak to the SQL grammar to make the parser tables a few bytes smaller.
FossilOrigin-Name: cc4810b23e683e8c359f7c1a562338ec8501e43cac3475b2be002568fca5e6a4
2017-06-28 14:26:37 +00:00
drh 6be95366c7 In the lemon-generated parser, store the number of symbols on the RHS of each
rule as a negative number and add it to the stack pointer, rather than storing
the value as a positive and subtracting it.  This makes the parser faster.

FossilOrigin-Name: b362f0d8ed34839bf3b29d10ed0853ab94245fba135ccd28e619caa6ee6992d5
2017-06-28 13:47:56 +00:00
drh bd8fcc130a In the lemon-generated parser, automatically promote SHIFTREDUCE actions on
nonterminal systems to pure REDUCE actions, for a performance enhancement.

FossilOrigin-Name: c46d94a8cde816ca383e771721ebd4900de77950cba700e35a26f70fd5b794a4
2017-06-28 11:56:18 +00:00
drh 6e11b16282 Simplify error handling logic in sqlite3_exec() to save about 40 bytes.
FossilOrigin-Name: 6480916c7266437cf8a70e5db2ca5c753ad71c361b68e41cbf8572f77c271920
2017-06-28 01:21:16 +00:00
drh 59a386ea03 Minor code simplification in the ALTER TABLE logic.
FossilOrigin-Name: bfc4e7f30e4654b9603457fb6a4136828e346dcfe4e313fdf56ed62d131b7156
2017-06-28 01:12:53 +00:00
drh 3144df1264 Avoid an unnecessary call to sqlite3XPrintf() in the code generator, for
a performance improvement.

FossilOrigin-Name: 29d6ceb3838394d902e248d1eab627625a857dccb5ed0bb66161a13fafc500c8
2017-06-28 00:55:50 +00:00
drh a5e906f307 Add SQLITE_DBCONFIG_ENABLE_QPSG that forces the query planner stability
guarantee.  This is the fix for ticket [b9f010107724c]

FossilOrigin-Name: b82efd2a24914ace39acf99df75175042471fd73a8d31d66a40b15f63b342e10
2017-06-27 23:36:44 +00:00
mistachkin ec99c0f632 Improve a local variable name.
FossilOrigin-Name: d0f6973d93c36451bf64f47de9a88abec613a624603033bf6717f5071139b6d2
2017-06-27 22:33:06 +00:00
mistachkin b5fdc26c21 Initial work on porting lsmtest to Win32.
FossilOrigin-Name: 7e669d9bfab237ff7ece821cf95cfd3bb753b1882b9a86044b7d4579808aecf4
2017-06-27 22:27:54 +00:00
mistachkin 59b1dd3830 Implement xFullpath for Win32.
FossilOrigin-Name: dbe9c8aa8d70051fafec569054eeda6c02efe9d036ab6beada00da3ed42e52d9
2017-06-27 18:15:38 +00:00
dan 210ec4c855 Fix a virtual table problem that can occur when the vtab is on the RHS of a
LEFT JOIN and there is a MATCH constraint in the ON clause, or when the vtab
is in a sub-query that is the RHS of a LEFT JOIN and there is a MATCH
constraint in the WHERE clause of the sub-query.

FossilOrigin-Name: 87b381663398f029f52cb5598aadd069b03034b6f833ce80ba762b406075a44e
2017-06-27 16:39:01 +00:00
mistachkin 8e1ddde079 Minor corrections to the previous check-in.
FossilOrigin-Name: e1cf8a78a0bbd7b05cefab22a5c9676098887ee9811d37330ce89b3367856f92
2017-06-27 06:28:00 +00:00
mistachkin 02679b0466 Work in progress porting lsm1 to Win32.
FossilOrigin-Name: 2017636e93cf810fe4d1247c18de9f316fca037035a026f77c4588563d7bf0cc
2017-06-27 05:59:47 +00:00
drh af38cdbc08 Add the -withoutnulls option to the "db eval" method in the TCL interface.
FossilOrigin-Name: 18f0616e15684ca327fb10a1d133331af1d3b75f609498982290f6ad69fcaced
2017-06-26 21:08:32 +00:00
drh d5fbde80a2 The ".import" command of the shell, and the csv virtual table extension both
ignore a single UTF-8 BOM at the beginning of their input.

FossilOrigin-Name: 7c15d762d99c2e3e534cd35dfe25ddcd317637eb1f2655fd24c2dd5f9d5a7613
2017-06-26 18:42:23 +00:00
drh 7df7475d0d Make sure sqlite3VdbeSetVarmask() is never invoked when QPSG is enabled.
FossilOrigin-Name: ebcfa73e1c8ebb4fc371a6dcf77f97b6e06e405a299c66182aa4b20423d519ec
2017-06-26 14:46:05 +00:00
drh 169dd928c5 Add the SQLITE_DBCONFIG_ENABLE_QPSG option to activate the query planner
stability guarantee.  This involves refactoring the sqlite3.flags bitvector
to carve out a free bit to use.

FossilOrigin-Name: 7076e8283ebae1b45a5d85d9538b49b6da399d38c3c6935de100f948f814f6a9
2017-06-26 13:57:49 +00:00
dan 4261a4065f Remove an invalid assert() from lsm test code.
FossilOrigin-Name: ca8a7e995c3da10ba05e3b7d4818c633fe5ba6d6f9351b67017a2603b50b903d
2017-06-26 11:46:01 +00:00
dan 3a31c67aae Fix another problem with multi-threaded mode in the LSM test code.
FossilOrigin-Name: 461ced77d93e84f09bfb4291999cd0245506fa9a8369049fd68968bbcf18d41b
2017-06-26 08:24:35 +00:00
dan e6f98bcf09 Update a test case to reflect the fact that the lsm blocksize is configured in
KiB. And defaults to 1024, not 2048.

FossilOrigin-Name: d7015475f121db1f56060716cd8adb73e9b52016890ec9018b620ef9d7d4fbff
2017-06-26 07:31:28 +00:00
dan 07cae6ae74 Fix some compiler warnings in lsm_file.c.
FossilOrigin-Name: 23f16382ed47a90bf5e6c1684d54d28484dca46fea20ca0f131bd477cf222bfb
2017-06-26 06:53:24 +00:00
drh a22dd3860a Disable shell tests for the .schema command if virtual tables are not available.
FossilOrigin-Name: c8186874b3fec737445ad5c4ba3eaecd922af664b387d89dc31eea60476a0294
2017-06-24 19:21:48 +00:00
dan 5aa550cf3b Consider the values bound to SQL variables when determining whether or not a
partial index may be used.

FossilOrigin-Name: 7b59c353b805c64689b4ae9df347705acbb5f116346ad77af8ce087da7893747
2017-06-24 18:10:29 +00:00
drh 7f2d1cd2b0 Make sure the config.h header is included by ctime.c, if that header exists.
FossilOrigin-Name: c2ea62937ec8fabec72d3c7cd38d8e2cabbb5ce48638f8ce7ebefd6cd2716fd3
2017-06-24 16:35:00 +00:00
drh 54ac445d53 Query planner tuning: When deciding between two plans with the same cost,
bias the selection toward the one that does not use the sorter.

FossilOrigin-Name: f0ec36d479ac4efaa0efd0594d032dd7b8ccdf84a4dc3644cd688762186fbcca
2017-06-24 16:03:18 +00:00
drh 45e7d7dd1c Make sure enough memory is allocated for pathological quoting cases when
computing a quoted table name in the command-line shell.

FossilOrigin-Name: 0583b84ab444db3ae3c93db619b67bf84b0305ab989200e77214e02ff2dc923a
2017-06-24 13:31:40 +00:00
dan 65c2a71042 When generating individual loops for each ORed term of an OR scan, move any
constant WHERE expressions outside of the loop, as is done for top-level
loops.

FossilOrigin-Name: 712267c9c08fdcef5d59cedc672657b55fd6a77472711711599f0bd653e6d880
2017-06-23 15:47:05 +00:00
drh a5907a86b8 Experimental "PRAGMA secure_delete=FAST" pragma. The intent is to overwrite
deleted content with zeros without increasing the amount of disk I/O.

FossilOrigin-Name: f1682f0faf1a93ded066464b1ddd5f987e21ee0f6bb5e828ed31c3ad903cf2c3
2017-06-19 11:44:22 +00:00
drh b74013300c Merge the latest changes from trunk.
FossilOrigin-Name: 60105c2253d0b617037e975b0d0b729bcb59b950aa2c33d8891394ad45aabb69
2017-06-15 15:06:26 +00:00
drh e9acf4b48e Merge enhancements and fixes from trunk.
FossilOrigin-Name: 3fd050c343256c0748256ef183b46df04d9e0da0f81b841dbd336034402b36ab
2017-06-09 15:14:41 +00:00
dan 41ac439dbe Fix another lsmtest build problem. Add the "-trans BOOLEAN" option to "lsmtest
speed2".

FossilOrigin-Name: 61853bc171e7c3af1db6a33ac8b1ad21e1c08e8d6b317fe061fdcd89c9a42e88
2017-06-07 19:46:18 +00:00
drh 0282c03abc Merge in trunk enhancements.
FossilOrigin-Name: f8bbb608cbf6c245628e3d362e9181fb3dc402b1d8241bcb687caf395f63c916
2017-06-07 16:25:25 +00:00
dan 3b328522f4 Fix a threading problem in lsm test code.
FossilOrigin-Name: 501238b9fbb4eece084b4bfce84a5f37a986f34db8081df517e60ef81f357454
2017-06-06 16:14:49 +00:00
drh 59ce97a013 Merge all recent trunk enhancements.
FossilOrigin-Name: 1d23294d88b1a80fe1f5403ea4fd75e61bb4932d5b714ea450d1b4b84f0896ab
2017-06-02 23:44:38 +00:00
dan 38d6985509 Add test code for LSM to the ext/lsm1/lsm-test directory.
FossilOrigin-Name: bb7436e84a315baf05f00e6cab396017e3f287ea404d32e0cc4f389fa1194dec
2017-06-01 16:13:57 +00:00
drh 2c2f392dca Add interfaces sqlite3_prepare_v3() and sqlite3_prepare16_v3() with the
extra prepFlags argument.  Add the SQLITE_PREPARE_PERSISTENT option as one
bit in that argument.

FossilOrigin-Name: 4a25c5883380fe5990d8180adb58c3bdc7a3d081bc4c69cd4de3cd57074fb251
2017-06-01 00:54:35 +00:00
drh 16b7dcc717 LSM1: Fix the integer key encoding so that negative keys are in numeric order.
FossilOrigin-Name: f92dc4187f6046fcb3ab63449efd7f3738594adc
2016-02-24 13:35:22 +00:00
drh 6627fd6126 Merge trunk enhancements.
FossilOrigin-Name: fac4f4ecee21a460e527a0e2ffa24094b74e17dd
2016-02-23 01:41:35 +00:00
drh 078b99f806 Add support for (variable length) integer keys in LSM1.
FossilOrigin-Name: 32f3daec0a8084b258b2513c8025bc4d95a5d757
2016-02-23 01:37:24 +00:00
drh 7dc1918bbf Merge up to trunk.
FossilOrigin-Name: f9e5fb88a5a14b26e9ea6997f449d0913f27a494
2016-02-22 13:01:22 +00:00
drh 99a1ab7ebc Merge the latest enhancements from trunk.
FossilOrigin-Name: 8aede091c4740511d11ea14da253fe39bbfe75a6
2015-11-19 19:31:33 +00:00
drh c83ef77bb9 Work toward more flexible typing for keys and values.
FossilOrigin-Name: 5c79f53131a7ab3c83f49e35a5021a6cdb2518fc
2015-11-19 19:27:07 +00:00
drh a87cc18948 Basic functionality is now working.
FossilOrigin-Name: aa129c51ecf5c917cfac30be330886f8a10f49e1
2015-11-17 02:23:09 +00:00
drh eb8e7adb16 The virtual table compiles but does not work and is missing many features.
This is an incremental check-in.

FossilOrigin-Name: a32849d6bf66462d1f511714a00f24519d7b7079
2015-11-17 00:15:21 +00:00
drh a0b7ffb184 Import the LSM code from SQLite4 for use in an experimental virtual table.
NB: This is a speculative experiment and could easily result in a dead-end
branch.

FossilOrigin-Name: 3d930501a2acb7f20932cfeb4e3fe308b4569cd6
2015-11-16 16:00:22 +00:00
312 changed files with 47277 additions and 2297 deletions
+11 -3
View File
@@ -181,7 +181,7 @@ LIBOBJS0 = alter.lo analyze.lo attach.lo auth.lo \
notify.lo opcodes.lo os.lo os_unix.lo os_win.lo \
pager.lo parse.lo pcache.lo pcache1.lo pragma.lo prepare.lo printf.lo \
random.lo resolve.lo rowset.lo rtree.lo \
sqlite3session.lo select.lo sqlite3rbu.lo status.lo \
sqlite3session.lo select.lo sqlite3rbu.lo status.lo stmt.lo \
table.lo threads.lo tokenize.lo treeview.lo trigger.lo \
update.lo util.lo vacuum.lo \
vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbemem.lo vdbesort.lo \
@@ -350,7 +350,8 @@ SRC += \
$(TOP)/ext/rbu/sqlite3rbu.h \
$(TOP)/ext/rbu/sqlite3rbu.c
SRC += \
$(TOP)/ext/misc/json1.c
$(TOP)/ext/misc/json1.c \
$(TOP)/ext/misc/stmt.c
# Generated source code files
#
@@ -434,6 +435,7 @@ TESTSRC += \
$(TOP)/ext/misc/series.c \
$(TOP)/ext/misc/spellfix.c \
$(TOP)/ext/misc/totype.c \
$(TOP)/ext/misc/unionvtab.c \
$(TOP)/ext/misc/wholenumber.c
# Source code to the library files needed by the test fixture
@@ -483,7 +485,8 @@ TESTSRC2 = \
$(TOP)/ext/fts3/fts3_tokenizer.c \
$(TOP)/ext/fts3/fts3_write.c \
$(TOP)/ext/async/sqlite3async.c \
$(TOP)/ext/session/sqlite3session.c
$(TOP)/ext/session/sqlite3session.c \
$(TOP)/ext/misc/stmt.c
# Header files used by all library source files.
#
@@ -564,6 +567,7 @@ SHELL_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS4
# SHELL_OPT += -DSQLITE_ENABLE_FTS5
SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS
SHELL_OPT += -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
SHELL_OPT += -DSQLITE_ENABLE_STMTVTAB
FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1
FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ
FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000
@@ -1034,6 +1038,9 @@ sqlite3session.lo: $(TOP)/ext/session/sqlite3session.c $(HDR) $(EXTHDR)
json1.lo: $(TOP)/ext/misc/json1.c
$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/misc/json1.c
stmt.lo: $(TOP)/ext/misc/stmt.c
$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/misc/stmt.c
# FTS5 things
#
FTS5_SRC = \
@@ -1083,6 +1090,7 @@ TESTFIXTURE_FLAGS += -DSQLITE_SERVER=1 -DSQLITE_PRIVATE="" -DSQLITE_CORE
TESTFIXTURE_FLAGS += -DBUILD_sqlite
TESTFIXTURE_FLAGS += -DSQLITE_SERIES_CONSTRAINT_VERIFY=1
TESTFIXTURE_FLAGS += -DSQLITE_DEFAULT_PAGE_SIZE=1024
TESTFIXTURE_FLAGS += -DSQLITE_ENABLE_STMTVTAB
TESTFIXTURE_SRC0 = $(TESTSRC2) libsqlite3.la
TESTFIXTURE_SRC1 = sqlite3.c
+9 -2
View File
@@ -1294,7 +1294,8 @@ SRC07 = \
$(TOP)\ext\rtree\rtree.c \
$(TOP)\ext\session\sqlite3session.c \
$(TOP)\ext\rbu\sqlite3rbu.c \
$(TOP)\ext\misc\json1.c
$(TOP)\ext\misc\json1.c \
$(TOP)\ext\misc\stmt.c
# Extension header files, part 1.
#
@@ -1417,6 +1418,7 @@ TESTEXT = \
$(TOP)\ext\misc\series.c \
$(TOP)\ext\misc\spellfix.c \
$(TOP)\ext\misc\totype.c \
$(TOP)\ext\misc\unionvtab.c \
$(TOP)\ext\misc\wholenumber.c
# Source code to the library files needed by the test fixture
@@ -1505,7 +1507,7 @@ FUZZDATA = \
# when the shell is not being dynamically linked.
#
!IF $(DYNAMIC_SHELL)==0 && $(FOR_WIN10)==0
SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_EXPLAIN_COMMENTS
SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_STMTVTAB
!ENDIF
# <<mark>>
@@ -2089,6 +2091,7 @@ TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_SERVER=1 -DSQLITE_PRIVATE=""
TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_CORE $(NO_WARN)
TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_SERIES_CONSTRAINT_VERIFY=1
TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_DEFAULT_PAGE_SIZE=1024
TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_ENABLE_STMTVTAB
TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) $(TEST_CCONV_OPTS)
TESTFIXTURE_SRC0 = $(TESTEXT) $(TESTSRC2)
@@ -2242,6 +2245,9 @@ rbu.exe: $(TOP)\ext\rbu\rbu.c $(TOP)\ext\rbu\sqlite3rbu.c $(SQLITE3C) $(SQLITE3H
$(LTLINK) $(NO_WARN) -DSQLITE_ENABLE_RBU \
$(TOP)\ext\rbu\rbu.c $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)
LSMDIR=$(TOP)\ext\lsm1
!INCLUDE $(LSMDIR)\Makefile.msc
moreclean: clean
del /Q $(SQLITE3C) $(SQLITE3H) 2>NUL
# <</mark>>
@@ -2261,6 +2267,7 @@ clean:
-rmdir /Q/S tsrc 2>NUL
del /Q .target_source 2>NUL
del /Q tclsqlite3.exe $(SQLITETCLH) $(SQLITETCLDECLSH) 2>NUL
del /Q lsm.dll lsmtest.exe 2>NUL
del /Q testloadext.dll 2>NUL
del /Q testfixture.exe test.db 2>NUL
del /Q LogEst.exe fts3view.exe rollback-test.exe showdb.exe dbdump.exe 2>NUL
+34 -22
View File
@@ -34,7 +34,9 @@ archives as follows:
If you do want to use Fossil to check out the source tree,
first install Fossil version 2.0 or later.
(Source tarballs and precompiled binaries available
[here](https://www.fossil-scm.org/fossil/uv/download.html).)
[here](https://www.fossil-scm.org/fossil/uv/download.html). Fossil is
a stand-alone program. To install, simply download or build the single
executable file and put that file someplace on your $PATH.)
Then run commands like this:
mkdir ~/sqlite
@@ -106,19 +108,22 @@ The makefiles also require AWK.
## Source Code Tour
Most of the core source files are in the **src/** subdirectory. But
src/ also contains files used to build the "testfixture" test harness;
those file all begin with "test". And src/ contains the "shell.c" file
which is the main program for the "sqlite3.exe" command-line shell and
the "tclsqlite.c" file which implements the bindings to SQLite from the
Tcl programming language. (Historical note: SQLite began as a Tcl
Most of the core source files are in the **src/** subdirectory. The
**src/** folder also contains files used to build the "testfixture" test
harness. The names of the source files used by "testfixture" all begin
with "test".
The **src/** also contains the "shell.c" file
which is the main program for the "sqlite3.exe"
[command-line shell](https://sqlite.org/cli.html) and
the "tclsqlite.c" file which implements the
[TCL bindings](https://sqlite.org/tclsqlite.html) for SQLite.
(Historical note: SQLite began as a Tcl
extension and only later escaped to the wild as an independent library.)
Test scripts and programs are found in the **test/** subdirectory.
There are other test suites for SQLite (see
[How SQLite Is Tested](http://www.sqlite.org/testing.html))
but those other test suites are
in separate source repositories.
Addtional test code is found in other source repositories.
See [How SQLite Is Tested](http://www.sqlite.org/testing.html) for
additional information.
The **ext/** subdirectory contains code for extensions. The
Full-text search engine is in **ext/fts3**. The R-Tree engine is in
@@ -142,7 +147,7 @@ manually-edited files and automatically-generated files.
The SQLite interface is defined by the **sqlite3.h** header file, which is
generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION. The
[Tcl script](http://www.tcl.tk) at tool/mksqlite3h.tcl does the conversion.
The manifest.uuid file contains the SHA1 hash of the particular check-in
The manifest.uuid file contains the SHA3 hash of the particular check-in
and is used to generate the SQLITE\_SOURCE\_ID macro. The VERSION file
contains the current SQLite version number. The sqlite3.h header is really
just a copy of src/sqlite.h.in with the source-id and version number inserted
@@ -153,9 +158,8 @@ used to generate that documentation are in a separate source repository.
The SQL language parser is **parse.c** which is generate from a grammar in
the src/parse.y file. The conversion of "parse.y" into "parse.c" is done
by the [lemon](./doc/lemon.html) LALR(1) parser generator. The source code
for lemon is at tool/lemon.c. Lemon uses a
template for generating its parser. A generic template is in tool/lempar.c,
but SQLite uses a slightly modified template found in src/lempar.c.
for lemon is at tool/lemon.c. Lemon uses the tool/lempar.c file as a
template for generating its parser.
Lemon also generates the **parse.h** header file, at the same time it
generates parse.c. But the parse.h header file is
@@ -175,6 +179,13 @@ that maps SQL language keywords (ex: "CREATE", "SELECT", "INDEX", etc.) into
the numeric codes used by the parse.c parser. The keywordhash.h file is
generated by a C-language program at tool mkkeywordhash.c.
The **pragma.h** header file contains various definitions used to parse
and implement the PRAGMA statements. The header is generated by a
script **tool/mkpragmatab.tcl**. If you want to add a new PRAGMA, edit
the **tool/mkpragmatab.tcl** file to insert the information needed by the
parser for your new PRAGMA, then run the script to regenerate the
**pragma.h** header file.
### The Amalgamation
All of the individual C source code and header files (both manually-edited
@@ -192,7 +203,7 @@ subdirectory (using the equivalent of "make target_source") then the
tool/mksqlite3c.tcl script is run to copy them all together in just the
right order while resolving internal "#include" references.
The amalgamation source file is more than 100K lines long. Some symbolic
The amalgamation source file is more than 200K lines long. Some symbolic
debuggers (most notably MSVC) are unable to deal with files longer than 64K
lines. To work around this, a separate Tcl script, tool/split-sqlite3c.tcl,
can be run on the amalgamation to break it up into a single small C file
@@ -209,14 +220,15 @@ See the [architectural description](http://www.sqlite.org/arch.html)
for details. Other documents that are useful in
(helping to understand how SQLite works include the
[file format](http://www.sqlite.org/fileformat2.html) description,
the [virtual machine](http://www.sqlite.org/vdbe.html) that runs
the [virtual machine](http://www.sqlite.org/opcode.html) that runs
prepared statements, the description of
[how transactions work](http://www.sqlite.org/atomiccommit.html), and
the [overview of the query planner](http://www.sqlite.org/optoverview.html).
Unfortunately, years of effort have gone into optimizating SQLite, both
Years of effort have gone into optimizating SQLite, both
for small size and high performance. And optimizations tend to result in
complex code. So there is a lot of complexity in the SQLite implementation.
complex code. So there is a lot of complexity in the current SQLite
implementation. It will not be the easiest library in the world to hack.
Key files:
@@ -227,7 +239,7 @@ Key files:
* **sqliteInt.h** - this header file defines many of the data objects
used internally by SQLite.
* **parse.y** - This file describes the LALR(1) grammer that SQLite uses
* **parse.y** - This file describes the LALR(1) grammar that SQLite uses
to parse SQL statements, and the actions that are taken at each step
in the parsing process.
@@ -260,13 +272,13 @@ Key files:
is not part of the core SQLite library. But as most of the tests in this
repository are written in Tcl, the Tcl language bindings are important.
There are many other source files. Each has a suscinct header comment that
There are many other source files. Each has a succinct header comment that
describes its purpose and role within the larger system.
## Contacts
The main SQLite webpage is [http://www.sqlite.org/](http://www.sqlite.org/)
with geographically distributed backup servers at
with geographically distributed backups at
[http://www2.sqlite.org/](http://www2.sqlite.org) and
[http://www3.sqlite.org/](http://www3.sqlite.org).
+1 -1
View File
@@ -1 +1 @@
3.20.0
3.21.0
+1 -1
View File
@@ -927,7 +927,7 @@ LIBRESOBJS =
# when the shell is not being dynamically linked.
#
!IF $(DYNAMIC_SHELL)==0 && $(FOR_WIN10)==0
SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_EXPLAIN_COMMENTS
SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_STMTVTAB
!ENDIF
Vendored
+9 -9
View File
@@ -1,6 +1,6 @@
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for sqlite 3.20.0.
# Generated by GNU Autoconf 2.69 for sqlite 3.21.0.
#
#
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -726,8 +726,8 @@ MAKEFLAGS=
# Identity of this package.
PACKAGE_NAME='sqlite'
PACKAGE_TARNAME='sqlite'
PACKAGE_VERSION='3.20.0'
PACKAGE_STRING='sqlite 3.20.0'
PACKAGE_VERSION='3.21.0'
PACKAGE_STRING='sqlite 3.21.0'
PACKAGE_BUGREPORT=''
PACKAGE_URL=''
@@ -1463,7 +1463,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures sqlite 3.20.0 to adapt to many kinds of systems.
\`configure' configures sqlite 3.21.0 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@@ -1528,7 +1528,7 @@ fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of sqlite 3.20.0:";;
short | recursive ) echo "Configuration of sqlite 3.21.0:";;
esac
cat <<\_ACEOF
@@ -1652,7 +1652,7 @@ fi
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
sqlite configure 3.20.0
sqlite configure 3.21.0
generated by GNU Autoconf 2.69
Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2071,7 +2071,7 @@ cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by sqlite $as_me 3.20.0, which was
It was created by sqlite $as_me 3.21.0, which was
generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
@@ -12151,7 +12151,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by sqlite $as_me 3.20.0, which was
This file was extended by sqlite $as_me 3.21.0, which was
generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
@@ -12217,7 +12217,7 @@ _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
sqlite config.status 3.20.0
sqlite config.status 3.21.0
configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"
+28 -18
View File
@@ -1707,6 +1707,19 @@ static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){
sqlite3_finalize(pCsr->pStmt);
}
/*
** Free all resources currently held by the cursor passed as the only
** argument.
*/
static void fts3ClearCursor(Fts3Cursor *pCsr){
fts3CursorFinalizeStmt(pCsr);
sqlite3Fts3FreeDeferredTokens(pCsr);
sqlite3_free(pCsr->aDoclist);
sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
sqlite3Fts3ExprFree(pCsr->pExpr);
memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
}
/*
** Close the cursor. For additional information see the documentation
** on the xClose method of the virtual table interface.
@@ -1714,11 +1727,7 @@ static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){
static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){
Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
fts3CursorFinalizeStmt(pCsr);
sqlite3Fts3ExprFree(pCsr->pExpr);
sqlite3Fts3FreeDeferredTokens(pCsr);
sqlite3_free(pCsr->aDoclist);
sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
fts3ClearCursor(pCsr);
assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
sqlite3_free(pCsr);
return SQLITE_OK;
@@ -1744,7 +1753,7 @@ static int fts3CursorSeekStmt(Fts3Cursor *pCsr){
}else{
zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist);
if( !zSql ) return SQLITE_NOMEM;
rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
rc = sqlite3_prepare_v3(p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0);
sqlite3_free(zSql);
}
if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1;
@@ -3219,11 +3228,7 @@ static int fts3FilterMethod(
assert( iIdx==nVal );
/* In case the cursor has been used before, clear it now. */
fts3CursorFinalizeStmt(pCsr);
sqlite3_free(pCsr->aDoclist);
sqlite3Fts3MIBufferFree(pCsr->pMIBuffer);
sqlite3Fts3ExprFree(pCsr->pExpr);
memset(&pCursor[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
fts3ClearCursor(pCsr);
/* Set the lower and upper bounds on docids to return */
pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64);
@@ -3281,7 +3286,7 @@ static int fts3FilterMethod(
);
}
if( zSql ){
rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
rc = sqlite3_prepare_v3(p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0);
sqlite3_free(zSql);
}else{
rc = SQLITE_NOMEM;
@@ -3302,7 +3307,12 @@ static int fts3FilterMethod(
** routine to find out if it has reached the end of a result set.
*/
static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){
return ((Fts3Cursor *)pCursor)->isEof;
Fts3Cursor *pCsr = (Fts3Cursor*)pCursor;
if( pCsr->isEof ){
fts3ClearCursor(pCsr);
pCsr->isEof = 1;
}
return pCsr->isEof;
}
/*
@@ -3343,8 +3353,7 @@ static int fts3ColumnMethod(
switch( iCol-p->nColumn ){
case 0:
/* The special 'table-name' column */
sqlite3_result_blob(pCtx, &pCsr, sizeof(Fts3Cursor*), SQLITE_TRANSIENT);
sqlite3_result_subtype(pCtx, SQLITE_BLOB);
sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
break;
case 1:
@@ -3562,9 +3571,10 @@ static int fts3FunctionArg(
sqlite3_value *pVal, /* argv[0] passed to function */
Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
){
int rc = SQLITE_OK;
if( sqlite3_value_subtype(pVal)==SQLITE_BLOB ){
*ppCsr = *(Fts3Cursor**)sqlite3_value_blob(pVal);
int rc;
*ppCsr = (Fts3Cursor*)sqlite3_value_pointer(pVal, "fts3cursor");
if( (*ppCsr)!=0 ){
rc = SQLITE_OK;
}else{
char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc);
sqlite3_result_error(pContext, zErr, -1);
+2 -1
View File
@@ -407,7 +407,8 @@ static int fts3SqlStmt(
if( !zSql ){
rc = SQLITE_NOMEM;
}else{
rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, NULL);
rc = sqlite3_prepare_v3(p->db, zSql, -1, SQLITE_PREPARE_PERSISTENT,
&pStmt, NULL);
sqlite3_free(zSql);
assert( rc==SQLITE_OK || pStmt==0 );
p->aStmt[eStmt] = pStmt;
+4 -2
View File
@@ -728,7 +728,8 @@ static int fts5IndexPrepareStmt(
){
if( p->rc==SQLITE_OK ){
if( zSql ){
p->rc = sqlite3_prepare_v2(p->pConfig->db, zSql, -1, ppStmt, 0);
p->rc = sqlite3_prepare_v3(p->pConfig->db, zSql, -1,
SQLITE_PREPARE_PERSISTENT, ppStmt, 0);
}else{
p->rc = SQLITE_NOMEM;
}
@@ -777,7 +778,8 @@ static void fts5DataDelete(Fts5Index *p, i64 iFirst, i64 iLast){
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &p->pDeleter, 0);
rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
SQLITE_PREPARE_PERSISTENT, &p->pDeleter, 0);
sqlite3_free(zSql);
}
if( rc!=SQLITE_OK ){
+11 -10
View File
@@ -883,7 +883,8 @@ static int fts5PrepareStatement(
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &pRet, 0);
rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
SQLITE_PREPARE_PERSISTENT, &pRet, 0);
if( rc!=SQLITE_OK ){
*pConfig->pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(pConfig->db));
}
@@ -1019,7 +1020,8 @@ static int fts5FindRankFunction(Fts5Cursor *pCsr){
char *zSql = sqlite3Fts5Mprintf(&rc, "SELECT %s", zRankArgs);
if( zSql ){
sqlite3_stmt *pStmt = 0;
rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &pStmt, 0);
rc = sqlite3_prepare_v3(pConfig->db, zSql, -1,
SQLITE_PREPARE_PERSISTENT, &pStmt, 0);
sqlite3_free(zSql);
assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
if( rc==SQLITE_OK ){
@@ -2607,15 +2609,14 @@ static void fts5ModuleDestroy(void *pCtx){
static void fts5Fts5Func(
sqlite3_context *pCtx, /* Function call context */
int nArg, /* Number of args */
sqlite3_value **apUnused /* Function arguments */
sqlite3_value **apArg /* Function arguments */
){
Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
char buf[8];
UNUSED_PARAM2(nArg, apUnused);
assert( nArg==0 );
assert( sizeof(buf)>=sizeof(pGlobal) );
memcpy(buf, (void*)&pGlobal, sizeof(pGlobal));
sqlite3_result_blob(pCtx, buf, sizeof(pGlobal), SQLITE_TRANSIENT);
fts5_api **ppApi;
UNUSED_PARAM(nArg);
assert( nArg==1 );
ppApi = (fts5_api**)sqlite3_value_pointer(apArg[0], "fts5_api_ptr");
if( ppApi ) *ppApi = &pGlobal->api;
}
/*
@@ -2680,7 +2681,7 @@ static int fts5Init(sqlite3 *db){
if( rc==SQLITE_OK ) rc = sqlite3Fts5VocabInit(pGlobal, db);
if( rc==SQLITE_OK ){
rc = sqlite3_create_function(
db, "fts5", 0, SQLITE_UTF8, p, fts5Fts5Func, 0, 0
db, "fts5", 1, SQLITE_UTF8, p, fts5Fts5Func, 0, 0
);
}
if( rc==SQLITE_OK ){
+2 -1
View File
@@ -136,7 +136,8 @@ static int fts5StorageGetStmt(
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
rc = sqlite3_prepare_v2(pC->db, zSql, -1, &p->aStmt[eStmt], 0);
rc = sqlite3_prepare_v3(pC->db, zSql, -1,
SQLITE_PREPARE_PERSISTENT, &p->aStmt[eStmt], 0);
sqlite3_free(zSql);
if( rc!=SQLITE_OK && pzErrMsg ){
*pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));
+3 -6
View File
@@ -99,16 +99,13 @@ static int SQLITE_TCLAPI f5tDbAndApi(
sqlite3_stmt *pStmt = 0;
fts5_api *pApi = 0;
rc = sqlite3_prepare_v2(db, "SELECT fts5()", -1, &pStmt, 0);
rc = sqlite3_prepare_v2(db, "SELECT fts5(?1)", -1, &pStmt, 0);
if( rc!=SQLITE_OK ){
Tcl_AppendResult(interp, "error: ", sqlite3_errmsg(db), 0);
return TCL_ERROR;
}
if( SQLITE_ROW==sqlite3_step(pStmt) ){
const void *pPtr = sqlite3_column_blob(pStmt, 0);
memcpy((void*)&pApi, pPtr, sizeof(pApi));
}
sqlite3_bind_pointer(pStmt, 1, (void*)&pApi, "fts5_api_ptr", 0);
sqlite3_step(pStmt);
if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
Tcl_AppendResult(interp, "error: ", sqlite3_errmsg(db), 0);
+3 -7
View File
@@ -73,13 +73,10 @@ static int fts5_api_from_db(sqlite3 *db, fts5_api **ppApi){
int rc;
*ppApi = 0;
rc = sqlite3_prepare(db, "SELECT fts5()", -1, &pStmt, 0);
rc = sqlite3_prepare(db, "SELECT fts5(?1)", -1, &pStmt, 0);
if( rc==SQLITE_OK ){
if( SQLITE_ROW==sqlite3_step(pStmt)
&& sizeof(fts5_api*)==sqlite3_column_bytes(pStmt, 0)
){
memcpy(ppApi, sqlite3_column_blob(pStmt, 0), sizeof(fts5_api*));
}
sqlite3_bind_pointer(pStmt, 1, (void*)ppApi, "fts5_api_ptr", 0);
(void)sqlite3_step(pStmt);
rc = sqlite3_finalize(pStmt);
}
@@ -422,4 +419,3 @@ int sqlite3Fts5TestRegisterMatchinfo(sqlite3 *db){
}
#endif /* SQLITE_ENABLE_FTS5 */
+1 -3
View File
@@ -441,7 +441,7 @@ db func funk funk
do_catchsql_test 16.2 {
SELECT funk(), bm25(n1), funk() FROM n1 WHERE n1 MATCH 'a+b+c+d'
} {0 {{} -1e-06 {}}}
# {1 {SQL logic error or missing database}}
# {1 {SQL logic error}}
#-------------------------------------------------------------------------
#
@@ -595,5 +595,3 @@ do_execsql_test 22.1 {
finish_test
-1
View File
@@ -294,4 +294,3 @@ do_execsql_test 7.0 {
finish_test
-1
View File
@@ -276,4 +276,3 @@ foreach {tn expr tclexpr} {
}
finish_test
-2
View File
@@ -231,7 +231,6 @@ foreach {T create} {
set res [lsort -integer -increasing $res]
}
set n [llength $res]
if {$T==5} breakpoint
do_execsql_test $T.$bAsc.$tn.$n $sql $res
}
}
@@ -242,4 +241,3 @@ foreach {T create} {
}
finish_test
-1
View File
@@ -309,4 +309,3 @@ foreach {tn q cnt} {
}
finish_test
-1
View File
@@ -178,4 +178,3 @@ do_execsql_test 5.1 {
} ;# foreach_detail_mode
finish_test
-1
View File
@@ -142,4 +142,3 @@ if {[detail_is_full]} {
finish_test
-1
View File
@@ -167,4 +167,3 @@ do_execsql_test 1.8.2 {
#db eval {SELECT rowid, fts5_decode(rowid, block) aS r FROM t1_data} {puts $r}
finish_test
-1
View File
@@ -55,4 +55,3 @@ do_execsql_test 1.2 {
finish_test
-1
View File
@@ -66,4 +66,3 @@ do_execsql_test 2.0 { INSERT INTO t1(t1) VALUES('integrity-check') }
finish_test
-1
View File
@@ -147,4 +147,3 @@ do_execsql_test 3.1 {
}
finish_test
+1 -2
View File
@@ -77,7 +77,7 @@ foreach {tn defn} {
} {
do_test 2.2.$tn {
catchsql { INSERT INTO ft1(ft1, rank) VALUES('rank', $defn) }
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
}
#-------------------------------------------------------------------------
@@ -297,4 +297,3 @@ do_catchsql_test 4.4.4 {
finish_test
-2
View File
@@ -89,7 +89,6 @@ do_execsql_test 3.1 {
BEGIN;
INSERT INTO abc(rowid, a) VALUES(2, 'a');
}
breakpoint
do_execsql_test 3.2 {
SELECT rowid FROM abc WHERE abc MATCH 'a';
} {1 2}
@@ -100,4 +99,3 @@ do_execsql_test 3.3 {
} {1 2}
finish_test
-1
View File
@@ -342,4 +342,3 @@ foreach {tn expr} {
finish_test
-2
View File
@@ -240,7 +240,6 @@ foreach {tn lRow res} {
} {
execsql { DELETE FROM x1 }
foreach row $lRow { execsql { INSERT INTO x1 VALUES($row) } }
breakpoint
do_execsql_test 8.$tn {
SELECT highlight(x1, 0, '[', ']') FROM x1 WHERE x1 MATCH 'a OR (b AND d)';
} $res
@@ -279,4 +278,3 @@ do_execsql_test 9.3 {
finish_test
-1
View File
@@ -112,4 +112,3 @@ db eval {
}
finish_test
-1
View File
@@ -61,4 +61,3 @@ do_test 2.1...slow {
} {}
finish_test
-2
View File
@@ -64,5 +64,3 @@ foreach_detail_mode $::testprefix {
}
finish_test
-2
View File
@@ -84,5 +84,3 @@ foreach_detail_mode $::testprefix {
finish_test
-1
View File
@@ -143,7 +143,6 @@ do_execsql_test 4.1.1 {
INSERT INTO t5 VALUES('2 4 6 8');
}
breakpoint
do_execsql_test 4.1.2 {
INSERT INTO t5(t5) VALUES('integrity-check');
}
+14 -16
View File
@@ -66,7 +66,7 @@ foreach {tn val} {
} {
do_catchsql_test 3.$tn {
INSERT INTO t1(t1, rank) VALUES('rank', $val);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
}
#-------------------------------------------------------------------------
@@ -110,7 +110,6 @@ do_catchsql_test 5.1 {
CREATE VIRTUAL TABLE xx USING fts5(x, tokenize="porter 'ascii");
} {1 {parse error in tokenize directive}}
breakpoint
do_catchsql_test 5.2 {
CREATE VIRTUAL TABLE xx USING fts5(x, [y[]);
} {0 {}}
@@ -169,33 +168,33 @@ do_execsql_test 9.0 {
} {}
do_catchsql_test 9.1.1 {
INSERT INTO abc(abc, rank) VALUES('pgsz', -5);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.1.2 {
INSERT INTO abc(abc, rank) VALUES('pgsz', 50000000);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.1.3 {
INSERT INTO abc(abc, rank) VALUES('pgsz', 66.67);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.2.1 {
INSERT INTO abc(abc, rank) VALUES('automerge', -5);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.2.2 {
INSERT INTO abc(abc, rank) VALUES('automerge', 50000000);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.2.3 {
INSERT INTO abc(abc, rank) VALUES('automerge', 66.67);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_execsql_test 9.2.4 {
INSERT INTO abc(abc, rank) VALUES('automerge', 1);
} {}
do_catchsql_test 9.3.1 {
INSERT INTO abc(abc, rank) VALUES('crisismerge', -5);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.3.2 {
INSERT INTO abc(abc, rank) VALUES('crisismerge', 66.67);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_execsql_test 9.3.3 {
INSERT INTO abc(abc, rank) VALUES('crisismerge', 1);
} {}
@@ -205,14 +204,14 @@ do_execsql_test 9.3.4 {
do_catchsql_test 9.4.1 {
INSERT INTO abc(abc, rank) VALUES('nosuchoption', 1);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.5.1 {
INSERT INTO abc(abc, rank) VALUES('hashsize', 'not an integer');
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.5.2 {
INSERT INTO abc(abc, rank) VALUES('hashsize', -500000);
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
do_catchsql_test 9.5.3 {
INSERT INTO abc(abc, rank) VALUES('hashsize', 500000);
} {0 {}}
@@ -245,7 +244,7 @@ foreach {tn opt} {
do_catchsql_test 12.1 {
INSERT INTO t1(t1, rank) VALUES('rank', NULL);;
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
#-------------------------------------------------------------------------
# errors in the 'usermerge' option
@@ -260,8 +259,7 @@ foreach {tn val} {
4 1
} {
set sql "INSERT INTO tt(tt, rank) VALUES('usermerge', $val)"
do_catchsql_test 13.$tn $sql {1 {SQL logic error or missing database}}
do_catchsql_test 13.$tn $sql {1 {SQL logic error}}
}
finish_test
-2
View File
@@ -66,5 +66,3 @@ do_execsql_test 2.1 {
}
finish_test
-1
View File
@@ -255,4 +255,3 @@ do_execsql_test 6.2 {
finish_test
-1
View File
@@ -96,4 +96,3 @@ do_catchsql_test 3.1 {
} {1 {database disk image is malformed}}
finish_test
-1
View File
@@ -269,4 +269,3 @@ do_catchsql_test 6.2 {
sqlite3_fts5_may_be_corrupt 0
finish_test
-1
View File
@@ -409,4 +409,3 @@ do_catchsql_test 9.2.2 {
sqlite3_fts5_may_be_corrupt 0
finish_test
-1
View File
@@ -51,4 +51,3 @@ do_test 1.2 {
} {}
finish_test
-1
View File
@@ -241,4 +241,3 @@ do_execsql_test 5.3 {
finish_test
-2
View File
@@ -63,5 +63,3 @@ foreach_detail_mode $::testprefix {
finish_test
-3
View File
@@ -66,7 +66,6 @@ proc do_dlidx_test1 {tn spc1 spc2 nEntry iFirst nStep} {
}
execsql COMMIT
breakpoint
do_test $tn.1 {
execsql { INSERT INTO t1(t1) VALUES('integrity-check') }
} {}
@@ -124,7 +123,6 @@ proc do_dlidx_test2 {tn nEntry iFirst nStep} {
do_execsql_test $tn.1 {
SELECT rowid FROM t1 WHERE t1 MATCH 'b AND a'
} {1}
breakpoint
do_execsql_test $tn.2 {
SELECT rowid FROM t1 WHERE t1 MATCH 'b AND a' ORDER BY rowid DESC
} {1}
@@ -197,4 +195,3 @@ foreach v $vocab {
finish_test
-1
View File
@@ -44,4 +44,3 @@ do_execsql_test 1.2 {
finish_test
-3
View File
@@ -81,6 +81,3 @@ do_execsql_test 3.3 {
finish_test
-1
View File
@@ -351,4 +351,3 @@ do_faultsim_test 9.1 -faults oom-* -prep {
finish_test
-1
View File
@@ -137,4 +137,3 @@ do_faultsim_test 5.0 -faults oom-* -prep {
}
finish_test
-1
View File
@@ -110,4 +110,3 @@ do_faultsim_test 3.2 -faults oom-* -prep {
finish_test
-1
View File
@@ -395,4 +395,3 @@ do_faultsim_test 14.1 -faults oom-t* -prep {
}
finish_test
-2
View File
@@ -105,7 +105,6 @@ do_faultsim_test 3.2 -faults oom-t* -body {
faultsim_test_result {0 {1 10 11 12 13 14 15 16 17 18 19 2}}
}
breakpoint
do_execsql_test 3.3.0 {
SELECT * FROM tv2;
} {
@@ -130,4 +129,3 @@ do_faultsim_test 3.3 -faults oom-t* -body {
finish_test
-2
View File
@@ -280,7 +280,6 @@ do_faultsim_test 5.4 -faults oom* -prep {
#-------------------------------------------------------------------------
catch { db close }
breakpoint
do_faultsim_test 6 -faults oom* -prep {
sqlite_orig db test.db
sqlite3_db_config_lookaside db 0 0 0
@@ -292,4 +291,3 @@ do_faultsim_test 6 -faults oom* -prep {
db close
}
finish_test
-1
View File
@@ -116,4 +116,3 @@ do_faultsim_test 2.2 -faults oom-* -body {
}
finish_test
-1
View File
@@ -82,4 +82,3 @@ do_faultsim_test 4 -faults oom-* -prep {
finish_test
-1
View File
@@ -153,4 +153,3 @@ do_faultsim_test 6 -faults oom-* -body {
} ;# foreach_detail_mode...
finish_test
-1
View File
@@ -61,4 +61,3 @@ do_faultsim_test 2 -faults oom* -prep {
faultsim_test_result {0 {1 2}}
}
finish_test
-1
View File
@@ -132,4 +132,3 @@ do_faultsim_test 4.2 -faults oom* -body {
finish_test
-1
View File
@@ -40,4 +40,3 @@ do_test 1.1 {
finish_test
-1
View File
@@ -90,4 +90,3 @@ do_catchsql_test 4.1 {
} {1 {fts5: syntax error near "`"}}
finish_test
-2
View File
@@ -121,7 +121,6 @@ foreach_detail_mode $testprefix {
}
execsql { CREATE VIRTUAL TABLE t2 USING fts5(x, detail=%DETAIL%) }
breakpoint
execsql {
INSERT INTO t2 VALUES($small || ' ' || $big);
}
@@ -130,4 +129,3 @@ breakpoint
} ;# foreach_detail_mode
finish_test
-1
View File
@@ -210,4 +210,3 @@ foreach {tn pgsz} {
}
finish_test
-1
View File
@@ -70,4 +70,3 @@ do_execsql_test 1.6 {
finish_test
+43
View File
@@ -0,0 +1,43 @@
# 2014 June 17
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#*************************************************************************
# This file implements regression tests for SQLite library. The
# focus of this script is testing the FTS5 module.
#
source [file join [file dirname [info script]] fts5_common.tcl]
set testprefix fts5leftjoin
# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
ifcapable !fts5 {
finish_test
return
}
do_execsql_test 1.0 {
CREATE VIRTUAL TABLE vt USING fts5(x);
INSERT INTO vt VALUES('abc');
INSERT INTO vt VALUES('xyz');
CREATE TABLE t1(a INTEGER PRIMARY KEY);
INSERT INTO t1 VALUES(1), (2);
}
do_execsql_test 1.1 {
SELECT * FROM t1 LEFT JOIN (
SELECT rowid AS rrr, * FROM vt WHERE vt MATCH 'abc'
) ON t1.a = rrr
} {1 1 abc 2 {} {}}
do_execsql_test 1.2 {
SELECT * FROM t1 LEFT JOIN vt ON (vt MATCH 'abc')
} {1 abc 2 abc}
finish_test
+1 -2
View File
@@ -472,7 +472,7 @@ do_execsql_test 12.1 {
#
reset_db
proc xyz {} {}
db func fts5 -argcount 0 xyz
db func fts5 -argcount 1 xyz
do_test 13.1 {
list [catch { sqlite3_fts5_register_matchinfo db } msg] $msg
} {1 SQLITE_ERROR}
@@ -492,4 +492,3 @@ do_catchsql_test 14.2 {
} {1 {unrecognized matchinfo flag: d}}
finish_test
-1
View File
@@ -241,4 +241,3 @@ do_execsql_test 6.3 {
finish_test
-1
View File
@@ -55,4 +55,3 @@ do_execsql_test 1.2 {
}
finish_test
-1
View File
@@ -45,4 +45,3 @@ do_multiclient_test tn {
};# do_multiclient_test
};# foreach_detail_mode
finish_test
-1
View File
@@ -68,4 +68,3 @@ do_near_test 1.25 "a b c d e f g h i" { NEAR(i a+b+c+d b+c, 4) } 0
finish_test
-1
View File
@@ -178,4 +178,3 @@ do_execsql_test 4.3.1 {
do_test 4.2.2 { fts5_level_segs ttt } {3}
finish_test
-1
View File
@@ -106,4 +106,3 @@ foreach {tn nStep} {
do_test 2.$tn.6 { fts5_segcount t1 } 1
}
finish_test
-1
View File
@@ -116,4 +116,3 @@ do_execsql_test 2.0 {
}
finish_test
-1
View File
@@ -64,4 +64,3 @@ do_eqp_test 1.5 {
finish_test
-1
View File
@@ -11803,4 +11803,3 @@ foreach {in out} $test_vocab {
finish_test
-1
View File
@@ -67,4 +67,3 @@ foreach {in out} $test_vocab {
finish_test
-2
View File
@@ -341,5 +341,3 @@ foreach {tn create} {
}
finish_test
-2
View File
@@ -79,5 +79,3 @@ for {set tn 1 ; set pgsz 64} {$tn<32} {incr tn; incr pgsz 16} {
finish_test
-1
View File
@@ -152,4 +152,3 @@ do_execsql_test 4.1 {
finish_test
-1
View File
@@ -64,4 +64,3 @@ do_catchsql_test 2.2 {
INSERT INTO nc(nc) VALUES('rebuild');
} {1 {'rebuild' may not be used with a contentless fts5 table}}
finish_test
-1
View File
@@ -149,4 +149,3 @@ do_test 4.3 {
finish_test
-1
View File
@@ -216,4 +216,3 @@ do_execsql_test 6.2 {
finish_test
-1
View File
@@ -411,7 +411,6 @@ do_catchsql_test 19.2 {
#-------------------------------------------------------------------------
reset_db
breakpoint
do_execsql_test 20.0 {
CREATE VIRTUAL TABLE x1 USING fts5(x);
INSERT INTO x1(x1, rank) VALUES('pgsz', 32);
-1
View File
@@ -370,4 +370,3 @@ do_execsql_test 17.6 {
#db eval {SELECT rowid, fts5_decode_none(rowid, block) aS r FROM t2_data} {puts $r}
finish_test
-1
View File
@@ -116,4 +116,3 @@ do_execsql_test 4.6 {
finish_test
-1
View File
@@ -421,4 +421,3 @@ do_execsql_test 7.1.2 {
} ;# foreach_detail_mode
finish_test
-1
View File
@@ -161,4 +161,3 @@ foreach {tn expr} {
}
finish_test
+1 -1
View File
@@ -109,7 +109,7 @@ do_catchsql_test 2.0 {
do_catchsql_test 2.1 {
CREATE VIRTUAL TABLE t4 USING fts5tokenize;
SELECT * FROM t4;
} {1 {SQL logic error or missing database}}
} {1 {SQL logic error}}
finish_test
-1
View File
@@ -302,4 +302,3 @@ do_test 9.5.2 { set ::flags } {query}
finish_test
-2
View File
@@ -50,7 +50,6 @@ do_execsql_test 2.0 "
INSERT INTO t2 VALUES('\xC0\xC8\xCC');
INSERT INTO t3 VALUES('\xC0\xC8\xCC');
"
breakpoint
do_execsql_test 2.1 "
SELECT 't1' FROM t1 WHERE t1 MATCH '\xE0\xE8\xEC';
SELECT 't2' FROM t2 WHERE t2 MATCH '\xE0\xE8\xEC';
@@ -59,4 +58,3 @@ do_execsql_test 2.1 "
finish_test
-1
View File
@@ -281,7 +281,6 @@ do_test 4.4 {
#-------------------------------------------------------------------------
breakpoint
do_unicode_token_test3 5.1 {tokenchars {}} {
sqlite3_reset sqlite3_column_int
} {
-1
View File
@@ -126,4 +126,3 @@ do_test 1.5 {
finish_test
-1
View File
@@ -76,4 +76,3 @@ do_execsql_test 3.2 {
finish_test
-2
View File
@@ -117,5 +117,3 @@ do_execsql_test 2.2.integrity {
}
finish_test
-1
View File
@@ -61,4 +61,3 @@ do_test 1.7 {
finish_test
-1
View File
@@ -210,7 +210,6 @@ do_execsql_test 5.0 {
INSERT INTO aux.t1 VALUES('x n z');
}
breakpoint
do_execsql_test 5.1 {
CREATE VIRTUAL TABLE temp.vm USING fts5vocab(main, t1, row);
CREATE VIRTUAL TABLE temp.vt1 USING fts5vocab(t1, row);
+56
View File
@@ -0,0 +1,56 @@
#
# This Makefile is designed for use with main.mk in the root directory of
# this project. After including main.mk, the users makefile should contain:
#
# LSMDIR=$(TOP)/ext/lsm1/
# LSMOPTS=-fPIC
# include $(LSMDIR)/Makefile
#
# The most useful targets are [lsmtest] and [lsm.so].
#
LSMOBJ = \
lsm_ckpt.o \
lsm_file.o \
lsm_log.o \
lsm_main.o \
lsm_mem.o \
lsm_mutex.o \
lsm_shared.o \
lsm_sorted.o \
lsm_str.o \
lsm_tree.o \
lsm_unix.o \
lsm_win32.o \
lsm_varint.o \
lsm_vtab.o
LSMHDR = \
$(LSMDIR)/lsm.h \
$(LSMDIR)/lsmInt.h
LSMTESTSRC = $(LSMDIR)/lsm-test/lsmtest1.c $(LSMDIR)/lsm-test/lsmtest2.c \
$(LSMDIR)/lsm-test/lsmtest3.c $(LSMDIR)/lsm-test/lsmtest4.c \
$(LSMDIR)/lsm-test/lsmtest5.c $(LSMDIR)/lsm-test/lsmtest6.c \
$(LSMDIR)/lsm-test/lsmtest7.c $(LSMDIR)/lsm-test/lsmtest8.c \
$(LSMDIR)/lsm-test/lsmtest9.c \
$(LSMDIR)/lsm-test/lsmtest_datasource.c \
$(LSMDIR)/lsm-test/lsmtest_func.c $(LSMDIR)/lsm-test/lsmtest_io.c \
$(LSMDIR)/lsm-test/lsmtest_main.c $(LSMDIR)/lsm-test/lsmtest_mem.c \
$(LSMDIR)/lsm-test/lsmtest_tdb.c $(LSMDIR)/lsm-test/lsmtest_tdb3.c \
$(LSMDIR)/lsm-test/lsmtest_util.c $(LSMDIR)/lsm-test/lsmtest_win32.c
# all: lsm.so
LSMOPTS += -DLSM_MUTEX_PTHREADS=1 -I$(LSMDIR)
lsm.so: $(LSMOBJ)
$(TCCX) -shared -o lsm.so $(LSMOBJ)
%.o: $(LSMDIR)/%.c $(LSMHDR) sqlite3.h
$(TCCX) $(LSMOPTS) -c $<
lsmtest$(EXE): $(LSMOBJ) $(LSMTESTSRC) $(LSMTESTHDR) sqlite3.o
# $(TCPPX) -c $(TOP)/lsm-test/lsmtest_tdb2.cc
$(TCCX) $(LSMOPTS) $(LSMTESTSRC) $(LSMOBJ) sqlite3.o -o lsmtest$(EXE) $(THREADLIB)
+102
View File
@@ -0,0 +1,102 @@
#
# This Makefile is designed for use with Makefile.msc in the root directory
# of this project. The Makefile.msc should contain:
#
# LSMDIR=$(TOP)\ext\lsm1
# !INCLUDE $(LSMDIR)\Makefile.msc
#
# The most useful targets are [lsmtest.exe] and [lsm.dll].
#
LSMOBJ = \
lsm_ckpt.lo \
lsm_file.lo \
lsm_log.lo \
lsm_main.lo \
lsm_mem.lo \
lsm_mutex.lo \
lsm_shared.lo \
lsm_sorted.lo \
lsm_str.lo \
lsm_tree.lo \
lsm_unix.lo \
lsm_win32.lo \
lsm_varint.lo \
lsm_vtab.lo
LSMHDR = \
$(LSMDIR)\lsm.h \
$(LSMDIR)\lsmInt.h
LSMTESTSRC = $(LSMDIR)\lsm-test\lsmtest1.c $(LSMDIR)\lsm-test\lsmtest2.c \
$(LSMDIR)\lsm-test\lsmtest3.c $(LSMDIR)\lsm-test\lsmtest4.c \
$(LSMDIR)\lsm-test\lsmtest5.c $(LSMDIR)\lsm-test\lsmtest6.c \
$(LSMDIR)\lsm-test\lsmtest7.c $(LSMDIR)\lsm-test\lsmtest8.c \
$(LSMDIR)\lsm-test\lsmtest9.c \
$(LSMDIR)\lsm-test\lsmtest_datasource.c \
$(LSMDIR)\lsm-test\lsmtest_func.c $(LSMDIR)\lsm-test\lsmtest_io.c \
$(LSMDIR)\lsm-test\lsmtest_main.c $(LSMDIR)\lsm-test\lsmtest_mem.c \
$(LSMDIR)\lsm-test\lsmtest_tdb.c $(LSMDIR)\lsm-test\lsmtest_tdb3.c \
$(LSMDIR)\lsm-test\lsmtest_util.c $(LSMDIR)\lsm-test\lsmtest_win32.c
# all: lsm.dll lsmtest.exe
LSMOPTS = $(NO_WARN) -DLSM_MUTEX_WIN32=1 -I$(LSMDIR)
!IF $(DEBUG)>2
LSMOPTS = $(LSMOPTS) -DLSM_DEBUG=1
!ENDIF
!IF $(MEMDEBUG)!=0
LSMOPTS = $(LSMOPTS) -DLSM_DEBUG_MEM=1
!ENDIF
lsm_ckpt.lo: $(LSMDIR)\lsm_ckpt.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_ckpt.c
lsm_file.lo: $(LSMDIR)\lsm_file.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_file.c
lsm_log.lo: $(LSMDIR)\lsm_log.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_log.c
lsm_main.lo: $(LSMDIR)\lsm_main.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_main.c
lsm_mem.lo: $(LSMDIR)\lsm_mem.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_mem.c
lsm_mutex.lo: $(LSMDIR)\lsm_mutex.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_mutex.c
lsm_shared.lo: $(LSMDIR)\lsm_shared.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_shared.c
lsm_sorted.lo: $(LSMDIR)\lsm_sorted.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_sorted.c
lsm_str.lo: $(LSMDIR)\lsm_str.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_str.c
lsm_tree.lo: $(LSMDIR)\lsm_tree.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_tree.c
lsm_unix.lo: $(LSMDIR)\lsm_unix.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_unix.c
lsm_win32.lo: $(LSMDIR)\lsm_win32.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_win32.c
lsm_varint.lo: $(LSMDIR)\lsm_varint.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_varint.c
lsm_vtab.lo: $(LSMDIR)\lsm_vtab.c $(LSMHDR) $(SQLITE3H)
$(LTCOMPILE) $(LSMOPTS) -c $(LSMDIR)\lsm_vtab.c
lsm.dll: $(LSMOBJ)
$(LD) $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) /DLL /OUT:$@ $(LSMOBJ)
copy /Y $@ $(LSMDIR)\$@
lsmtest.exe: $(LSMOBJ) $(LSMTESTSRC) $(LSMTESTHDR) $(LIBOBJ)
$(LTLINK) $(LSMOPTS) $(LSMTESTSRC) /link $(LSMOBJ) $(LIBOBJ)
copy /Y $@ $(LSMDIR)\$@
+40
View File
@@ -0,0 +1,40 @@
Organization of test case files:
lsmtest1.c: Data tests. Tests that perform many inserts and deletes on a
database file, then verify that the contents of the database can
be queried.
lsmtest2.c: Crash tests. Tests that attempt to verify that the database
recovers correctly following an application or system crash.
lsmtest3.c: Rollback tests. Tests that focus on the explicit rollback of
transactions and sub-transactions.
lsmtest4.c: Multi-client tests.
lsmtest5.c: Multi-client tests with a different thread for each client.
lsmtest6.c: OOM injection tests.
lsmtest7.c: API tests.
lsmtest8.c: Writer crash tests. Tests in this file attempt to verify that
the system recovers and other clients proceed unaffected if
a process fails in the middle of a write transaction.
The difference from lsmtest2.c is that this file tests
live-recovery (recovery from a failure that occurs while other
clients are still running) whereas lsmtest2.c tests recovery
from a system or power failure.
lsmtest9.c: More data tests. These focus on testing that calling
lsm_work(nMerge=1) to compact the database does not corrupt it.
In other words, that databases containing block-redirects
can be read and written.
+302
View File
@@ -0,0 +1,302 @@
#ifndef __WRAPPER_INT_H_
#define __WRAPPER_INT_H_
#include "lsmtest_tdb.h"
#include "sqlite3.h"
#include "lsm.h"
#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#ifndef _WIN32
# include <unistd.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdlib.h>
#include <errno.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _WIN32
# include "windows.h"
# define gettimeofday win32GetTimeOfDay
# define F_OK (0)
# define sleep(sec) Sleep(1000 * (sec))
# define usleep(usec) Sleep(((usec) + 999) / 1000)
# ifdef _MSC_VER
# include <io.h>
# define snprintf _snprintf
# define fsync(fd) FlushFileBuffers((HANDLE)_get_osfhandle((fd)))
# define fdatasync(fd) FlushFileBuffers((HANDLE)_get_osfhandle((fd)))
# define __va_copy(dst,src) ((dst) = (src))
# define ftruncate(fd,sz) ((_chsize_s((fd), (sz))==0) ? 0 : -1)
# else
# error Unsupported C compiler for Windows.
# endif
int win32GetTimeOfDay(struct timeval *, void *);
#endif
#ifndef _LSM_INT_H
typedef unsigned int u32;
typedef unsigned char u8;
typedef long long int i64;
typedef unsigned long long int u64;
#endif
#define ArraySize(x) ((int)(sizeof(x) / sizeof((x)[0])))
#define MIN(x,y) ((x)<(y) ? (x) : (y))
#define MAX(x,y) ((x)>(y) ? (x) : (y))
#define unused_parameter(x) (void)(x)
#define TESTDB_DEFAULT_PAGE_SIZE 4096
#define TESTDB_DEFAULT_CACHE_SIZE 2048
#ifndef _O_BINARY
# define _O_BINARY (0)
#endif
/*
** Ideally, these should be in wrapper.c. But they are here instead so that
** they can be used by the C++ database wrappers in wrapper2.cc.
*/
typedef struct DatabaseMethods DatabaseMethods;
struct TestDb {
DatabaseMethods const *pMethods; /* Database methods */
const char *zLibrary; /* Library name for tdb_open() */
};
struct DatabaseMethods {
int (*xClose)(TestDb *);
int (*xWrite)(TestDb *, void *, int , void *, int);
int (*xDelete)(TestDb *, void *, int);
int (*xDeleteRange)(TestDb *, void *, int, void *, int);
int (*xFetch)(TestDb *, void *, int, void **, int *);
int (*xScan)(TestDb *, void *, int, void *, int, void *, int,
void (*)(void *, void *, int , void *, int)
);
int (*xBegin)(TestDb *, int);
int (*xCommit)(TestDb *, int);
int (*xRollback)(TestDb *, int);
};
/*
** Functions in wrapper2.cc (a C++ source file). wrapper2.cc contains the
** wrapper for Kyoto Cabinet. Kyoto cabinet has a C API, but
** the primary interface is the C++ API.
*/
int test_kc_open(const char*, const char *zFilename, int bClear, TestDb **ppDb);
int test_kc_close(TestDb *);
int test_kc_write(TestDb *, void *, int , void *, int);
int test_kc_delete(TestDb *, void *, int);
int test_kc_delete_range(TestDb *, void *, int, void *, int);
int test_kc_fetch(TestDb *, void *, int, void **, int *);
int test_kc_scan(TestDb *, void *, int, void *, int, void *, int,
void (*)(void *, void *, int , void *, int)
);
int test_mdb_open(const char*, const char *zFile, int bClear, TestDb **ppDb);
int test_mdb_close(TestDb *);
int test_mdb_write(TestDb *, void *, int , void *, int);
int test_mdb_delete(TestDb *, void *, int);
int test_mdb_fetch(TestDb *, void *, int, void **, int *);
int test_mdb_scan(TestDb *, void *, int, void *, int, void *, int,
void (*)(void *, void *, int , void *, int)
);
/*
** Functions in wrapper3.c. This file contains the tdb wrapper for lsm.
** The wrapper for lsm is a bit more involved than the others, as it
** includes code for a couple of different lsm configurations, and for
** various types of fault injection and robustness testing.
*/
int test_lsm_open(const char*, const char *zFile, int bClear, TestDb **ppDb);
int test_lsm_lomem_open(const char*, const char*, int bClear, TestDb **ppDb);
int test_lsm_zip_open(const char*, const char*, int bClear, TestDb **ppDb);
int test_lsm_small_open(const char*, const char*, int bClear, TestDb **ppDb);
int test_lsm_mt2(const char*, const char *zFile, int bClear, TestDb **ppDb);
int test_lsm_mt3(const char*, const char *zFile, int bClear, TestDb **ppDb);
int tdb_lsm_configure(lsm_db *, const char *);
/* Functions in lsmtest_tdb4.c */
int test_bt_open(const char*, const char *zFile, int bClear, TestDb **ppDb);
int test_fbt_open(const char*, const char *zFile, int bClear, TestDb **ppDb);
int test_fbts_open(const char*, const char *zFile, int bClear, TestDb **ppDb);
/* Functions in testutil.c. */
int testPrngInit(void);
u32 testPrngValue(u32 iVal);
void testPrngArray(u32 iVal, u32 *aOut, int nOut);
void testPrngString(u32 iVal, char *aOut, int nOut);
void testErrorInit(int argc, char **);
void testPrintError(const char *zFormat, ...);
void testPrintUsage(const char *zArgs);
void testPrintFUsage(const char *zFormat, ...);
void testTimeInit(void);
int testTimeGet(void);
/* Functions in testmem.c. */
void testMallocInstall(lsm_env *pEnv);
void testMallocUninstall(lsm_env *pEnv);
void testMallocCheck(lsm_env *pEnv, int *, int *, FILE *);
void testMallocOom(lsm_env *pEnv, int, int, void(*)(void*), void *);
void testMallocOomEnable(lsm_env *pEnv, int);
/* lsmtest.c */
TestDb *testOpen(const char *zSystem, int, int *pRc);
void testReopen(TestDb **ppDb, int *pRc);
void testClose(TestDb **ppDb);
void testFetch(TestDb *, void *, int, void *, int, int *);
void testWrite(TestDb *, void *, int, void *, int, int *);
void testDelete(TestDb *, void *, int, int *);
void testDeleteRange(TestDb *, void *, int, void *, int, int *);
void testWriteStr(TestDb *, const char *, const char *zVal, int *pRc);
void testFetchStr(TestDb *, const char *, const char *, int *pRc);
void testBegin(TestDb *pDb, int iTrans, int *pRc);
void testCommit(TestDb *pDb, int iTrans, int *pRc);
void test_failed(void);
char *testMallocPrintf(const char *zFormat, ...);
char *testMallocVPrintf(const char *zFormat, va_list ap);
int testGlobMatch(const char *zPattern, const char *zStr);
void testScanCompare(TestDb *, TestDb *, int, void *, int, void *, int, int *);
void testFetchCompare(TestDb *, TestDb *, void *, int, int *);
void *testMalloc(int);
void *testMallocCopy(void *pCopy, int nByte);
void *testRealloc(void *, int);
void testFree(void *);
/* lsmtest_bt.c */
int do_bt(int nArg, char **azArg);
/* testio.c */
int testVfsConfigureDb(TestDb *pDb);
/* testfunc.c */
int do_show(int nArg, char **azArg);
int do_work(int nArg, char **azArg);
/* testio.c */
int do_io(int nArg, char **azArg);
/* lsmtest2.c */
void do_crash_test(const char *zPattern, int *pRc);
int do_rollback_test(int nArg, char **azArg);
/* test3.c */
void test_rollback(const char *zSystem, const char *zPattern, int *pRc);
/* test4.c */
void test_mc(const char *zSystem, const char *zPattern, int *pRc);
/* test5.c */
void test_mt(const char *zSystem, const char *zPattern, int *pRc);
/* lsmtest6.c */
void test_oom(const char *zPattern, int *pRc);
void testDeleteLsmdb(const char *zFile);
void testSaveDb(const char *zFile, const char *zAuxExt);
void testRestoreDb(const char *zFile, const char *zAuxExt);
void testCopyLsmdb(const char *zFrom, const char *zTo);
/* lsmtest7.c */
void test_api(const char *zPattern, int *pRc);
/* lsmtest8.c */
void do_writer_crash_test(const char *zPattern, int *pRc);
/*************************************************************************
** Interface to functionality in test_datasource.c.
*/
typedef struct Datasource Datasource;
typedef struct DatasourceDefn DatasourceDefn;
struct DatasourceDefn {
int eType; /* A TEST_DATASOURCE_* value */
int nMinKey; /* Minimum key size */
int nMaxKey; /* Maximum key size */
int nMinVal; /* Minimum value size */
int nMaxVal; /* Maximum value size */
};
#define TEST_DATASOURCE_RANDOM 1
#define TEST_DATASOURCE_SEQUENCE 2
char *testDatasourceName(const DatasourceDefn *);
Datasource *testDatasourceNew(const DatasourceDefn *);
void testDatasourceFree(Datasource *);
void testDatasourceEntry(Datasource *, int, void **, int *, void **, int *);
/* End of test_datasource.c interface.
*************************************************************************/
void testDatasourceFetch(
TestDb *pDb, /* Database handle */
Datasource *pData,
int iKey,
int *pRc /* IN/OUT: Error code */
);
void testWriteDatasource(TestDb *, Datasource *, int, int *);
void testWriteDatasourceRange(TestDb *, Datasource *, int, int, int *);
void testDeleteDatasource(TestDb *, Datasource *, int, int *);
void testDeleteDatasourceRange(TestDb *, Datasource *, int, int, int *);
/* test1.c */
void test_data_1(const char *, const char *, int *pRc);
void test_data_2(const char *, const char *, int *pRc);
void test_data_3(const char *, const char *, int *pRc);
void testDbContents(TestDb *, Datasource *, int, int, int, int, int, int *);
void testCaseProgress(int, int, int, int *);
int testCaseNDot(void);
void testCompareDb(Datasource *, int, int, TestDb *, TestDb *, int *);
int testControlDb(TestDb **ppDb);
typedef struct CksumDb CksumDb;
CksumDb *testCksumArrayNew(Datasource *, int, int, int);
char *testCksumArrayGet(CksumDb *, int);
void testCksumArrayFree(CksumDb *);
void testCaseStart(int *pRc, char *zFmt, ...);
void testCaseFinish(int rc);
void testCaseSkip(void);
int testCaseBegin(int *, const char *, const char *, ...);
#define TEST_CKSUM_BYTES 29
int testCksumDatabase(TestDb *pDb, char *zOut);
int testCountDatabase(TestDb *pDb);
void testCompareInt(int, int, int *);
void testCompareStr(const char *z1, const char *z2, int *pRc);
/* lsmtest9.c */
void test_data_4(const char *, const char *, int *pRc);
/*
** Similar to the Tcl_GetIndexFromObjStruct() Tcl library function.
*/
#define testArgSelect(w,x,y,z) testArgSelectX(w,x,sizeof(w[0]),y,z)
int testArgSelectX(void *, const char *, int, const char *, int *);
#ifdef __cplusplus
} /* End of the 'extern "C"' block */
#endif
#endif
+654
View File
@@ -0,0 +1,654 @@
#include "lsmtest.h"
#define DATA_SEQUENTIAL TEST_DATASOURCE_SEQUENCE
#define DATA_RANDOM TEST_DATASOURCE_RANDOM
typedef struct Datatest1 Datatest1;
typedef struct Datatest2 Datatest2;
/*
** An instance of the following structure contains parameters used to
** customize the test function in this file. Test procedure:
**
** 1. Create a data-source based on the "datasource definition" vars.
**
** 2. Insert nRow key value pairs into the database.
**
** 3. Delete all keys from the database. Deletes are done in the same
** order as the inserts.
**
** During steps 2 and 3 above, after each Datatest1.nVerify inserts or
** deletes, the following:
**
** a. Run Datasource.nTest key lookups and check the results are as expected.
**
** b. If Datasource.bTestScan is true, run a handful (8) of range
** queries (scanning forwards and backwards). Check that the results
** are as expected.
**
** c. Close and reopen the database. Then run (a) and (b) again.
*/
struct Datatest1 {
/* Datasource definition */
DatasourceDefn defn;
/* Test procedure parameters */
int nRow; /* Number of rows to insert then delete */
int nVerify; /* How often to verify the db contents */
int nTest; /* Number of keys to test (0==all) */
int bTestScan; /* True to do scan tests */
};
/*
** An instance of the following data structure is used to describe the
** second type of test case in this file. The chief difference between
** these tests and those described by Datatest1 is that these tests also
** experiment with range-delete operations. Tests proceed as follows:
**
** 1. Open the datasource described by Datatest2.defn.
**
** 2. Open a connection on an empty database.
**
** 3. Do this Datatest2.nIter times:
**
** a) Insert Datatest2.nWrite key-value pairs from the datasource.
**
** b) Select two pseudo-random keys and use them as the start
** and end points of a range-delete operation.
**
** c) Verify that the contents of the database are as expected (see
** below for details).
**
** d) Close and then reopen the database handle.
**
** e) Verify that the contents of the database are still as expected.
**
** The inserts and range deletes are run twice - once on the database being
** tested and once using a control system (sqlite3, kc etc. - something that
** works). In order to verify that the contents of the db being tested are
** correct, the test runs a bunch of scans and lookups on both the test and
** control databases. If the results are the same, the test passes.
*/
struct Datatest2 {
DatasourceDefn defn;
int nRange;
int nWrite; /* Number of writes per iteration */
int nIter; /* Total number of iterations to run */
};
/*
** Generate a unique name for the test case pTest with database system
** zSystem.
*/
static char *getName(const char *zSystem, int bRecover, Datatest1 *pTest){
char *zRet;
char *zData;
zData = testDatasourceName(&pTest->defn);
zRet = testMallocPrintf("data.%s.%s.rec=%d.%d.%d",
zSystem, zData, bRecover, pTest->nRow, pTest->nVerify
);
testFree(zData);
return zRet;
}
int testControlDb(TestDb **ppDb){
#ifdef HAVE_KYOTOCABINET
return tdb_open("kyotocabinet", "tmp.db", 1, ppDb);
#else
return tdb_open("sqlite3", "", 1, ppDb);
#endif
}
void testDatasourceFetch(
TestDb *pDb, /* Database handle */
Datasource *pData,
int iKey,
int *pRc /* IN/OUT: Error code */
){
void *pKey; int nKey; /* Database key to query for */
void *pVal; int nVal; /* Expected result of query */
testDatasourceEntry(pData, iKey, &pKey, &nKey, &pVal, &nVal);
testFetch(pDb, pKey, nKey, pVal, nVal, pRc);
}
/*
** This function is called to test that the contents of database pDb
** are as expected. In this case, expected is defined as containing
** key-value pairs iFirst through iLast, inclusive, from data source
** pData. In other words, a loop like the following could be used to
** construct a database with identical contents from scratch.
**
** for(i=iFirst; i<=iLast; i++){
** testDatasourceEntry(pData, i, &pKey, &nKey, &pVal, &nVal);
** // insert (pKey, nKey) -> (pVal, nVal) into database
** }
**
** The key domain consists of keys 0 to (nRow-1), inclusive, from
** data source pData. For both scan and lookup tests, keys are selected
** pseudo-randomly from within this set.
**
** This function runs nLookupTest lookup tests and nScanTest scan tests.
**
** A lookup test consists of selecting a key from the domain and querying
** pDb for it. The test fails if the presence of the key and, if present,
** the associated value do not match the expectations defined above.
**
** A scan test involves selecting a key from the domain and running
** the following queries:
**
** 1. Scan all keys equal to or greater than the key, in ascending order.
** 2. Scan all keys equal to or smaller than the key, in descending order.
**
** Additionally, if nLookupTest is greater than zero, the following are
** run once:
**
** 1. Scan all keys in the db, in ascending order.
** 2. Scan all keys in the db, in descending order.
**
** As you would assume, the test fails if the returned values do not match
** expectations.
*/
void testDbContents(
TestDb *pDb, /* Database handle being tested */
Datasource *pData, /* pDb contains data from here */
int nRow, /* Size of key domain */
int iFirst, /* Index of first key from pData in pDb */
int iLast, /* Index of last key from pData in pDb */
int nLookupTest, /* Number of lookup tests to run */
int nScanTest, /* Number of scan tests to run */
int *pRc /* IN/OUT: Error code */
){
int j;
int rc = *pRc;
if( rc==0 && nScanTest ){
TestDb *pDb2 = 0;
/* Open a control db (i.e. one that we assume works) */
rc = testControlDb(&pDb2);
for(j=iFirst; rc==0 && j<=iLast; j++){
void *pKey; int nKey; /* Database key to insert */
void *pVal; int nVal; /* Database value to insert */
testDatasourceEntry(pData, j, &pKey, &nKey, &pVal, &nVal);
rc = tdb_write(pDb2, pKey, nKey, pVal, nVal);
}
if( rc==0 ){
int iKey1;
int iKey2;
void *pKey1; int nKey1; /* Start key */
void *pKey2; int nKey2; /* Final key */
iKey1 = testPrngValue((iFirst<<8) + (iLast<<16)) % nRow;
iKey2 = testPrngValue((iLast<<8) + (iFirst<<16)) % nRow;
testDatasourceEntry(pData, iKey1, &pKey2, &nKey1, 0, 0);
pKey1 = testMalloc(nKey1+1);
memcpy(pKey1, pKey2, nKey1+1);
testDatasourceEntry(pData, iKey2, &pKey2, &nKey2, 0, 0);
testScanCompare(pDb2, pDb, 0, 0, 0, 0, 0, &rc);
testScanCompare(pDb2, pDb, 0, 0, 0, pKey2, nKey2, &rc);
testScanCompare(pDb2, pDb, 0, pKey1, nKey1, 0, 0, &rc);
testScanCompare(pDb2, pDb, 0, pKey1, nKey1, pKey2, nKey2, &rc);
testScanCompare(pDb2, pDb, 1, 0, 0, 0, 0, &rc);
testScanCompare(pDb2, pDb, 1, 0, 0, pKey2, nKey2, &rc);
testScanCompare(pDb2, pDb, 1, pKey1, nKey1, 0, 0, &rc);
testScanCompare(pDb2, pDb, 1, pKey1, nKey1, pKey2, nKey2, &rc);
testFree(pKey1);
}
tdb_close(pDb2);
}
/* Test some lookups. */
for(j=0; rc==0 && j<nLookupTest; j++){
int iKey; /* Datasource key to test */
void *pKey; int nKey; /* Database key to query for */
void *pVal; int nVal; /* Expected result of query */
if( nLookupTest>=nRow ){
iKey = j;
}else{
iKey = testPrngValue(j + (iFirst<<8) + (iLast<<16)) % nRow;
}
testDatasourceEntry(pData, iKey, &pKey, &nKey, &pVal, &nVal);
if( iFirst>iKey || iKey>iLast ){
pVal = 0;
nVal = -1;
}
testFetch(pDb, pKey, nKey, pVal, nVal, &rc);
}
*pRc = rc;
}
/*
** This function should be called during long running test cases to output
** the progress dots (...) to stdout.
*/
void testCaseProgress(int i, int n, int nDot, int *piDot){
int iDot = *piDot;
while( iDot < ( ((nDot*2+1) * i) / (n*2) ) ){
printf(".");
fflush(stdout);
iDot++;
}
*piDot = iDot;
}
int testCaseNDot(void){ return 20; }
#if 0
static void printScanCb(
void *pCtx, void *pKey, int nKey, void *pVal, int nVal
){
printf("%s\n", (char *)pKey);
fflush(stdout);
}
#endif
void testReopenRecover(TestDb **ppDb, int *pRc){
if( *pRc==0 ){
const char *zLib = tdb_library_name(*ppDb);
const char *zDflt = tdb_default_db(zLib);
testCopyLsmdb(zDflt, "bak.db");
testClose(ppDb);
testCopyLsmdb("bak.db", zDflt);
*pRc = tdb_open(zLib, 0, 0, ppDb);
}
}
static void doDataTest1(
const char *zSystem, /* Database system to test */
int bRecover,
Datatest1 *p, /* Structure containing test parameters */
int *pRc /* OUT: Error code */
){
int i;
int iDot;
int rc = LSM_OK;
Datasource *pData;
TestDb *pDb;
/* Start the test case, open a database and allocate the datasource. */
pDb = testOpen(zSystem, 1, &rc);
pData = testDatasourceNew(&p->defn);
i = 0;
iDot = 0;
while( rc==LSM_OK && i<p->nRow ){
/* Insert some data */
testWriteDatasourceRange(pDb, pData, i, p->nVerify, &rc);
i += p->nVerify;
/* Check that the db content is correct. */
testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc);
if( bRecover ){
testReopenRecover(&pDb, &rc);
}else{
testReopen(&pDb, &rc);
}
/* Check that the db content is still correct. */
testDbContents(pDb, pData, p->nRow, 0, i-1, p->nTest, p->bTestScan, &rc);
/* Update the progress dots... */
testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot);
}
i = 0;
iDot = 0;
while( rc==LSM_OK && i<p->nRow ){
/* Delete some entries */
testDeleteDatasourceRange(pDb, pData, i, p->nVerify, &rc);
i += p->nVerify;
/* Check that the db content is correct. */
testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc);
/* Close and reopen the database. */
if( bRecover ){
testReopenRecover(&pDb, &rc);
}else{
testReopen(&pDb, &rc);
}
/* Check that the db content is still correct. */
testDbContents(pDb, pData, p->nRow, i, p->nRow-1,p->nTest,p->bTestScan,&rc);
/* Update the progress dots... */
testCaseProgress(i, p->nRow, testCaseNDot()/2, &iDot);
}
/* Free the datasource, close the database and finish the test case. */
testDatasourceFree(pData);
tdb_close(pDb);
testCaseFinish(rc);
*pRc = rc;
}
void test_data_1(
const char *zSystem, /* Database system name */
const char *zPattern, /* Run test cases that match this pattern */
int *pRc /* IN/OUT: Error code */
){
Datatest1 aTest[] = {
{ {DATA_RANDOM, 500,600, 1000,2000}, 1000, 100, 10, 0},
{ {DATA_RANDOM, 20,25, 100,200}, 1000, 250, 1000, 1},
{ {DATA_RANDOM, 8,10, 100,200}, 1000, 250, 1000, 1},
{ {DATA_RANDOM, 8,10, 10,20}, 1000, 250, 1000, 1},
{ {DATA_RANDOM, 8,10, 1000,2000}, 1000, 250, 1000, 1},
{ {DATA_RANDOM, 8,100, 10000,20000}, 100, 25, 100, 1},
{ {DATA_RANDOM, 80,100, 10,20}, 1000, 250, 1000, 1},
{ {DATA_RANDOM, 5000,6000, 10,20}, 100, 25, 100, 1},
{ {DATA_SEQUENTIAL, 5,10, 10,20}, 1000, 250, 1000, 1},
{ {DATA_SEQUENTIAL, 5,10, 100,200}, 1000, 250, 1000, 1},
{ {DATA_SEQUENTIAL, 5,10, 1000,2000}, 1000, 250, 1000, 1},
{ {DATA_SEQUENTIAL, 5,100, 10000,20000}, 100, 25, 100, 1},
{ {DATA_RANDOM, 10,10, 100,100}, 100000, 1000, 100, 0},
{ {DATA_SEQUENTIAL, 10,10, 100,100}, 100000, 1000, 100, 0},
};
int i;
int bRecover;
for(bRecover=0; bRecover<2; bRecover++){
if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break;
for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
char *zName = getName(zSystem, bRecover, &aTest[i]);
if( testCaseBegin(pRc, zPattern, "%s", zName) ){
doDataTest1(zSystem, bRecover, &aTest[i], pRc);
}
testFree(zName);
}
}
}
void testCompareDb(
Datasource *pData,
int nData,
int iSeed,
TestDb *pControl,
TestDb *pDb,
int *pRc
){
int i;
static int nCall = 0;
nCall++;
testScanCompare(pControl, pDb, 0, 0, 0, 0, 0, pRc);
testScanCompare(pControl, pDb, 1, 0, 0, 0, 0, pRc);
if( *pRc==0 ){
int iKey1;
int iKey2;
void *pKey1; int nKey1; /* Start key */
void *pKey2; int nKey2; /* Final key */
iKey1 = testPrngValue(iSeed) % nData;
iKey2 = testPrngValue(iSeed+1) % nData;
testDatasourceEntry(pData, iKey1, &pKey2, &nKey1, 0, 0);
pKey1 = testMalloc(nKey1+1);
memcpy(pKey1, pKey2, nKey1+1);
testDatasourceEntry(pData, iKey2, &pKey2, &nKey2, 0, 0);
testScanCompare(pControl, pDb, 0, 0, 0, pKey2, nKey2, pRc);
testScanCompare(pControl, pDb, 0, pKey1, nKey1, 0, 0, pRc);
testScanCompare(pControl, pDb, 0, pKey1, nKey1, pKey2, nKey2, pRc);
testScanCompare(pControl, pDb, 1, 0, 0, pKey2, nKey2, pRc);
testScanCompare(pControl, pDb, 1, pKey1, nKey1, 0, 0, pRc);
testScanCompare(pControl, pDb, 1, pKey1, nKey1, pKey2, nKey2, pRc);
testFree(pKey1);
}
for(i=0; i<nData && *pRc==0; i++){
void *pKey; int nKey;
testDatasourceEntry(pData, i, &pKey, &nKey, 0, 0);
testFetchCompare(pControl, pDb, pKey, nKey, pRc);
}
}
static void doDataTest2(
const char *zSystem, /* Database system to test */
int bRecover,
Datatest2 *p, /* Structure containing test parameters */
int *pRc /* OUT: Error code */
){
TestDb *pDb;
TestDb *pControl;
Datasource *pData;
int i;
int rc = LSM_OK;
int iDot = 0;
/* Start the test case, open a database and allocate the datasource. */
pDb = testOpen(zSystem, 1, &rc);
pData = testDatasourceNew(&p->defn);
rc = testControlDb(&pControl);
if( tdb_lsm(pDb) ){
int nBuf = 32 * 1024 * 1024;
lsm_config(tdb_lsm(pDb), LSM_CONFIG_AUTOFLUSH, &nBuf);
}
for(i=0; rc==0 && i<p->nIter; i++){
void *pKey1; int nKey1;
void *pKey2; int nKey2;
int ii;
int nRange = MIN(p->nIter*p->nWrite, p->nRange);
for(ii=0; rc==0 && ii<p->nWrite; ii++){
int iKey = (i*p->nWrite + ii) % p->nRange;
testWriteDatasource(pControl, pData, iKey, &rc);
testWriteDatasource(pDb, pData, iKey, &rc);
}
testDatasourceEntry(pData, i+1000000, &pKey1, &nKey1, 0, 0);
pKey1 = testMallocCopy(pKey1, nKey1);
testDatasourceEntry(pData, i+2000000, &pKey2, &nKey2, 0, 0);
testDeleteRange(pDb, pKey1, nKey1, pKey2, nKey2, &rc);
testDeleteRange(pControl, pKey1, nKey1, pKey2, nKey2, &rc);
testFree(pKey1);
testCompareDb(pData, nRange, i, pControl, pDb, &rc);
if( bRecover ){
testReopenRecover(&pDb, &rc);
}else{
testReopen(&pDb, &rc);
}
testCompareDb(pData, nRange, i, pControl, pDb, &rc);
/* Update the progress dots... */
testCaseProgress(i, p->nIter, testCaseNDot(), &iDot);
}
testClose(&pDb);
testClose(&pControl);
testDatasourceFree(pData);
testCaseFinish(rc);
*pRc = rc;
}
static char *getName2(const char *zSystem, int bRecover, Datatest2 *pTest){
char *zRet;
char *zData;
zData = testDatasourceName(&pTest->defn);
zRet = testMallocPrintf("data2.%s.%s.rec=%d.%d.%d.%d",
zSystem, zData, bRecover, pTest->nRange, pTest->nWrite, pTest->nIter
);
testFree(zData);
return zRet;
}
void test_data_2(
const char *zSystem, /* Database system name */
const char *zPattern, /* Run test cases that match this pattern */
int *pRc /* IN/OUT: Error code */
){
Datatest2 aTest[] = {
/* defn, nRange, nWrite, nIter */
{ {DATA_RANDOM, 20,25, 100,200}, 10000, 10, 50 },
{ {DATA_RANDOM, 20,25, 100,200}, 10000, 200, 50 },
{ {DATA_RANDOM, 20,25, 100,200}, 100, 10, 1000 },
{ {DATA_RANDOM, 20,25, 100,200}, 100, 200, 50 },
};
int i;
int bRecover;
for(bRecover=0; bRecover<2; bRecover++){
if( bRecover==1 && memcmp(zSystem, "lsm", 3) ) break;
for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
char *zName = getName2(zSystem, bRecover, &aTest[i]);
if( testCaseBegin(pRc, zPattern, "%s", zName) ){
doDataTest2(zSystem, bRecover, &aTest[i], pRc);
}
testFree(zName);
}
}
}
/*************************************************************************
** Test case data3.*
*/
typedef struct Datatest3 Datatest3;
struct Datatest3 {
int nRange; /* Keys are between 1 and this value, incl. */
int nIter; /* Number of iterations */
int nWrite; /* Number of writes per iteration */
int nDelete; /* Number of deletes per iteration */
int nValMin; /* Minimum value size for writes */
int nValMax; /* Maximum value size for writes */
};
void testPutU32(u8 *aBuf, u32 iVal){
aBuf[0] = (iVal >> 24) & 0xFF;
aBuf[1] = (iVal >> 16) & 0xFF;
aBuf[2] = (iVal >> 8) & 0xFF;
aBuf[3] = (iVal >> 0) & 0xFF;
}
void dt3PutKey(u8 *aBuf, int iKey){
assert( iKey<100000 && iKey>=0 );
sprintf((char *)aBuf, "%.5d", iKey);
}
static void doDataTest3(
const char *zSystem, /* Database system to test */
Datatest3 *p, /* Structure containing test parameters */
int *pRc /* OUT: Error code */
){
int iDot = 0;
int rc = *pRc;
TestDb *pDb;
u8 *abPresent; /* Array of boolean */
char *aVal; /* Buffer to hold values */
int i;
u32 iSeq = 10; /* prng counter */
abPresent = (u8 *)testMalloc(p->nRange+1);
aVal = (char *)testMalloc(p->nValMax+1);
pDb = testOpen(zSystem, 1, &rc);
for(i=0; i<p->nIter && rc==0; i++){
int ii;
testCaseProgress(i, p->nIter, testCaseNDot(), &iDot);
/* Perform nWrite inserts */
for(ii=0; ii<p->nWrite; ii++){
u8 aKey[6];
u32 iKey;
int nVal;
iKey = (testPrngValue(iSeq++) % p->nRange) + 1;
nVal = (testPrngValue(iSeq++) % (p->nValMax - p->nValMin)) + p->nValMin;
testPrngString(testPrngValue(iSeq++), aVal, nVal);
dt3PutKey(aKey, iKey);
testWrite(pDb, aKey, sizeof(aKey)-1, aVal, nVal, &rc);
abPresent[iKey] = 1;
}
/* Perform nDelete deletes */
for(ii=0; ii<p->nDelete; ii++){
u8 aKey1[6];
u8 aKey2[6];
u32 iKey;
iKey = (testPrngValue(iSeq++) % p->nRange) + 1;
dt3PutKey(aKey1, iKey-1);
dt3PutKey(aKey2, iKey+1);
testDeleteRange(pDb, aKey1, sizeof(aKey1)-1, aKey2, sizeof(aKey2)-1, &rc);
abPresent[iKey] = 0;
}
testReopen(&pDb, &rc);
for(ii=1; rc==0 && ii<=p->nRange; ii++){
int nDbVal;
void *pDbVal;
u8 aKey[6];
int dbrc;
dt3PutKey(aKey, ii);
dbrc = tdb_fetch(pDb, aKey, sizeof(aKey)-1, &pDbVal, &nDbVal);
testCompareInt(0, dbrc, &rc);
if( abPresent[ii] ){
testCompareInt(1, (nDbVal>0), &rc);
}else{
testCompareInt(1, (nDbVal<0), &rc);
}
}
}
testClose(&pDb);
testCaseFinish(rc);
*pRc = rc;
}
static char *getName3(const char *zSystem, Datatest3 *p){
return testMallocPrintf("data3.%s.%d.%d.%d.%d.(%d..%d)",
zSystem, p->nRange, p->nIter, p->nWrite, p->nDelete,
p->nValMin, p->nValMax
);
}
void test_data_3(
const char *zSystem, /* Database system name */
const char *zPattern, /* Run test cases that match this pattern */
int *pRc /* IN/OUT: Error code */
){
Datatest3 aTest[] = {
/* nRange, nIter, nWrite, nDelete, nValMin, nValMax */
{ 100, 1000, 5, 5, 50, 100 },
{ 100, 1000, 2, 2, 5, 10 },
};
int i;
for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
char *zName = getName3(zSystem, &aTest[i]);
if( testCaseBegin(pRc, zPattern, "%s", zName) ){
doDataTest3(zSystem, &aTest[i], pRc);
}
testFree(zName);
}
}
+488
View File
@@ -0,0 +1,488 @@
/*
** This file contains tests related to recovery following application
** and system crashes (power failures) while writing to the database.
*/
#include "lsmtest.h"
/*
** Structure used by testCksumDatabase() to accumulate checksum values in.
*/
typedef struct Cksum Cksum;
struct Cksum {
int nRow;
int cksum1;
int cksum2;
};
/*
** tdb_scan() callback used by testCksumDatabase()
*/
static void scanCksumDb(
void *pCtx,
void *pKey, int nKey,
void *pVal, int nVal
){
Cksum *p = (Cksum *)pCtx;
int i;
p->nRow++;
for(i=0; i<nKey; i++){
p->cksum1 += ((u8 *)pKey)[i];
p->cksum2 += p->cksum1;
}
for(i=0; i<nVal; i++){
p->cksum1 += ((u8 *)pVal)[i];
p->cksum2 += p->cksum1;
}
}
/*
** tdb_scan() callback used by testCountDatabase()
*/
static void scanCountDb(
void *pCtx,
void *pKey, int nKey,
void *pVal, int nVal
){
Cksum *p = (Cksum *)pCtx;
p->nRow++;
unused_parameter(pKey);
unused_parameter(nKey);
unused_parameter(pVal);
unused_parameter(nVal);
}
/*
** Iterate through the entire contents of database pDb. Write a checksum
** string based on the db contents into buffer zOut before returning. A
** checksum string is at most 29 (TEST_CKSUM_BYTES) bytes in size:
**
** * 32-bit integer (10 bytes)
** * 1 space (1 byte)
** * 32-bit hex (8 bytes)
** * 1 space (1 byte)
** * 32-bit hex (8 bytes)
** * nul-terminator (1 byte)
**
** The number of entries in the database is returned.
*/
int testCksumDatabase(
TestDb *pDb, /* Database handle */
char *zOut /* Buffer to write checksum to */
){
Cksum cksum;
memset(&cksum, 0, sizeof(Cksum));
tdb_scan(pDb, (void *)&cksum, 0, 0, 0, 0, 0, scanCksumDb);
sprintf(zOut, "%d %x %x",
cksum.nRow, (u32)cksum.cksum1, (u32)cksum.cksum2
);
assert( strlen(zOut)<TEST_CKSUM_BYTES );
return cksum.nRow;
}
int testCountDatabase(TestDb *pDb){
Cksum cksum;
memset(&cksum, 0, sizeof(Cksum));
tdb_scan(pDb, (void *)&cksum, 0, 0, 0, 0, 0, scanCountDb);
return cksum.nRow;
}
/*
** This function is a no-op if *pRc is not 0 when it is called.
**
** Otherwise, the two nul-terminated strings z1 and z1 are compared. If
** they are the same, the function returns without doing anything. Otherwise,
** an error message is printed, *pRc is set to 1 and the test_failed()
** function called.
*/
void testCompareStr(const char *z1, const char *z2, int *pRc){
if( *pRc==0 ){
if( strcmp(z1, z2) ){
testPrintError("testCompareStr: \"%s\" != \"%s\"\n", z1, z2);
*pRc = 1;
test_failed();
}
}
}
/*
** This function is a no-op if *pRc is not 0 when it is called.
**
** Otherwise, the two integers i1 and i2 are compared. If they are equal,
** the function returns without doing anything. Otherwise, an error message
** is printed, *pRc is set to 1 and the test_failed() function called.
*/
void testCompareInt(int i1, int i2, int *pRc){
if( *pRc==0 && i1!=i2 ){
testPrintError("testCompareInt: %d != %d\n", i1, i2);
*pRc = 1;
test_failed();
}
}
void testCaseStart(int *pRc, char *zFmt, ...){
va_list ap;
va_start(ap, zFmt);
vprintf(zFmt, ap);
printf(" ...");
va_end(ap);
*pRc = 0;
fflush(stdout);
}
/*
** This function is a no-op if *pRc is non-zero when it is called. Zero
** is returned in this case.
**
** Otherwise, the zFmt (a printf style format string) and following arguments
** are used to create a test case name. If zPattern is NULL or a glob pattern
** that matches the test case name, 1 is returned and the test case started.
** Otherwise, zero is returned and the test case does not start.
*/
int testCaseBegin(int *pRc, const char *zPattern, const char *zFmt, ...){
int res = 0;
if( *pRc==0 ){
char *zTest;
va_list ap;
va_start(ap, zFmt);
zTest = testMallocVPrintf(zFmt, ap);
va_end(ap);
if( zPattern==0 || testGlobMatch(zPattern, zTest) ){
printf("%-50s ...", zTest);
res = 1;
}
testFree(zTest);
fflush(stdout);
}
return res;
}
void testCaseFinish(int rc){
if( rc==0 ){
printf("Ok\n");
}else{
printf("FAILED\n");
}
fflush(stdout);
}
void testCaseSkip(){
printf("Skipped\n");
}
void testSetupSavedLsmdb(
const char *zCfg,
const char *zFile,
Datasource *pData,
int nRow,
int *pRc
){
if( *pRc==0 ){
int rc;
TestDb *pDb;
rc = tdb_lsm_open(zCfg, zFile, 1, &pDb);
if( rc==0 ){
testWriteDatasourceRange(pDb, pData, 0, nRow, &rc);
testClose(&pDb);
if( rc==0 ) testSaveDb(zFile, "log");
}
*pRc = rc;
}
}
/*
** This function is a no-op if *pRc is non-zero when it is called.
**
** Open the LSM database identified by zFile and compute its checksum
** (a string, as returned by testCksumDatabase()). If the checksum is
** identical to zExpect1 or, if it is not NULL, zExpect2, the test passes.
** Otherwise, print an error message and set *pRc to 1.
*/
static void testCompareCksumLsmdb(
const char *zFile, /* Path to LSM database */
int bCompress, /* True if db is compressed */
const char *zExpect1, /* Expected checksum 1 */
const char *zExpect2, /* Expected checksum 2 (or NULL) */
int *pRc /* IN/OUT: Test case error code */
){
if( *pRc==0 ){
char zCksum[TEST_CKSUM_BYTES];
TestDb *pDb;
*pRc = tdb_lsm_open((bCompress?"compression=1 mmap=0":""), zFile, 0, &pDb);
testCksumDatabase(pDb, zCksum);
testClose(&pDb);
if( *pRc==0 ){
int r1 = 0;
int r2 = -1;
r1 = strcmp(zCksum, zExpect1);
if( zExpect2 ) r2 = strcmp(zCksum, zExpect2);
if( r1 && r2 ){
if( zExpect2 ){
testPrintError("testCompareCksumLsmdb: \"%s\" != (\"%s\" OR \"%s\")",
zCksum, zExpect1, zExpect2
);
}else{
testPrintError("testCompareCksumLsmdb: \"%s\" != \"%s\"",
zCksum, zExpect1
);
}
*pRc = 1;
test_failed();
}
}
}
}
#if 0 /* not used */
static void testCompareCksumBtdb(
const char *zFile, /* Path to LSM database */
const char *zExpect1, /* Expected checksum 1 */
const char *zExpect2, /* Expected checksum 2 (or NULL) */
int *pRc /* IN/OUT: Test case error code */
){
if( *pRc==0 ){
char zCksum[TEST_CKSUM_BYTES];
TestDb *pDb;
*pRc = tdb_open("bt", zFile, 0, &pDb);
testCksumDatabase(pDb, zCksum);
testClose(&pDb);
if( *pRc==0 ){
int r1 = 0;
int r2 = -1;
r1 = strcmp(zCksum, zExpect1);
if( zExpect2 ) r2 = strcmp(zCksum, zExpect2);
if( r1 && r2 ){
if( zExpect2 ){
testPrintError("testCompareCksumLsmdb: \"%s\" != (\"%s\" OR \"%s\")",
zCksum, zExpect1, zExpect2
);
}else{
testPrintError("testCompareCksumLsmdb: \"%s\" != \"%s\"",
zCksum, zExpect1
);
}
*pRc = 1;
test_failed();
}
}
}
}
#endif /* not used */
/* Above this point are reusable test routines. Not clear that they
** should really be in this file.
*************************************************************************/
/*
** This test verifies that if a system crash occurs while doing merge work
** on the db, no data is lost.
*/
static void crash_test1(int bCompress, int *pRc){
const char *DBNAME = "testdb.lsm";
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 200, 200};
const int nRow = 5000; /* Database size */
const int nIter = 200; /* Number of test iterations */
const int nWork = 20; /* Maximum lsm_work() calls per iteration */
const int nPage = 15; /* Pages per lsm_work call */
int i;
int iDot = 0;
Datasource *pData;
CksumDb *pCksumDb;
TestDb *pDb;
char *zCfg;
const char *azConfig[2] = {
"page_size=1024 block_size=65536 autoflush=16384 safety=2 mmap=0",
"page_size=1024 block_size=65536 autoflush=16384 safety=2 "
" compression=1 mmap=0"
};
assert( bCompress==0 || bCompress==1 );
/* Allocate datasource. And calculate the expected checksums. */
pData = testDatasourceNew(&defn);
pCksumDb = testCksumArrayNew(pData, nRow, nRow, 1);
/* Setup and save the initial database. */
zCfg = testMallocPrintf("%s automerge=7", azConfig[bCompress]);
testSetupSavedLsmdb(zCfg, DBNAME, pData, 5000, pRc);
testFree(zCfg);
for(i=0; i<nIter && *pRc==0; i++){
int iWork;
int testrc = 0;
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
/* Restore and open the database. */
testRestoreDb(DBNAME, "log");
testrc = tdb_lsm_open(azConfig[bCompress], DBNAME, 0, &pDb);
assert( testrc==0 );
/* Call lsm_work() on the db */
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%(nWork*2)));
for(iWork=0; testrc==0 && iWork<nWork; iWork++){
int nWrite = 0;
lsm_db *db = tdb_lsm(pDb);
testrc = lsm_work(db, 0, nPage, &nWrite);
/* assert( testrc!=0 || nWrite>0 ); */
if( testrc==0 ) testrc = lsm_checkpoint(db, 0);
}
tdb_close(pDb);
/* Check that the database content is still correct */
testCompareCksumLsmdb(DBNAME,
bCompress, testCksumArrayGet(pCksumDb, nRow), 0, pRc);
}
testCksumArrayFree(pCksumDb);
testDatasourceFree(pData);
}
/*
** This test verifies that if a system crash occurs while committing a
** transaction to the log file, no earlier transactions are lost or damaged.
*/
static void crash_test2(int bCompress, int *pRc){
const char *DBNAME = "testdb.lsm";
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 1000, 1000};
const int nIter = 200;
const int nInsert = 20;
int i;
int iDot = 0;
Datasource *pData;
CksumDb *pCksumDb;
TestDb *pDb;
/* Allocate datasource. And calculate the expected checksums. */
pData = testDatasourceNew(&defn);
pCksumDb = testCksumArrayNew(pData, 100, 100+nInsert, 1);
/* Setup and save the initial database. */
testSetupSavedLsmdb("", DBNAME, pData, 100, pRc);
for(i=0; i<nIter && *pRc==0; i++){
int iIns;
int testrc = 0;
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
/* Restore and open the database. */
testRestoreDb(DBNAME, "log");
testrc = tdb_lsm_open("safety=2", DBNAME, 0, &pDb);
assert( testrc==0 );
/* Insert nInsert records into the database. Crash midway through. */
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%(nInsert+2)));
for(iIns=0; iIns<nInsert; iIns++){
void *pKey; int nKey;
void *pVal; int nVal;
testDatasourceEntry(pData, 100+iIns, &pKey, &nKey, &pVal, &nVal);
testrc = tdb_write(pDb, pKey, nKey, pVal, nVal);
if( testrc ) break;
}
tdb_close(pDb);
/* Check that no data was lost when the system crashed. */
testCompareCksumLsmdb(DBNAME, bCompress,
testCksumArrayGet(pCksumDb, 100 + iIns),
testCksumArrayGet(pCksumDb, 100 + iIns + 1),
pRc
);
}
testDatasourceFree(pData);
testCksumArrayFree(pCksumDb);
}
/*
** This test verifies that if a system crash occurs when checkpointing
** the database, data is not lost (assuming that any writes not synced
** to the db have been synced into the log file).
*/
static void crash_test3(int bCompress, int *pRc){
const char *DBNAME = "testdb.lsm";
const int nIter = 100;
const DatasourceDefn defn = {TEST_DATASOURCE_RANDOM, 12, 16, 1000, 1000};
int i;
int iDot = 0;
Datasource *pData;
CksumDb *pCksumDb;
TestDb *pDb;
/* Allocate datasource. And calculate the expected checksums. */
pData = testDatasourceNew(&defn);
pCksumDb = testCksumArrayNew(pData, 110, 150, 10);
/* Setup and save the initial database. */
testSetupSavedLsmdb("", DBNAME, pData, 100, pRc);
for(i=0; i<nIter && *pRc==0; i++){
int iOpen;
testCaseProgress(i, nIter, testCaseNDot(), &iDot);
testRestoreDb(DBNAME, "log");
for(iOpen=0; iOpen<5; iOpen++){
/* Open the database. Insert 10 more records. */
pDb = testOpen("lsm", 0, pRc);
testWriteDatasourceRange(pDb, pData, 100+iOpen*10, 10, pRc);
/* Schedule a crash simulation then close the db. */
tdb_lsm_prepare_sync_crash(pDb, 1 + (i%2));
tdb_close(pDb);
/* Open the database and check that the crash did not cause any
** data loss. */
testCompareCksumLsmdb(DBNAME, bCompress,
testCksumArrayGet(pCksumDb, 110 + iOpen*10), 0,
pRc
);
}
}
testDatasourceFree(pData);
testCksumArrayFree(pCksumDb);
}
void do_crash_test(const char *zPattern, int *pRc){
struct Test {
const char *zTest;
void (*x)(int, int *);
int bCompress;
} aTest [] = {
{ "crash.lsm.1", crash_test1, 0 },
#ifdef HAVE_ZLIB
{ "crash.lsm_zip.1", crash_test1, 1 },
#endif
{ "crash.lsm.2", crash_test2, 0 },
{ "crash.lsm.3", crash_test3, 0 },
};
int i;
for(i=0; *pRc==LSM_OK && i<ArraySize(aTest); i++){
struct Test *p = &aTest[i];
if( testCaseBegin(pRc, zPattern, "%s", p->zTest) ){
p->x(p->bCompress, pRc);
testCaseFinish(*pRc);
}
}
}
+238
View File
@@ -0,0 +1,238 @@
/*
** This file contains tests related to the explicit rollback of database
** transactions and sub-transactions.
*/
/*
** Repeat 2000 times (until the db contains 100,000 entries):
**
** 1. Open a transaction and insert 500 rows, opening a nested
** sub-transaction each 100 rows.
**
** 2. Roll back to each sub-transaction savepoint. Check the database
** checksum looks Ok.
**
** 3. Every second iteration, roll back the main transaction. Check the
** db checksum is correct. Every other iteration, commit the main
** transaction (increasing the size of the db by 100 rows).
*/
#include "lsmtest.h"
struct CksumDb {
int nFirst;
int nLast;
int nStep;
char **azCksum;
};
CksumDb *testCksumArrayNew(
Datasource *pData,
int nFirst,
int nLast,
int nStep
){
TestDb *pDb;
CksumDb *pRet;
int i;
int nEntry;
int rc = 0;
assert( nLast>=nFirst && ((nLast-nFirst)%nStep)==0 );
pRet = malloc(sizeof(CksumDb));
memset(pRet, 0, sizeof(CksumDb));
pRet->nFirst = nFirst;
pRet->nLast = nLast;
pRet->nStep = nStep;
nEntry = 1 + ((nLast - nFirst) / nStep);
/* Allocate space so that azCksum is an array of nEntry pointers to
** buffers each TEST_CKSUM_BYTES in size. */
pRet->azCksum = (char **)malloc(nEntry * (sizeof(char *) + TEST_CKSUM_BYTES));
for(i=0; i<nEntry; i++){
char *pStart = (char *)(&pRet->azCksum[nEntry]);
pRet->azCksum[i] = &pStart[i * TEST_CKSUM_BYTES];
}
tdb_open("lsm", "tempdb.lsm", 1, &pDb);
testWriteDatasourceRange(pDb, pData, 0, nFirst, &rc);
for(i=0; i<nEntry; i++){
testCksumDatabase(pDb, pRet->azCksum[i]);
if( i==nEntry ) break;
testWriteDatasourceRange(pDb, pData, nFirst+i*nStep, nStep, &rc);
}
tdb_close(pDb);
return pRet;
}
char *testCksumArrayGet(CksumDb *p, int nRow){
int i;
assert( nRow>=p->nFirst );
assert( nRow<=p->nLast );
assert( ((nRow-p->nFirst) % p->nStep)==0 );
i = (nRow - p->nFirst) / p->nStep;
return p->azCksum[i];
}
void testCksumArrayFree(CksumDb *p){
free(p->azCksum);
memset(p, 0x55, sizeof(*p));
free(p);
}
/* End of CksumDb code.
**************************************************************************/
/*
** Test utility function. Write key-value pair $i from datasource pData
** into database pDb.
*/
void testWriteDatasource(TestDb *pDb, Datasource *pData, int i, int *pRc){
void *pKey; int nKey;
void *pVal; int nVal;
testDatasourceEntry(pData, i, &pKey, &nKey, &pVal, &nVal);
testWrite(pDb, pKey, nKey, pVal, nVal, pRc);
}
/*
** Test utility function. Delete datasource pData key $i from database pDb.
*/
void testDeleteDatasource(TestDb *pDb, Datasource *pData, int i, int *pRc){
void *pKey; int nKey;
testDatasourceEntry(pData, i, &pKey, &nKey, 0, 0);
testDelete(pDb, pKey, nKey, pRc);
}
/*
** This function inserts nWrite key/value pairs into database pDb - the
** nWrite key value pairs starting at iFirst from data source pData.
*/
void testWriteDatasourceRange(
TestDb *pDb, /* Database to write to */
Datasource *pData, /* Data source to read values from */
int iFirst, /* Index of first key/value pair */
int nWrite, /* Number of key/value pairs to write */
int *pRc /* IN/OUT: Error code */
){
int i;
for(i=0; i<nWrite; i++){
testWriteDatasource(pDb, pData, iFirst+i, pRc);
}
}
void testDeleteDatasourceRange(
TestDb *pDb, /* Database to write to */
Datasource *pData, /* Data source to read keys from */
int iFirst, /* Index of first key */
int nWrite, /* Number of keys to delete */
int *pRc /* IN/OUT: Error code */
){
int i;
for(i=0; i<nWrite; i++){
testDeleteDatasource(pDb, pData, iFirst+i, pRc);
}
}
static char *getName(const char *zSystem){
char *zRet;
zRet = testMallocPrintf("rollback.%s", zSystem);
return zRet;
}
static int rollback_test_1(
const char *zSystem,
Datasource *pData
){
const int nRepeat = 100;
TestDb *pDb;
int rc;
int i;
CksumDb *pCksum;
char *zName;
zName = getName(zSystem);
testCaseStart(&rc, zName);
testFree(zName);
pCksum = testCksumArrayNew(pData, 0, nRepeat*100, 100);
pDb = 0;
rc = tdb_open(zSystem, 0, 1, &pDb);
if( pDb && tdb_transaction_support(pDb)==0 ){
testCaseSkip();
goto skip_rollback_test;
}
for(i=0; i<nRepeat && rc==0; i++){
char zCksum[TEST_CKSUM_BYTES];
int nCurrent = (((i+1)/2) * 100);
int nDbRow;
int iTrans;
/* Check that the database is the expected size. */
nDbRow = testCountDatabase(pDb);
testCompareInt(nCurrent, nDbRow, &rc);
for(iTrans=2; iTrans<=6 && rc==0; iTrans++){
tdb_begin(pDb, iTrans);
testWriteDatasourceRange(pDb, pData, nCurrent, 100, &rc);
nCurrent += 100;
}
testCksumDatabase(pDb, zCksum);
testCompareStr(zCksum, testCksumArrayGet(pCksum, nCurrent), &rc);
for(iTrans=6; iTrans>2 && rc==0; iTrans--){
tdb_rollback(pDb, iTrans);
nCurrent -= 100;
testCksumDatabase(pDb, zCksum);
testCompareStr(zCksum, testCksumArrayGet(pCksum, nCurrent), &rc);
}
if( i%2 ){
tdb_rollback(pDb, 0);
nCurrent -= 100;
testCksumDatabase(pDb, zCksum);
testCompareStr(zCksum, testCksumArrayGet(pCksum, nCurrent), &rc);
}else{
tdb_commit(pDb, 0);
}
}
testCaseFinish(rc);
skip_rollback_test:
tdb_close(pDb);
testCksumArrayFree(pCksum);
return rc;
}
void test_rollback(
const char *zSystem,
const char *zPattern,
int *pRc
){
if( *pRc==0 ){
int bRun = 1;
if( zPattern ){
char *zName = getName(zSystem);
bRun = testGlobMatch(zPattern, zName);
testFree(zName);
}
if( bRun ){
DatasourceDefn defn = { TEST_DATASOURCE_RANDOM, 10, 15, 50, 100 };
Datasource *pData = testDatasourceNew(&defn);
*pRc = rollback_test_1(zSystem, pData);
testDatasourceFree(pData);
}
}
}

Some files were not shown because too many files have changed in this diff Show More