Optimizations to the logic that converts main table accesses into equivalent

index accesses. Code is now slightly smaller and faster than trunk. FossilOrigin-Name: 611b640442025e57b8e161f8ddac1f19bd3be9a3d5266f4cef287595c3ed9257
For UPDATE and DELETE, use OP_DeferredSeek always. If the seek must later
2020-08-14 21:32:16 +00:00 · 2020-08-14 20:04:26 +00:00 · 2020-08-14 17:39:31 +00:00
69 changed files with 325 additions and 3558 deletions
@@ -418,7 +418,6 @@ TESTSRC = \
  $(TOP)/src/test_quota.c \
  $(TOP)/src/test_rtree.c \
  $(TOP)/src/test_schema.c \
-  $(TOP)/src/test_schemapool.c \
  $(TOP)/src/test_server.c \
  $(TOP)/src/test_superlock.c \
  $(TOP)/src/test_syscall.c \
@@ -476,7 +475,6 @@ TESTSRC2 = \
  $(TOP)/src/bitvec.c \
  $(TOP)/src/btree.c \
  $(TOP)/src/build.c \
-  $(TOP)/src/callback.c \
  $(TOP)/src/ctime.c \
  $(TOP)/src/date.c \
  $(TOP)/src/dbpage.c \
@@ -1535,7 +1535,6 @@ TESTSRC = \
  $(TOP)\src\test_quota.c \
  $(TOP)\src\test_rtree.c \
  $(TOP)\src\test_schema.c \
-  $(TOP)\src\test_schemapool.c \
  $(TOP)\src\test_server.c \
  $(TOP)\src\test_superlock.c \
  $(TOP)\src\test_syscall.c \
@@ -1,142 +0,0 @@
-
-Shared-Schema Mode Notes
-========================
-
-The [reuse-schema](/timeline?r=reuse-schema) branch contains changes 
-to allow SQLite connections to share schemas
-between database connections within the same process in order to save memory.
-Schemas may be shared between multiple databases attached to the same or
-distinct connection handles.
-
-Compile with -DSQLITE\_ENABLE\_SHARED\_SCHEMA in order to enable the
-shared-schema enhancement.  Enabling the shared-schema enhancement causes
-approximately a 0.1% increase in CPU cycles consumed and about a 3000-byte
-increase in the size of the library, even if shared-schema is never used.
-
-Assuming the compile-time requirements are satisfied, the shared-schema
-feature is engaged by opening the database connection using the
-sqlite3&#95;open&#95;v2() API with the SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA
-flag specified.  The main database and any attached databases will then share
-an in-memory Schema object with any other database opened within the process
-for which: 
-
-  * the contents of the sqlite&#95;master table, including all object names,
-    SQL statements and root pages are identical, and
-  * have the same values for the schema-cookie.
-
-Temp databases (those populated with "CREATE TEMP TABLE" and similar
-statements) never share schemas.
-
-Connections opened with the SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA flag
-specified may not modify any database schema except that belonging to the
-temp database in anyway. This includes creating or dropping database 
-objects, vacuuming the database, or running ANALYZE when the
-sqlite&#95;stat\[14\] tables do not exist.
-
-For SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections, the
-SQLITE&#95;DBSTATUS&#95;SCHEMA&#95;USED sqlite3&#95;db&#95;status() verb
-distributes the memory used for a shared schema object evenly between all
-database connections that share it.
-
-## The ".shared-schema" Command
-
-The shell tool on this branch contains a special dot-command to help with
-managing databases. The ".shared-schema" dot-command can be used to test
-whether or not two databases are similar enough to share in-memory schemas,
-and to fix minor problems that prevent them from doing so. To test if
-two or more database are compatible, one database is opened directly using 
-the shell tool and the following command issued:
-
-        .shared-schema check <database-1> [<database-2>]...
-
-where &lt;database-1&gt; etc. are replaced with the names of database files
-on disk. For each database specified on the command line, a single line of
-output is produced. If the database can share an in-memory schema with the
-main database opened by the shell tool, the output is of the form:
-
-        <database> is compatible
-
-Otherwise, if the database cannot share a schema with the main db, the output
-is of the form:
-
-        <database> is NOT compatible (<reason>)
-
-where &lt;reason&gt; indicates the cause of the incompatibility. &lt;reason&gt;
-is always one of the following.
-
-<ul>
-  <li> <b>objects</b> - the databases contain a different set schema objects
-  (tables, indexes, views and triggers).
-
-  <li> <b>SQL</b> - the databases contain the same set of objects, but the SQL
-  statements used to create them were not the same.
-
-  <li> <b>root pages</b> - the databases contain the same set of objects created
-  by the same SQL statements, but the root pages are not the same.
-
-  <li> <b>order of sqlite&#95;master rows</b> - the databases contain the same
-  set of objects created by the same SQL statements with the same root pages,
-  but the order of the rows in the sqlite&#95;master tables are different.
-
-  <li> <b>schema cookie</b> - the database schemas are compatible, but the 
-  schema cookie values ("PRAGMA schema&#95;version") are different.
-</ul>
-
-The final three problems in the list above can be fixed using the
-.shared-schema command. To modify such a database so that it can share a 
-schema with the main database, the following shell command is used:
-
-        .shared-schema fix <database-1> [<database-2>]...
-
-If a database can be modified so that it may share a schema with the main
-database opened by the shell tool, output is as follows:
-
-        Fixing <database>... <database> is compatible
-
-If a database does not require modification, or cannot be modified such that
-it can share a schema with the main database, the output of "fix" is identical
-to that of the "check" command.
-
-## Implementation Notes
-
-A single Schema object is never used by more than one database simultaneously,
-regardless of whether or not those databases are attached to the same or
-different database handles. Instead, a pool of schema objects is maintained 
-for each unique sqlite&#95;master-contents/schema-cookie combination
-opened within the process. Each time database schemas are required by a
-connection, for example as part of an sqlite3&#95;prepare\*(),
-sqlite3&#95;blob&#95;open() or sqlite3&#95;blob&#95;open() call, it obtains
-the minimum number of schemas required from the various schema-pools, returning
-them at the end of the call. This means that a single schema-pool only ever
-contains more than one copy of the schema if:
-
-  * Two threads require schemas from the same pool at the same time, or
-  * A single sqlite3&#95;prepare\*() call requires schemas for two or more
-    attached databases that use the same schema-pool.
-
-The size of a schema-pool never shrinks. Each schema pool always maintains 
-a number of schema objects equal to the highwater mark of schema objects
-simultaneously required by clients.
-
-This approach is preferred to allowing multiple databases to use the same
-Schema object simultaneously for three reasons:
-
-  * The Schema object is not completely read-only. For example, the 
-    Index.zIdxAff string is allocated lazily.
-  * Throughout the statement compiler, SQLite uses variables like 
-    Table.pSchema and Index.pSchema with the sqlite3SchemaToIndex() routine
-    in order to determine which attached database a Table or Index object
-    resides in. This mechanism does not work if the same Schema may be
-    used by two or more attached databases.
-  * It may be easier to modify this approach in order to allow
-    SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections to modify database
-    schemas, should that be required.
-
-SQLITE&#95;OPEN&#95;SHARED&#95;SCHEMA connections do not store their
-virtual-table handles in the Table.pVTable list of each table. This would not
-work, as (a) there is no guarantee that a connection will be assigned the same
-Schema object each time it requests one from a schema-pool and (b) a single
-Schema (and therefore Table) object may correspond to tables in two or more
-databases attached to a single connection. Instead, all virtual-table handles
-associated with a single database are stored in a linked-list headed at
-Db.pVTable.
@@ -343,7 +343,6 @@ TESTSRC = \
  $(TOP)/src/test_quota.c \
  $(TOP)/src/test_rtree.c \
  $(TOP)/src/test_schema.c \
-  $(TOP)/src/test_schemapool.c \
  $(TOP)/src/test_server.c \
  $(TOP)/src/test_sqllog.c \
  $(TOP)/src/test_superlock.c \
@@ -396,7 +395,6 @@ TESTSRC2 = \
  $(TOP)/src/backup.c \
  $(TOP)/src/btree.c \
  $(TOP)/src/build.c \
-  $(TOP)/src/callback.c \
  $(TOP)/src/date.c \
  $(TOP)/src/dbpage.c \
  $(TOP)/src/dbstat.c \
@@ -1,11 +1,11 @@
-C Merge\sbugfixes\smade\ssince\sversion\s3.33.0\sinto\sthis\sbranch.
-D 2020-09-16T16:55:48.900
+C Optimizations\sto\sthe\slogic\sthat\sconverts\smain\stable\saccesses\sinto\sequivalent\nindex\saccesses.\s\sCode\sis\snow\sslightly\ssmaller\sand\sfaster\sthan\strunk.
+D 2020-08-14T21:32:16.882
 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
 F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
-F Makefile.in 270f76ae25d3bc5027121b3cd0d498b484b9f8c98ef91c81cf9db3f48a68035e
+F Makefile.in 19374a5db06c3199ec1bab71ab74a103d8abf21053c05e9389255dc58083f806
 F Makefile.linux-gcc f609543700659711fbd230eced1f01353117621dccae7b9fb70daa64236c5241
-F Makefile.msc 9333691b59996201408f3e006d9ef6abaabc9a8cb444c14add736a4c37ed70f1
+F Makefile.msc 48f5a3fc32672c09ad73795749f6253e406a31526935fbbffd8f021108d54574
 F README.md 1514a365ffca3c138e00c5cc839906108a01011a6b082bad19b09781e3aa498a
 F VERSION 5db2ee2cfcc790af73775fa485c13b2e8ccaa5936c6e1f47aedeba7056041ca5
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
@@ -40,7 +40,6 @@ F contrib/sqlitecon.tcl 210a913ad63f9f991070821e599d600bd913e0ad
 F doc/F2FS.txt c1d4a0ae9711cfe0e1d8b019d154f1c29e0d3abfe820787ba1e9ed7691160fcd
 F doc/lemon.html 1edc0f916e771212792d4d077aedc05168bf13fd65d64d41b2c13e46ac0063a8
 F doc/pager-invariants.txt 27fed9a70ddad2088750c4a2b493b63853da2710
-F doc/shared_schema.md 759fc374709fccf4e5d2d0cbd05f8fedd38fb022bdd8a6c5b5f492684c7023b9
 F doc/trusted-schema.md 33625008620e879c7bcfbbfa079587612c434fa094d338b08242288d358c3e8a
 F doc/vfs-shm.txt e101f27ea02a8387ce46a05be2b1a902a021d37a
 F doc/wal-lock.md 781726aaba20bafeceb7ba9f91d5c98c6731691b30c954e37cf0b49a053d461d
@@ -458,7 +457,7 @@ F ext/userauth/userauth.c 7f00cded7dcaa5d47f54539b290a43d2e59f4b1eb5f447545fa865
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 7d384a56be992954cf3ae0eb8bdd910d48727554ff3ca4904253a125ac7e615a
+F main.mk b1cd0bc6aedad7ebb667b7f74f835f932f60ee33be2a5c3051fd93eb465f5c75
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -470,27 +469,27 @@ F spec.template 86a4a43b99ebb3e75e6b9a735d5fd293a24e90ca
 F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
 F sqlite3.1 fc7ad8990fc8409983309bb80de8c811a7506786
 F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
-F src/alter.c 46f7f401f9bfce4b842d0ce14fb8bc74aa147ebaec7a9518c0719ed73ce0e5df
-F src/analyze.c 5eab9cfb85d1280fa35fd4cf5c497f77ad884bf3658610e7321c3994e703c2e6
-F src/attach.c f5e649fb70e856e2bc388d2f158cd4b4e43b85f43ad4c397fee192b35bd0dd57
+F src/alter.c 805de23ddca536181f8f0439df989fdd4a2f76c40bc305ec9fe2f211f68c89e8
+F src/analyze.c 5cffff3d355858cd22bfc6e20ac7203510d2e1cc935086eb06f4abb2f579f628
+F src/attach.c 0b11e00c166b622c84ec176773b1d691c61ad07d247809e3e1635d4e99e71d30
 F src/auth.c a3d5bfdba83d25abed1013a8c7a5f204e2e29b0c25242a56bc02bb0c07bf1e06
 F src/backup.c b1c90cd4110248c8e1273ff4578d3a84c0c34725e1b96dacd4a6294a908702de
 F src/bitvec.c 17ea48eff8ba979f1f5b04cc484c7bb2be632f33
 F src/btmutex.c 8acc2f464ee76324bf13310df5692a262b801808984c1b79defb2503bbafadb6
-F src/btree.c 73a3e74e0f6116ba43175577d8fd5eee66794908ae30dde6a0dcf317d2abfd81
+F src/btree.c 1439fd9b45d4d1883c53752daef42af489adaa1a1508fa39dedbc9c80ea21a2f
 F src/btree.h 7af72bbb4863c331c8f6753277ab40ee67d2a2125a63256d5c25489722ec162b
 F src/btreeInt.h 83166f6daeb91062b6ae9ee6247b3ad07e40eba58f3c05ba9e8dedad4ab1ea38
-F src/build.c d8ece0dfeec69eb72d97054397aeaf2d4c43cf51c57b90574a3ac161c06f4a76
-F src/callback.c d8cdf5d697a31cf54a2b64bce9001fe24f3522a566f44c9fe1eb3a0c7e291c56
+F src/build.c dbdaee54ffef924a070eb6202017e10d6be56baab953ef0a8e714a6def683198
+F src/callback.c d0b853dd413255d2e337b34545e54d888ea02f20da5ad0e63585b389624c4a6c
 F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
-F src/ctime.c f5eaef0a5985fab6fc21e8b00aeaea1ca862a09c1ea5e505b0ad1da157eec247
+F src/ctime.c e98518d2d3d4029a13c805e07313fb60c877be56db76e90dd5f3af73085d0ce6
 F src/date.c dace306a10d9b02ee553d454c8e1cf8d3c9b932e137738a6b15b90253a9bfc10
 F src/dbpage.c 8a01e865bf8bc6d7b1844b4314443a6436c07c3efe1d488ed89e81719047833a
 F src/dbstat.c 3aa79fc3aed7ce906e4ea6c10e85d657299e304f6049861fe300053ac57de36c
-F src/delete.c 410c771c25afc113c273d9efad6ab6881bda28c75a1838b9d2c52ba20d1dc704
-F src/expr.c 4c8b9c2942adb896b9d1613794bd00cbf98c94e38c41cd5720b78bcdc21a965d
+F src/delete.c a2a603ab07cced8560065b0e2c4c9c842f2c5a2fd43d87355f95eb53bae7fe21
+F src/expr.c 58c06940d964c2cf455b979cf66a648499d294a5ee6dadcaeaed447257c1dc75
 F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
-F src/fkey.c 6cf1e15c986e5a393399ce337e4c085bf872117b8b095b04c79ae39d1f6a069a
+F src/fkey.c 83372403298e6a7dd989a47aaacdbaa5b4307b5199dbd56e07d4896066b3de72
 F src/func.c 2333eb4277f55a5efdc12ef754e7d7ec9105d257b2fd00301d23ce1e8fa67dc0
 F src/global.c 943256ac44f333039d35a9830c18d075a81fa6b6bf2af05771494a9acfb9a40b
 F src/hash.c 8d7dda241d0ebdafb6ffdeda3149a412d7df75102cecfc1021c98d6219823b19
@@ -500,7 +499,7 @@ F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
 F src/insert.c 957254a2d0542597455d0d4c640e4e3f3eea8c6d78f04582df03dfc626f07925
 F src/legacy.c d7874bc885906868cd51e6c2156698f2754f02d9eee1bae2d687323c3ca8e5aa
 F src/loadext.c 436af4968c6954d304fce9efa12719367bd8f37b19b93b71d6ad607e85adbb47
-F src/main.c 6ae3b03c1be1c77bcfd20d000e4b88d1018033499f8b6b2de2a77485bed0eb15
+F src/main.c 09580279145f27f3db206ef44dcb3a8875a42644230f79c7e54aff35e71668f0
 F src/malloc.c 22d5bdd9fe88ae4fad1b91a1b9735104b82853ffef868f1f05517d60dc1875f5
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c c12a42539b1ba105e3707d0e628ad70e611040d8f5e38cf942cee30c867083de
@@ -520,7 +519,7 @@ F src/os.c 80e4cf3e5da06be03ca641661e331ce60eeeeabf0d7354dbb1c0e166d0eedbbe
 F src/os.h 48388821692e87da174ea198bf96b1b2d9d83be5dfc908f673ee21fafbe0d432
 F src/os_common.h b2f4707a603e36811d9b1a13278bffd757857b85
 F src/os_setup.h 0dbaea40a7d36bf311613d31342e0b99e2536586
-F src/os_unix.c 89f19aec76a049b4deb5f1fc16afd4786bd1d151d20467abc6570c822abbfb35
+F src/os_unix.c 9b1b860163fd2d4d7679b5260d384d1a9f88ef917a90f28963eca8acd472d8c8
 F src/os_win.c a2149ff0a85c1c3f9cc102a46c673ce87e992396ba3411bfb53db66813b32f1d
 F src/os_win.h 7b073010f1451abe501be30d12f6bc599824944a
 F src/pager.c 3700a1c55427a3d4168ad1f1b8a8b0cb9ace1d107e4506e30a8f1e66d8a1195e
@@ -529,23 +528,23 @@ F src/parse.y 5bdb760a29c0b25caf7e80e82210b81cd2ea3066d5199ca29e6eac40b34bc184
 F src/pcache.c 385ff064bca69789d199a98e2169445dc16e4291fa807babd61d4890c3b34177
 F src/pcache.h 4f87acd914cef5016fae3030343540d75f5b85a1877eed1a2a19b9f284248586
 F src/pcache1.c 6596e10baf3d8f84cc1585d226cf1ab26564a5f5caf85a15757a281ff977d51a
-F src/pragma.c b4e8df9a29c6fbe7e6576217e79a50cef34742d13ad49af20dd3c75434112e71
-F src/pragma.h ce2b135cde481eeb198af0dfc4781d58528ce80b17580a2b747b8fd4bc969e44
-F src/prepare.c 71bdb999ff30da7cd1f5202a9879e48e9109103a5e0b0144310418b11de83f2d
+F src/pragma.c bdb600be936f66b9fe69d26dfbba4528beaaf4f95c479c85b328a92484e0bf71
+F src/pragma.h 8dc78ab7e9ec6ce3ded8332810a2066f1ef6267e2e03cd7356ee00276125c6cf
+F src/prepare.c 3d5a761d026052bc888d1b803a06dd2bfe245e8e836d4689f927003549148b0f
 F src/printf.c 9efcd4e984f22bcccb1ded37a1178cac98f6e3a0534e1e0629f64899971f8838
 F src/random.c 80f5d666f23feb3e6665a6ce04c7197212a88384
-F src/resolve.c 97b91fb25d86881ff20c9ad2ad98412c6c1bb5f7d6c9bb044db250cbc9cfcd4b
+F src/resolve.c d74715aceed2a8f493ba244d535646fa93132042a4400a29dfd26ec841514048
 F src/rowset.c ba9515a922af32abe1f7d39406b9d35730ed65efab9443dc5702693b60854c92
-F src/select.c 233e884d7da6601486c7b93aedb97fd29302ae5c03742d0e0eccb4790638bb77
-F src/shell.c.in 21c61b18f27512699b355d1888d037406b4883f261efe9f7b7744f719809ab14
-F src/sqlite.h.in 7c1b9b3e42c6ed1670ef7dfd2df5ae95aaa966508c14ae5d060a9d14be9d99ae
+F src/select.c 510fdf819f218be3dac2683d3eaaf64e5080f548061a4dd12205590beda976bb
+F src/shell.c.in b9b819feede7b85585ab0826490a352e04e2ee46e8132c92597d29972b2be1d7
+F src/sqlite.h.in d2c03414a8ee5d4a6855c04dd7cd5998e45139b0fe66b65bae86d4223edd091f
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
 F src/sqlite3ext.h 2d1af80082edffd71c6f96f70ad1ce6a4fb46615ad10291fc77fe0dea9ff0197
-F src/sqliteInt.h c0e801eb5d45f397c0cf29729988f84a573d01280f0a09f94bf139156613ee13
-F src/sqliteLimit.h d7323ffea5208c6af2734574bae933ca8ed2ab728083caa117c9738581a31657
-F src/status.c d0956e57c71160155f620a3efeb1e5c05a3f8b9a897dd09c5263268e5d237579
+F src/sqliteInt.h 86ad0f9164cbadb2ba9598cc6cf5b32bdb47b343c0da5ca62f3d73b60be55b65
+F src/sqliteLimit.h 95cb8479ca459496d9c1c6a9f76b38aee12203a56ce1092fe13e50ae2454c032
+F src/status.c 4b8bc2a6905163a38b739854a35b826c737333fab5b1f8e03fa7eb9a4799c4c1
 F src/table.c 0f141b58a16de7e2fbe81c308379e7279f4c6b50eb08efeec5892794a0ba30d1
-F src/tclsqlite.c f4dd32d001c2be33371dca87e30117352f02dad59a2e5428c97f08703360a169
+F src/tclsqlite.c 986b6391f02cd9b53c1d688be55899f6ffddeb8e8014cd83c1b73ff912579a71
 F src/test1.c 24b9cd0863ecc4d3920f4999c40e876c2bd92f3cc5879c48b99abe02c546ed18
 F src/test2.c 3efb99ab7f1fc8d154933e02ae1378bac9637da5
 F src/test3.c 61798bb0d38b915067a8c8e03f5a534b431181f802659a6616f9b4ff7d872644
@@ -561,7 +560,7 @@ F src/test_backup.c bf5da90c9926df0a4b941f2d92825a01bbe090a0
 F src/test_bestindex.c 78809f11026f18a93fcfd798d9479cba37e1201c830260bf1edc674b2fa9b857
 F src/test_blob.c ae4a0620b478548afb67963095a7417cd06a4ec0a56adb453542203bfdcb31ce
 F src/test_btree.c 8b2dc8b8848cf3a4db93f11578f075e82252a274
-F src/test_config.c 9eaeaa599673b8e8732b80540549250a1f1b5bab5de4bfd76b1566f495bc95ab
+F src/test_config.c 5ea19bf0972a9d91728518b4d30e91477acce80496003ecbef3a7fb18d0bd081
 F src/test_delete.c e2fe07646dff6300b48d49b2fee2fe192ed389e834dd635e3b3bac0ce0bf9f8f
 F src/test_demovfs.c 86142ba864d4297d54c5b2e972e74f3141ae4b30f05b3a95824184ed2d3d7f91
 F src/test_devsym.c 6109b45c3db3ef7b002320947ed448c027356ab8b885156ff535fd8684d4a571
@@ -585,12 +584,11 @@ F src/test_quota.c 6cb9297115b551f433a9ad1741817a9831abed99
 F src/test_quota.h 2a8ad1952d1d2ca9af0ce0465e56e6c023b5e15d
 F src/test_rtree.c 671f3fae50ff116ef2e32a3bf1fe21b5615b4b7b
 F src/test_schema.c f5d6067dfc2f2845c4dd56df63e66ee826fb23877855c785f75cc2ca83fd0c1b
-F src/test_schemapool.c ae21a79f9bc7e9099ae78dbd46d5c28ee75330e62e3256a9fde25564ff9df492
 F src/test_server.c a2615049954cbb9cfb4a62e18e2f0616e4dc38fe
 F src/test_sqllog.c 540feaea7280cd5f926168aee9deb1065ae136d0bbbe7361e2ef3541783e187a
 F src/test_superlock.c 4839644b9201da822f181c5bc406c0b2385f672e
 F src/test_syscall.c 1073306ba2e9bfc886771871a13d3de281ed3939
-F src/test_tclsh.c 6cbaaf30c4fed76c7b35baa42c521fd225c49563ff580f736d77def9e216b31b
+F src/test_tclsh.c eeafce33ad2136d57e5dec10f1e9a4347447eb72ffd504a1c7b9c6bfe2e71578
 F src/test_tclvar.c 33ff42149494a39c5fbb0df3d25d6fafb2f668888e41c0688d07273dcb268dfc
 F src/test_thread.c 269ea9e1fa5828dba550eb26f619aa18aedbc29fd92f8a5f6b93521fbb74a61c
 F src/test_vdbecov.c f60c6f135ec42c0de013a1d5136777aa328a776d33277f92abac648930453d43
@@ -601,32 +599,32 @@ F src/test_windirent.h 90dfbe95442c9762357fe128dc7ae3dc199d006de93eb33ba3972e0a9
 F src/test_window.c cdae419fdcea5bad6dcd9368c685abdad6deb59e9fc8b84b153de513d394ba3f
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/threads.c 4ae07fa022a3dc7c5beb373cf744a85d3c5c6c3c
-F src/tokenize.c cc9b7b311ea93b70aff96fe9aeb37b034588453115c3a09a728a0675594953d4
+F src/tokenize.c 4dc01b267593537e2a0d0efe9f80dabe24c5b6f7627bc6971c487fa6a1dacbbf
 F src/treeview.c 4b92992176fb2caefbe06ba5bd06e0e0ebcde3d5564758da672631f17aa51cda
-F src/trigger.c 595153f55f10058605e84aa6e41718e92ebd6fa896528bcc3a97708f0bb27ac4
-F src/update.c fb15bec5b54fd098f4b84f6abc83c7103b45ba8484011fff8edf5ae31656eab6
+F src/trigger.c ef67bde309a831515dc3c2173d792574309f2f42d45f8c078743fae9f7f98c75
+F src/update.c 55a6203008d033fc1a9c125d7a0a61efdb79bbb2e6db427b917d1d427b4639be
 F src/upsert.c 2920de71b20f04fe25eb00b655d086f0ba60ea133c59d7fa3325c49838818e78
 F src/utf.c ee39565f0843775cc2c81135751ddd93eceb91a673ea2c57f61c76f288b041a0
-F src/util.c c0c7977de7ef9b8cb10f6c85f2d0557889a658f817b0455909a49179ba4c8002
-F src/vacuum.c 55537753cfc6b860b844bf9a3e47b855ba5a8094e165074a7a908304dd1960ad
-F src/vdbe.c 9ae5113faf176c3305db3b8cb06a3e129293cc66af15e42142dbab13ce10bac5
-F src/vdbe.h 9e947bd4a40e3b65159b699571c8246c209f6bda6e13979a1ab623faa2f0d23f
+F src/util.c c8bf30c4356b091bcc3b624d0e24b2b4d11b8be4d6c90d8e0705971e15cc819b
+F src/vacuum.c 1c4f8e2f39d950037f4cf946b6858c993d3a54c3101f78e05c76460a073afcf0
+F src/vdbe.c e9f7f818f128c8600058c0eabb6b3975974c95153a104d340f419adabbc15b9f
+F src/vdbe.h 83603854bfa5851af601fc0947671eb260f4363e62e960e8a994fb9bbcd2aaa1
 F src/vdbeInt.h 762abffb7709f19c2cb74af1bba73a900f762e64f80d69c31c9ae89ed1066b60
 F src/vdbeapi.c c5e7cb2ab89a24d7f723e87b508f21bfb1359a04db5277d8a99fd1e015c12eb9
-F src/vdbeaux.c 1aa53cee66d6fd880d47891a0d6f0beaf3f8530335c7e8824e0491516bf81397
-F src/vdbeblob.c 40028e015fe557a945c99edb6cbf844ea96d853c3e8ac4eb5c1e49bff59f154e
+F src/vdbeaux.c 73854da7a9a4f12db72a855758214173c82f46a14be6cb19e63677ba02c97cae
+F src/vdbeblob.c 253ed82894924c362a7fa3079551d3554cd1cdace39aa833da77d3bc67e7c1b1
 F src/vdbemem.c 947f2a65910edb4014dc981d33e414a68c51f169f9df8c4c493a0ba840b6eb1f
-F src/vdbesort.c f5b5e473a7cee44e47a94817b042fd7172cf3aa2c0a7928a8339d612bcfdec5a
+F src/vdbesort.c 2be76d26998ce2b3324cdcc9f6443728e54b6c7677c553ad909c7d7cfab587df
 F src/vdbetrace.c fa3bf238002f0bbbdfb66cc8afb0cea284ff9f148d6439bc1f6f2b4c3b7143f0
 F src/vdbevtab.c f99b275366c5fc5e2d99f734729880994ab9500bdafde7fae3b02d562b9d323c
-F src/vtab.c 54b6ab9f5ab772f56e9f3a95543207943e775ec699b7cbbfd3a99c264cad377f
+F src/vtab.c 5f5fc793092f53bbdfde296c50f563fb7bda58cf48e9cf6a8bdfbc5abd409845
 F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
 F src/wal.c 69e770e96fd56cc21608992bf2c6f1f3dc5cf2572d0495c6a643b06c3a679f14
 F src/wal.h c3aa7825bfa2fe0d85bef2db94655f99870a285778baa36307c0a16da32b226a
 F src/walker.c 3df26a33dc4f54e8771600fb7fdebe1ece0896c2ad68c30ab40b017aa4395049
-F src/where.c 2ea911238674e9baaeddf105dddabed92692a01996073c4d4983f9a7efe481f9
-F src/whereInt.h 6b874aa15f94e43a2cec1080be64d955b04deeafeac90ffb5d6975c0d511be3c
-F src/wherecode.c 8064fe5c042824853a9b1fda670054a51a49033a6c79059988c97751ccf8088e
+F src/where.c 396ba2c62defd56283ef54a4b221f698f4733fe8fbfca4aa8b1cc4f8c58d12ee
+F src/whereInt.h eb8c2847fb464728533777efec1682b3c074224293b2da73513c61a609efbeab
+F src/wherecode.c cb9bc7cef99578c99baceafeea9c9bcc738d5be37f56dbfe3a1c61ea52483fd0
 F src/whereexpr.c 264d58971eaf8256eb5b0917bcd7fc7a1f1109fdda183a8382308a1b18a2dce7
 F src/window.c edd6f5e25a1e8f2b6f5305b7f5f7da7bb35f07f0d432b255b1d4c2fcab4205aa
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
@@ -669,7 +667,7 @@ F test/async2.test c0a9bd20816d7d6a2ceca7b8c03d3d69c28ffb8b
 F test/async3.test d73a062002376d7edc1fe3edff493edbec1fc2f7
 F test/async4.test 1787e3952128aa10238bf39945126de7ca23685a
 F test/async5.test 383ab533fdb9f7ad228cc99ee66e1acb34cc0dc0
-F test/atof1.test 10049623e77006691c4c2978c1dc8a3f75276377a53417811aa85bda7493f963
+F test/atof1.test 1ccfc96a6888566597b83d882c81b3c04258dc39317e8c1cec89ba481eaa2fba
 F test/atomic.test 065a453dde33c77ff586d91ccaa6ed419829d492dbb1a5694b8a09f3f9d7d061
 F test/atomic2.test b6863b4aa552543874f80b42fb3063f1c8c2e3d8e56b6562f00a3cc347b5c1da
 F test/atrc.c c388fac43dbba05c804432a7135ae688b32e8f25818e9994ffba4b64cf60c27c
@@ -730,7 +728,7 @@ F test/btree01.test e08b3613540145b353f20c81cb18ead54ff12e0f
 F test/btree02.test 7555a5440453d900410160a52554fe6478af4faf53098f7235f1f443d5a1d6cc
 F test/btreefault.test c2bcb542685eea44621275cfedbd8a13f65201e3
 F test/busy.test 510dc6daaad18bcbbc085bcc6217d6dc418def5e73f72ce1475eea0cb7834727
-F test/busy2.test 26ae3b8b74235c851f27326807de94292af4d359476c629f80dc106f35c8293e
+F test/busy2.test 2499cb62c9e58e18335892602c158cb35639c411803adca6423401b31e46c503
 F test/cache.test 13bc046b26210471ca6f2889aceb1ea52dc717de
 F test/cacheflush.test af25bb1509df04c1da10e38d8f322d66eceedf61
 F test/cachespill.test 895997f84a25b323b166aecb69baab2d6380ea98f9e0bcc688c4493c535cfab9
@@ -1052,7 +1050,7 @@ F test/hook2.test b9ff3b8c6519fb67f33192f1afe86e7782ee4ac8
 F test/icu.test 716a6b89fbabe5cc63e0cd4c260befb08fd7b9d761f04d43669233292f0753b1
 F test/ieee754.test b0945d12be7d255f3dfa18e2511b17ca37e0edd2b803231c52d05b86c04ab26e
 F test/imposter1.test c3f1db2d3db2c24611a6596a3fc0ffc14f1466c8
-F test/in.test 95a704448eaa348300a517df267b37488c854aa0713125f4fa7b6280cfd4ed0f
+F test/in.test ae4ba0fe3232fdd84ef1090a68c5cd6ccd93f1f8774d5c967dd0c1b301492eed
 F test/in2.test 5d4c61d17493c832f7d2d32bef785119e87bde75
 F test/in3.test 3cbf58c87f4052cee3a58b37b6389777505aa0c0
 F test/in4.test 65460600d48933adba4283c6ebd089aae173d16136ab9d01f74c89089090c5a5
@@ -1105,11 +1103,11 @@ F test/ioerr5.test 2edfa4fb0f896f733071303b42224df8bedd9da4
 F test/ioerr6.test a395a6ab144b26a9e3e21059a1ab6a7149cca65b
 F test/istrue.test 06f92ea38750fa74df7dbbe6920205251c2310861fbbe23a3adfa918a2e2ba74
 F test/join.test bca044589e94bb466e4c1e91fb6fecdc3f3326ca6b3f590f555f1958156eb321
-F test/join2.test 21fc30e54ab35ed66bf51b89cec18729205497f5cc43c83bc042f96a73721593
+F test/join2.test 7d24d095ab88d3910228d53a3b548b7baf2e0e7d8aac6731a273e300e1b34b61
 F test/join3.test 6f0c774ff1ba0489e6c88a3e77b9d3528fb4fda0
 F test/join4.test 1a352e4e267114444c29266ce79e941af5885916
 F test/join5.test 3a96dc62f0b45402d7207e22d1993fe0c2fce1c57644a11439891dd62b990eb7
-F test/join6.test f809c025fa253f9e150c0e9afd4cef8813257bceeb6f46e04041228c9403cc2c
+F test/join6.test cfe6503791ceb0cbb509966740286ec423cbf10b
 F test/journal1.test c7b768041b7f494471531e17abc2f4f5ebf9e5096984f43ed17c4eb80ba34497
 F test/journal2.test 9dac6b4ba0ca79c3b21446bbae993a462c2397c4
 F test/journal3.test 7c3cf23ffc77db06601c1fcfc9743de8441cb77db9d1aa931863d94f5ffa140e
@@ -1274,16 +1272,9 @@ F test/regexp1.test 497ea812f264d12b6198d6e50a76be4a1973a9d8
 F test/regexp2.test 40e894223b3d6672655481493f1be12012f2b33c
 F test/reindex.test cd9d6021729910ece82267b4f5e1b5ac2911a7566c43b43c176a6a4732e2118d
 F test/releasetest.tcl fb76d8fcc95ac29d6356cd9e52b726ab9e43a24082897618dfbcb7c2b0049153 x
-F test/releasetest_data.tcl ce3bebf5a6755412eca6f37f4cb7f8768027a8d9af8aac129dc10e656f4c0ff5
+F test/releasetest_data.tcl 9919fc6ac5bc92f8878fecfd1840db15999f660a6c9f609240b41aa62b885c88
 F test/resetdb.test 8062cf10a09d8c048f8de7711e94571c38b38168db0e5877ba7561789e5eeb2b
 F test/resolver01.test f4022acafda7f4d40eca94dbf16bc5fc4ac30ceb
-F test/reuse1.test faa2ce5ff566d936b8a10d9e22ba2ee66a54ce89fdcf8aef561df6b15b0ff3d3
-F test/reuse2.test 5dd9c98579358f0d5a90d25e36dd6e678a03e23446b6c7f2630a8da22ae7ca94
-F test/reuse3.test 876d15c42d61b1f6ab718cd8169912514ad314d7fe1cd9788080aa62168ba0d1
-F test/reuse4.test adaad66253aea6cc748674328abe69b650c5c78b8676ed1162d3de09742519f9
-F test/reuse5.test bbe6cf7384ef90f134392edd93d626385ef0bf6f40eefc3d993535cd0861d83b
-F test/reuse6.test f4674f9967aee2a0b49c02832120b8b495291c0d87aae084c54e6c0cc18132fe
-F test/reusefault.test ef646a0fb51d50ddfb4b7cd872f88e7d36eaba64bde7797b3418c3774e1c8d14
 F test/rollback.test 06680159bc6746d0f26276e339e3ae2f951c64812468308838e0a3362d911eaa
 F test/rollback2.test bc868d57899dc6972e2b4483faae0e03365a0556941474eec487ae21d8d38bb6
 F test/rollbackfault.test 0e646aeab8840c399cfbfa43daab46fd609cf04a
@@ -1427,7 +1418,7 @@ F test/tabfunc01.test 5ca6d004157a3e886a55a9387b960cc0db41acd88753eb597ff409ec6c
 F test/table.test eb3463b7add9f16a5bb836badf118cf391b809d09fdccd1f79684600d07ec132
 F test/tableapi.test ecbcc29c4ab62c1912c3717c48ea5c5e59f7d64e4a91034e6148bd2b82f177f4
 F test/tableopts.test dba698ba97251017b7c80d738c198d39ab747930
-F test/tclsqlite.test 9ad3f8d337ae8e460b25d82094ff1b4f180afc3ca73856ec5a90ac215f43906c
+F test/tclsqlite.test 79a473f5797e317c08f2c4f8192edb3eea6a67329b1087453328b66a7cb31070
 F test/tempdb.test 4cdaa23ddd8acb4d79cbb1b68ccdfd09b0537aaba909ca69a876157c2a2cbd08
 F test/tempdb2.test 353864e96fd3ae2f70773d0ffbf8b1fe48589b02c2ec05013b540879410c3440
 F test/tempfault.test 0c0d349c9a99bf5f374655742577f8712c647900
@@ -1446,7 +1437,7 @@ F test/thread2.test f35d2106452b77523b3a2b7d1dcde2e5ee8f9e46
 F test/thread_common.tcl 334639cadcb9f912bf82aa73f49efd5282e6cadd
 F test/threadtest1.c 6029d9c5567db28e6dc908a0c63099c3ba6c383b
 F test/threadtest2.c a70a8e94bef23339d34226eb9521015ef99f4df8
-F test/threadtest3.c e58f0e1b6a3e4ccb24f831650c296e800f6299cc258793f6fc372591f416cb93
+F test/threadtest3.c 38a612ea62854349ed66372f330a40d73c5cf956
 F test/threadtest4.c c1e67136ceb6c7ec8184e56ac61db28f96bd2925
 F test/time-wordcount.sh 8e0b0f8109367827ad5d58f5cc849705731e4b90
 F test/tkt-02a8e81d44.test 6c80d9c7514e2a42d4918bf87bf6bc54f379110c
@@ -1619,13 +1610,11 @@ F test/triggerF.test 5d76f0a8c428ff87a4d5ed52da06f6096a2c787a1e21b846111dfac4123
 F test/triggerG.test 2b816093c91ba73c733cfa8aedcc210ad819d72a98b1da30768a3c56505233e9
 F test/triggerupfrom.test d25961fa70a99b6736193da7b49a36d8c1d28d56188f0be6406d4366315cd6e4
 F test/trustschema1.test 4e970aef0bfe0cee139703cc7209d0e0f07725d999b180ba50770f49edef1494
-F test/tt3_checkpoint.c 9a7fe00e07700af027769d83ef67ab727927ae6c865ecdc71fe8011194200c53
-F test/tt3_index.c 95592839426dc85ce5a7a57b41be2cbf3c2ec3457b9cd841a06ed5877f712c7c
-F test/tt3_lookaside1.c 2ddd99bfffeef288f0786827ef68f912f6f47ce3d3184e62f05808d8e13b920e
-F test/tt3_reuseschema.c 4d52e141f89f009028d8ab0bd1f0697d0edffa94bafc1fff0f7ad4d9d9baa549
-F test/tt3_shared.c b37d22defc944a2ac4c91c927fd06c1d48cd51e2ce9d004fe868625bd2399f93
-F test/tt3_stress.c 077e817ac1168443b075fedb44e92db84bb4dc5bd3b6fe1aba25c94ac280b231
-F test/tt3_vacuum.c ca42adcf8a671abbe34338b828464269e21758a6b4857b889dabfd39a3206d98
+F test/tt3_checkpoint.c 9e75cf7c1c364f52e1c47fd0f14c4340a9db0fe1
+F test/tt3_index.c 39eec10a35f57672225be4d182862152896dee4a
+F test/tt3_lookaside1.c 0377e202c3c2a50d688cb65ba203afeda6fafeb9
+F test/tt3_stress.c f9a769ca8b026ecc76ee93ca8c9700a5619f8e51c581107c4053ba6ac97f616f
+F test/tt3_vacuum.c 1753f45917699c9c1f66b64c717a717c9379f776
 F test/types.test bf816ce73c7dfcfe26b700c19f97ef4050d194ff
 F test/types2.test 1aeb81976841a91eef292723649b5c4fe3bc3cac
 F test/types3.test 99e009491a54f4dc02c06bdbc0c5eea56ae3e25a
@@ -1823,7 +1812,7 @@ F tool/mkmsvcmin.tcl 6ecab9fe22c2c8de4d82d4c46797bda3d2deac8e763885f5a38d0c44a89
 F tool/mkopcodec.tcl d1b6362bd3aa80d5520d4d6f3765badf01f6c43c
 F tool/mkopcodeh.tcl 352a4319c0ad869eb26442bf7c3b015aa15594c21f1cce5a6420dbe999367c21
 F tool/mkopts.tcl 680f785fdb09729fd9ac50632413da4eadbdf9071535e3f26d03795828ab07fa
-F tool/mkpragmatab.tcl 37381569b5a5cd3269e3fdbc08829eb1a5f7c2a8e59ee7be8995127e5ef99e0d
+F tool/mkpragmatab.tcl ae5585ae76ca26e4d6ccd5ea9cdebaf5efefb318bf989497a0e846cd711d9ab1
 F tool/mkshellc.tcl 70a9978e363b0f3280ca9ce1c46d72563ff479c1930a12a7375e3881b7325712
 F tool/mksourceid.c 36aa8020014aed0836fd13c51d6dc9219b0df1761d6b5f58ff5b616211b079b9
 F tool/mkspeedsql.tcl a1a334d288f7adfe6e996f2e712becf076745c97
@@ -1890,10 +1879,7 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P e456d437083c550570063b874d685f110162a0551f51d5f190f90c1354e6e996 807643c596b2315feed9e9c492dcdba1dc35d6eb81253a72f0bca320fcaa4fca
-R e7c94e3f9a4566c0c1994c62bcabc581
-T *branch * reuse-schema-3.33
-T *sym-reuse-schema-3.33 *
-T -sym-reuse-schema *
-U dan
-Z 9b7288a270043d5d2618b7597889b1ef
+P a495f60d315e34b1a1bc5fb1336e05047add52c8fb2710b577c97b10a5e734f6
+R 54b8b0b6f00b6cfab28e2e5a52014ff6
+U drh
+Z a854ac35ef1e1fa9d5bc731176f5cbf6
@@ -1 +1 @@
-2e269dcdef0a0e86afedb84fd61d5d5b41c327b48bd5bf51b4e785aaf4d08fe8
+611b640442025e57b8e161f8ddac1f19bd3be9a3d5266f4cef287595c3ed9257
@@ -80,8 +80,8 @@ static void renameReloadSchema(Parse *pParse, int iDb){
  Vdbe *v = pParse->pVdbe;
  if( v ){
    sqlite3ChangeCookie(pParse, iDb);
-    sqlite3VdbeAddParseSchemaOp(pParse, iDb, 0);
-    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse, 1, 0);
+    sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0);
+    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0);
  }
 }

@@ -212,7 +212,6 @@ static void openStatTable(
        ** side-effect of the CREATE TABLE statement is to leave the rootpage 
        ** of the new table in register pParse->regRoot. This is important 
        ** because the OpenWrite opcode below will be needing it. */
-        sqlite3SchemaWritable(pParse, iDb);
        sqlite3NestedParse(pParse,
            "CREATE TABLE %Q.%s(%s)", pDb->zDbSName, zTab, aTable[i].zCols
        );
@@ -205,14 +205,14 @@ static void attachFunc(
  ** way we found it.
  */
  if( rc==SQLITE_OK ){
+    sqlite3BtreeEnterAll(db);
    db->init.iDb = 0;
    db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
-    if( !IsSharedSchema(db) && !REOPEN_AS_MEMDB(db) ){
-      sqlite3BtreeEnterAll(db);
+    if( !REOPEN_AS_MEMDB(db) ){
      rc = sqlite3Init(db, &zErrDyn);
-      sqlite3BtreeLeaveAll(db);
-      assert( zErrDyn==0 || rc!=SQLITE_OK );
    }
+    sqlite3BtreeLeaveAll(db);
+    assert( zErrDyn==0 || rc!=SQLITE_OK );
  }
 #ifdef SQLITE_USER_AUTHENTICATION
  if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
@@ -310,7 +310,6 @@ static void detachFunc(
    pEntry = sqliteHashNext(pEntry);
  }

-  sqlite3SchemaDisconnect(db, i, 0);
  sqlite3BtreeClose(pDb->pBt);
  pDb->pBt = 0;
  pDb->pSchema = 0;
@@ -2605,7 +2605,7 @@ btree_open_out:
    ** do not change the pager-cache size.
    */
    if( sqlite3BtreeSchema(p, 0, 0)==0 ){
-      sqlite3BtreeSetCacheSize(p, SQLITE_DEFAULT_CACHE_SIZE);
+      sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
    }

    pFile = sqlite3PagerFile(pBt->pPager);
@@ -296,39 +296,6 @@ int sqlite3UserAuthTable(const char *zTable){
 }
 #endif

-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-/*
-** If this database connection was opened with the SQLITE_OPEN_SHARED_SCHEMA
-** flag specified, then ensure that the database schema for database iDb
-** is loaded. Either by obtaining a Schema object from the schema-pool, or
-** by reading the contents of the sqlite_master table. Unless it is NULL, 
-** the location indicated by parameter pbUnload is set to 1 if a shared-schema 
-** is loaded.
-**
-** If the database handle was not opened with SQLITE_OPEN_SHARED_SCHEMA, or
-** if the schema for database iDb is already loaded, this function is a no-op.
-**
-** SQLITE_OK is returned if successful, or an SQLite error code otherwise. If
-** an error code is returned, (*pzErr) may be set to point to a buffer
-** containing an error message. It is the responsibility of the caller to
-** eventually free this buffer using sqlite3_free().
-*/
-int sqlite3SchemaLoad(sqlite3 *db, int iDb, int *pbUnload, char **pzErr){
-  int rc = SQLITE_OK;
-  if( IsSharedSchema(db) 
-      && DbHasProperty(db, iDb, DB_SchemaLoaded)==0 
-      && (db->init.busy==0 || (iDb!=1 && db->init.iDb==1))
-  ){
-    struct sqlite3InitInfo sv = db->init;
-    memset(&db->init, 0, sizeof(struct sqlite3InitInfo));
-    rc = sqlite3InitOne(db, iDb, pzErr, 0);
-    db->init = sv;
-    if( pbUnload && rc==SQLITE_OK && iDb!=1 ) *pbUnload = 1;
-  }
-  return rc;
-}
-#endif
-
 /*
 ** Locate the in-memory structure that describes a particular database
 ** table given the name of that table and (optionally) the name of the
@@ -354,41 +321,59 @@ Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
    return 0;
  }
 #endif
-  while(1){
-    for(i=OMIT_TEMPDB; i<db->nDb; i++){
-      int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
-      if( zDatabase==0 || sqlite3DbIsNamed(db, j, zDatabase) ){
-        int bUnload = 0;
-        assert( sqlite3SchemaMutexHeld(db, j, 0) );
-        if( IsSharedSchema(db) ){
-          Parse *pParse = db->pParse;
-          if( pParse && pParse->nErr==0 ){
-            pParse->rc = sqlite3SchemaLoad(db, j, &bUnload, &pParse->zErrMsg);
-            if( pParse->rc ) pParse->nErr++;
-          }
+  if( zDatabase ){
+    for(i=0; i<db->nDb; i++){
+      if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break;
+    }
+    if( i>=db->nDb ){
+      /* No match against the official names.  But always match "main"
+      ** to schema 0 as a legacy fallback. */
+      if( sqlite3StrICmp(zDatabase,"main")==0 ){
+        i = 0;
+      }else{
+        return 0;
+      }
+    }
+    p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
+    if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
+      if( i==1 ){
+        if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0
+         || sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0
+         || sqlite3StrICmp(zName+7, &DFLT_SCHEMA_TABLE[7])==0
+        ){
+          p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, 
+                              DFLT_TEMP_SCHEMA_TABLE);
        }
-        p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
-        if( p ) return p;
-        if( bUnload ){
-          sqlite3SchemaRelease(db, j);
+      }else{
+        if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
+          p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
+                              DFLT_SCHEMA_TABLE);
        }
      }
    }
-    /* Not found.  If the name we were looking for was temp.sqlite_master
-    ** then change the name to sqlite_temp_master and try again. */
-    if( sqlite3StrICmp(zName, ALT_SCHEMA_TABLE)==0 ){
-      zName = DFLT_SCHEMA_TABLE;
-      continue;
+  }else{
+    /* Match against TEMP first */
+    p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName);
+    if( p ) return p;
+    /* The main database is second */
+    p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName);
+    if( p ) return p;
+    /* Attached databases are in order of attachment */
+    for(i=2; i<db->nDb; i++){
+      assert( sqlite3SchemaMutexHeld(db, i, 0) );
+      p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName);
+      if( p ) break;
    }
-    if( sqlite3StrICmp(zName, ALT_TEMP_SCHEMA_TABLE)==0 ){
-      zName = DFLT_TEMP_SCHEMA_TABLE;
-      continue;
+    if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
+      if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
+        p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, DFLT_SCHEMA_TABLE);
+      }else if( sqlite3StrICmp(zName+7, &ALT_TEMP_SCHEMA_TABLE[7])==0 ){
+        p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, 
+                            DFLT_TEMP_SCHEMA_TABLE);
+      }
    }
-    if( sqlite3StrICmp(zName, DFLT_SCHEMA_TABLE)!=0 ) break;
-    if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;
-    zName = DFLT_TEMP_SCHEMA_TABLE;
  }
-  return 0;
+  return p;
 }

 /*
@@ -413,7 +398,6 @@ Table *sqlite3LocateTable(
  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 
-   && !IsSharedSchema(db)
   && SQLITE_OK!=sqlite3ReadSchema(pParse)
  ){
    return 0;
@@ -430,18 +414,8 @@ Table *sqlite3LocateTable(
      if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
        pMod = sqlite3PragmaVtabRegister(db, zName);
      }
-      if( pMod ){
-        if( IsSharedSchema(db) && pParse->nErr==0 ){
-          int bDummy = 0;
-          pParse->rc = sqlite3SchemaLoad(db, 0, &bDummy, &pParse->zErrMsg);
-          if( pParse->rc ) pParse->nErr++;
-        }
-        if( sqlite3VtabEponymousTableInit(pParse, pMod) ){
-          Table *pEpoTab = pMod->pEpoTab;
-          assert( IsSharedSchema(db) || pEpoTab->pSchema==db->aDb[0].pSchema );
-          pEpoTab->pSchema = db->aDb[0].pSchema;  /* For SHARED_SCHEMA mode */
-          return pEpoTab;
-        }
+      if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
+        return pMod->pEpoTab;
      }
    }
 #endif
@@ -451,7 +425,7 @@ Table *sqlite3LocateTable(
    p = 0;
  }

-  if( p==0 && (!IsSharedSchema(db) || pParse->nErr==0) ){
+  if( p==0 ){
    const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
    if( zDbase ){
      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
@@ -610,10 +584,11 @@ void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
    DbSetProperty(db, 1, DB_ResetWanted);
    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
  }
+
  if( db->nSchemaLock==0 ){
    for(i=0; i<db->nDb; i++){
      if( DbHasProperty(db, i, DB_ResetWanted) ){
-        sqlite3SchemaClearOrDisconnect(db, i);
+        sqlite3SchemaClear(db->aDb[i].pSchema);
      }
    }
  }
@@ -626,17 +601,16 @@ void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
 void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
-  for(i=0; i<db->nDb; i=(i?i+1:2)){
+  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      if( db->nSchemaLock==0 ){
-        sqlite3SchemaClearOrDisconnect(db, i);
+        sqlite3SchemaClear(pDb->pSchema);
      }else{
        DbSetProperty(db, i, DB_ResetWanted);
      }
    }
  }
-  sqlite3SchemaClear(db->aDb[1].pSchema);
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
@@ -1132,7 +1106,7 @@ void sqlite3StartTable(
  */
  if( !IN_SPECIAL_PARSE ){
    char *zDb = db->aDb[iDb].zDbSName;
-    if( !IsSharedSchema(db) && SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+    if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
      goto begin_table_error;
    }
    pTable = sqlite3FindTable(db, zName, zDb);
@@ -1909,15 +1883,12 @@ static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
  int nByte;
  if( pIdx->nColumn>=N ) return SQLITE_OK;
  assert( pIdx->isResized==0 );
-  nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*N;
+  nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
  zExtra = sqlite3DbMallocZero(db, nByte);
  if( zExtra==0 ) return SQLITE_NOMEM_BKPT;
  memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
  pIdx->azColl = (const char**)zExtra;
  zExtra += sizeof(char*)*N;
-  memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
-  pIdx->aiRowLogEst = (LogEst*)zExtra;
-  zExtra += sizeof(LogEst)*N;
  memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
  pIdx->aiColumn = (i16*)zExtra;
  zExtra += sizeof(i16)*N;
@@ -2551,7 +2522,7 @@ void sqlite3EndTable(
 #endif

    /* Reparse everything to update our internal data structures */
-    sqlite3VdbeAddParseSchemaOp(pParse, iDb,
+    sqlite3VdbeAddParseSchemaOp(v, iDb,
           sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
  }

@@ -3083,7 +3054,7 @@ void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
  }
  assert( pParse->nErr==0 );
  assert( pName->nSrc==1 );
-  if( !IsSharedSchema(db) && sqlite3ReadSchema(pParse) ) goto exit_drop_table;
+  if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
  if( noErr ) db->suppressErr++;
  assert( isView==0 || isView==LOCATE_VIEW );
  pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
@@ -3095,7 +3066,6 @@ void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
  }
  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
-  sqlite3SchemaWritable(pParse, iDb);

  /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
  ** it is initialized.
@@ -3544,7 +3514,7 @@ void sqlite3CreateIndex(
  if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
    goto exit_create_index;
  }
-  if( !IsSharedSchema(db) && SQLITE_OK!=sqlite3ReadSchema(pParse) ){
+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    goto exit_create_index;
  }
  if( sqlite3HasExplicitNulls(pParse, pList) ){
@@ -4040,7 +4010,7 @@ void sqlite3CreateIndex(
      if( pTblName ){
        sqlite3RefillIndex(pParse, pIndex, iMem);
        sqlite3ChangeCookie(pParse, iDb);
-        sqlite3VdbeAddParseSchemaOp(pParse, iDb,
+        sqlite3VdbeAddParseSchemaOp(v, iDb,
            sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
        sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
      }
@@ -4175,7 +4145,6 @@ void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
    goto exit_drop_index;
  }
  iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
-  sqlite3SchemaWritable(pParse, iDb);
 #ifndef SQLITE_OMIT_AUTHORIZATION
  {
    int code = SQLITE_DROP_INDEX;
@@ -16,63 +16,6 @@

 #include "sqliteInt.h"

-/*
-** Connections opened with the SQLITE_OPEN_SHARED_SCHEMA flag specified
-** may use SchemaPool objects for any database that is not the temp db
-** (iDb==1). For such databases (type "struct Db") there are three states
-** the Schema/SchemaPool object may be in.
-**
-**   1) pSPool==0, pSchema points to an empty object allocated by
-**      sqlite3_malloc(). DB_SchemaLoaded flag is clear.
-**
-**   2) pSPool!=0, pSchema points to a populated object owned by the
-**      SchemaPool. DB_SchemaLoaded flag is set.
-**
-**   3) pSPool!=0, pSchema points to the SchemaPool's static object
-**      (SchemaPool.sSchema).
-*/
-struct SchemaPool {
-  int nRef;                       /* Number of pointers to this object */
-  int nDelete;                    /* Schema objects deleted by ReleaseAll() */
-  u64 cksum;                      /* Checksum for this Schema contents */
-  Schema *pSchema;                /* Linked list of Schema objects */
-  Schema sSchema;                 /* The single dummy schema object */
-  SchemaPool *pNext;              /* Next element in schemaPoolList */
-};
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-#ifdef SQLITE_DEBUG
-static void assert_schema_state_ok(sqlite3 *db){
-  if( IsSharedSchema(db) && db->magic!=SQLITE_MAGIC_ZOMBIE ){
-    int i;
-    for(i=0; i<db->nDb; i++){
-      if( i!=1 ){
-        Db *pDb = &db->aDb[i];
-        Btree *pBt = pDb->pBt;
-        if( pBt==0 ) continue;
-        assert( sqlite3BtreeSchema(pBt, 0, 0)==0 );
-        assert( pDb->pSchema );
-        if( pDb->pSPool ){
-          if( DbHasProperty(db, i, DB_SchemaLoaded)==0 ){
-            assert( pDb->pSchema->tblHash.count==0 );
-            assert( pDb->pSchema==&pDb->pSPool->sSchema );
-          }else{
-            assert( pDb->pSchema!=&pDb->pSPool->sSchema );
-          }
-        }else{
-          assert( DbHasProperty(db, i, DB_SchemaLoaded)==0 );
-          assert( pDb->pSchema->tblHash.count==0 );
-          assert( pDb->pSchema!=&pDb->pSPool->sSchema );
-        }
-      }
-    }
-  }
-}
-#else
-# define assert_schema_state_ok(x)
-#endif
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-
 /*
 ** Invoke the 'collation needed' callback to request a collation sequence
 ** in the encoding enc of name zName, length nName.
@@ -570,317 +513,15 @@ void sqlite3SchemaClear(void *p){
 }

 /*
-** If this database was opened with the SQLITE_OPEN_SHARED_SCHEMA flag
-** and iDb!=1, then disconnect from the schema-pool associated with
-** database iDb. Otherwise, clear the Schema object belonging to
-** database iDb. 
-**
-** If an OOM error occurs while disconnecting from a schema-pool, 
-** the db->mallocFailed flag is set.
-*/
-void sqlite3SchemaClearOrDisconnect(sqlite3 *db, int iDb){
-  Db *pDb = &db->aDb[iDb];
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  if( IsSharedSchema(db) && iDb!=1 && pDb->pSPool ){
-    sqlite3SchemaDisconnect(db, iDb, 1);
-  }else
-#endif
-  {
-    sqlite3SchemaClear(pDb->pSchema);
-  }
-}
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-/*
-** Global linked list of SchemaPool objects. Read and write access must
-** be protected by the SQLITE_MUTEX_STATIC_MASTER mutex.
-*/
-static SchemaPool *SQLITE_WSD schemaPoolList = 0;
-
-#ifdef SQLITE_TEST
-/*
-** Return a pointer to the head of the linked list of SchemaPool objects.
-** This is used by the virtual table in file test_schemapool.c.
-*/
-SchemaPool *sqlite3SchemaPoolList(void){ return schemaPoolList; }
-#endif
-
-/*
-** Database handle db was opened with the SHARED_SCHEMA flag, and database
-** iDb is currently connected to a schema-pool. When this function is called,
-** (*pnByte) is set to nInit plus the amount of memory used to store a 
-** single instance of the Schema objects managed by the schema-pool.
-** This function adjusts (*pnByte) sot hat it is set to nInit plus
-** (nSchema/nRef) of the amount of memory used by a single Schema object,
-** where nSchema is the number of Schema objects allocated by this pool,
-** and nRef is the number of connections to the schema-pool.
-*/
-void sqlite3SchemaAdjustUsed(sqlite3 *db, int iDb, int nInit, int *pnByte){
-  SchemaPool *pSPool = db->aDb[iDb].pSPool;
-  int nSchema = 0;
-  Schema *p;
-  sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-  for(p=pSPool->pSchema; p; p=p->pNext){
-    nSchema++;
-  }
-  *pnByte = nInit + ((*pnByte - nInit) * nSchema) / pSPool->nRef;
-  sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-}
-
-/*
-** Check that the schema of db iDb is writable (either because it is the 
-** temp db schema or because the db handle was opened without
-** SQLITE_OPEN_SHARED_SCHEMA). If so, do nothing. Otherwise, leave an 
-** error in the Parse object.
-*/
-void sqlite3SchemaWritable(Parse *pParse, int iDb){
-  if( iDb!=1 && IsSharedSchema(pParse->db) && IN_DECLARE_VTAB==0 ){
-    sqlite3ErrorMsg(pParse, "attempt to modify read-only schema");
-  }
-}
-
-/*
-** The schema object passed as the only argument was allocated using
-** sqlite3_malloc() and then populated using the usual mechanism. This
-** function frees both the Schema object and its contents.
-*/
-static void schemaDelete(Schema *pSchema){
-  sqlite3SchemaClear((void*)pSchema);
-  sqlite3_free(pSchema);
-}
-
-/*
-** When this function is called, the database connection Db must be
-** using a schema-pool (Db.pSPool!=0) and must currently have Db.pSchema
-** set to point to a populated schema object checked out from the 
-** schema-pool. It is also assumed that the STATIC_MASTER mutex is held.
-** This function returns the Schema object to the schema-pool and sets
-** Db.pSchema to point to the schema-pool's static, empty, Schema object.
-*/
-static void schemaRelease(sqlite3 *db, Db *pDb){
-  Schema *pRelease = pDb->pSchema;
-  SchemaPool *pSPool = pDb->pSPool;
-
-  assert( pDb->pSchema->iGeneration==pSPool->sSchema.iGeneration );
-  pDb->pSchema = &pSPool->sSchema;
-
-  assert( pDb->pSPool && pRelease );
-  assert( pRelease->schemaFlags & DB_SchemaLoaded );
-  assert( (pDb->pSchema->schemaFlags & DB_SchemaLoaded)==0 );
-  assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) );
-
-  /* If the DBFLAG_FreeSchema flag is set and the database connection holds
-  ** at least one other copy of the schema being released, delete it instead
-  ** of returning it to the schema-pool.  */
-  if( db->mDbFlags & DBFLAG_FreeSchema ){
-    int i;
-    for(i=0; i<db->nDb; i++){
-      Db *p = &db->aDb[i];
-      if( p!=pDb && p->pSchema!=&pSPool->sSchema && pDb->pSPool==p->pSPool ){
-        pSPool->nDelete++;
-        schemaDelete(pRelease);
-        return;
-      }
-    }
-  }
-
-  pRelease->pNext = pDb->pSPool->pSchema;
-  pDb->pSPool->pSchema = pRelease;
-}
-
-/*
-** The schema for database iDb of database handle db, which was opened
-** with SQLITE_OPEN_SHARED_SCHEMA, has just been parsed. This function either
-** finds a matching SchemaPool object on the global list (schemaPoolList) or
-** else allocates a new one and sets the Db.pSPool variable accordingly.
-**
-** SQLITE_OK is returned if no error occurs, or an SQLite error code 
-** (SQLITE_NOMEM) otherwise.
-*/
-int sqlite3SchemaConnect(sqlite3 *db, int iDb, u64 cksum){
-  Schema *pSchema = db->aDb[iDb].pSchema;
-  SchemaPool *p;
-
-  assert( pSchema && iDb!=1 && db->aDb[iDb].pSPool==0 );
-
-  sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-
-  /* Search for a matching SchemaPool object */
-  for(p=schemaPoolList; p; p=p->pNext){
-    if( p->cksum==cksum && p->sSchema.schema_cookie==pSchema->schema_cookie ){
-      break;
-    }
-  }
-  if( !p ){
-    /* No SchemaPool object found. Allocate a new one. */
-    p = (SchemaPool*)sqlite3_malloc(sizeof(SchemaPool));
-    if( p ){
-      memset(p, 0, sizeof(SchemaPool));
-      p->cksum = cksum;
-      p->pNext = schemaPoolList;
-      schemaPoolList = p;
-
-      p->sSchema.schema_cookie = pSchema->schema_cookie;
-      p->sSchema.iGeneration = pSchema->iGeneration;
-      p->sSchema.file_format = pSchema->file_format;
-      p->sSchema.enc = pSchema->enc;
-      p->sSchema.cache_size = pSchema->cache_size;
-    }
-  }
-
-  if( p ) p->nRef++;
-
-  /* If the SchemaPool contains one or more free schemas at the moment, 
-  ** delete one of them. */
-  if( p && p->pSchema ){
-    Schema *pDel = p->pSchema;
-    p->pSchema = pDel->pNext;
-    schemaDelete(pDel);
-  }
-
-  sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-
-  db->aDb[iDb].pSPool = p;
-  return (p ? SQLITE_OK : SQLITE_NOMEM);
-}
-
-/*
-** If parameter iDb is 1 (the temp db), or if connection handle db was not
-** opened with the SQLITE_OPEN_SHARED_SCHEMA flag, this function is a no-op.
-** Otherwise, it disconnects from the schema-pool associated with database
-** iDb, assuming it is connected.
-**
-** If parameter bNew is true, then Db.pSchema is set to point to a new, empty,
-** Schema object obtained from sqlite3_malloc(). Or, if bNew is false, then
-** Db.pSchema is set to NULL before returning.
-**
-** If the bNew parameter is true, then this function may allocate memory. 
-** If the allocation attempt fails, then SQLITE_NOMEM is returned and the
-** schema-pool is not disconnected from. Or, if no OOM error occurs, 
-** SQLITE_OK is returned.
-*/
-int sqlite3SchemaDisconnect(sqlite3 *db, int iDb, int bNew){
-  int rc = SQLITE_OK;
-  if( IsSharedSchema(db) ){
-    Db *pDb = &db->aDb[iDb];
-    SchemaPool *pSPool = pDb->pSPool;
-    assert_schema_state_ok(db);
-    assert( pDb->pSchema );
-
-    if( pSPool==0 ){
-      assert( pDb->pVTable==0 );
-      assert( bNew==0 );
-      schemaDelete(pDb->pSchema);
-      pDb->pSchema = 0;
-    }else{
-      VTable *p;
-      VTable *pNext;
-      for(p=pDb->pVTable; p; p=pNext){
-        pNext = p->pNext;
-        sqlite3VtabUnlock(p);
-      }
-      pDb->pVTable = 0;
-      sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-      if( DbHasProperty(db, iDb, DB_SchemaLoaded) ){
-        schemaRelease(db, pDb);
-      }
-      if( bNew ){
-        Schema *pNew = sqlite3SchemaGet(db, 0);
-        if( pNew==0 ){
-          rc = SQLITE_NOMEM;
-        }else{
-          pDb->pSchema = pNew;
-        }
-      }
-      if( rc==SQLITE_OK ){
-        assert( pSPool->nRef>=1 );
-        pDb->pSPool = 0;
-        pSPool->nRef--;
-        if( pSPool->nRef<=0 ){
-          SchemaPool **pp;
-          while( pSPool->pSchema ){
-            Schema *pNext = pSPool->pSchema->pNext;
-            schemaDelete(pSPool->pSchema);
-            pSPool->pSchema = pNext;
-          }
-          for(pp=&schemaPoolList; (*pp)!=pSPool; pp=&((*pp)->pNext));
-          *pp = pSPool->pNext;
-          sqlite3_free(pSPool);
-        }
-      }
-      sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-    }
-  }
-  return rc;
-}
-
-/*
-** Extract and return a pointer to a schema object from the SchemaPool passed
-** as the only argument, if one is available. If one is not available, return
-** NULL.
-*/
-Schema *sqlite3SchemaExtract(SchemaPool *pSPool){
-  Schema *pRet = 0;
-  sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-  if( pSPool->pSchema ){
-    pRet = pSPool->pSchema;
-    pSPool->pSchema = pRet->pNext;
-    pRet->pNext = 0;
-  }
-  sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-  return pRet;
-}
-
-/*
-** Return all sharable schemas held by database handle db back to their
-** respective schema-pools. Db.pSchema variables are left pointing to
-** the static, empty, Schema object owned by each schema-pool.
-*/
-void sqlite3SchemaReleaseAll(sqlite3 *db){
-  int i;
-  assert_schema_state_ok(db);
-  sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-  for(i=0; i<db->nDb; i++){
-    if( i!=1 ){
-      Db *pDb = &db->aDb[i];
-      if( pDb->pSPool && DbHasProperty(db,i,DB_SchemaLoaded) ){
-        schemaRelease(db, pDb);
-      }
-    }
-  }
-  db->mDbFlags &= ~DBFLAG_FreeSchema;
-  sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-}
-
-/*
-** Release any sharable schema held by connection iDb of database handle
-** db. Db.pSchema is left pointing to the static, empty, Schema object
-** owned by the schema-pool.
-*/
-void sqlite3SchemaRelease(sqlite3 *db, int iDb){
-  Db *pDb = &db->aDb[iDb];
-  assert( iDb!=1 );
-  assert_schema_state_ok(db);
-  sqlite3_mutex_enter( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-  schemaRelease(db, pDb);
-  sqlite3_mutex_leave( sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER) );
-}
-
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-
-/*
-** In most cases, this function finds and returns the schema associated 
-** with BTree handle pBt, creating a new one if necessary. However, if
-** the database handle was opened with the SQLITE_OPEN_SHARED_SCHEMA flag
-** specified, a new, empty, Schema object in memory obtained by 
-** sqlite3_malloc() is always returned.
+** Find and return the schema associated with a BTree.  Create
+** a new one if necessary.
 */
 Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
-  Schema *p;
-  if( pBt && IsSharedSchema(db)==0 ){
-    p = (Schema*)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
+  Schema * p;
+  if( pBt ){
+    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
  }else{
-    p = (Schema*)sqlite3DbMallocZero(0, sizeof(Schema));
+    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
  }
  if( !p ){
    sqlite3OomFault(db);
@@ -298,9 +298,6 @@ static const char * const sqlite3azCompileOpt[] = {
 #if SQLITE_ENABLE_SESSION
  "ENABLE_SESSION",
 #endif
-#if SQLITE_ENABLE_SHARED_SCHEMA
-  "ENABLE_SHARED_SCHEMA",
-#endif
 #if SQLITE_ENABLE_SNAPSHOT
  "ENABLE_SNAPSHOT",
 #endif
@@ -425,7 +425,7 @@ void sqlite3DeleteFrom(
  }else
 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
  {
-    u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK|WHERE_SEEK_TABLE;
+    u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK;
    if( sNC.ncFlags & NC_VarSelect ) bComplex = 1;
    wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW);
    if( HasRowid(pTab) ){
@@ -461,6 +461,9 @@ void sqlite3DeleteFrom(
    assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
    assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
    if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse);
+    if( sqlite3WhereUsesDeferredSeek(pWInfo) ){
+      sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur);
+    }
  
    /* Keep track of the number of rows to be deleted */
    if( memCnt ){
@@ -495,6 +498,7 @@ void sqlite3DeleteFrom(
      if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0;
      if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0;
      if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
+      addrBypass = sqlite3VdbeMakeLabel(pParse);
    }else{
      if( pPk ){
        /* Add the PK key for this row to the temporary table */
@@ -508,13 +512,6 @@ void sqlite3DeleteFrom(
        nKey = 1;  /* OP_DeferredSeek always uses a single rowid */
        sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
      }
-    }
-  
-    /* If this DELETE cannot use the ONEPASS strategy, this is the 
-    ** end of the WHERE loop */
-    if( eOnePass!=ONEPASS_OFF ){
-      addrBypass = sqlite3VdbeMakeLabel(pParse);
-    }else{
      sqlite3WhereEnd(pWInfo);
    }
  
@@ -44,7 +44,7 @@ char sqlite3TableColumnAffinity(Table *pTab, int iCol){
 */
 char sqlite3ExprAffinity(const Expr *pExpr){
  int op;
-  while( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){
+  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
@@ -115,7 +115,7 @@ Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
 */
 Expr *sqlite3ExprSkipCollate(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
-    assert( pExpr->op==TK_COLLATE );
+    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
  }   
  return pExpr;
@@ -134,7 +134,7 @@ Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{
-      assert( pExpr->op==TK_COLLATE );
+      assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
      pExpr = pExpr->pLeft;
    }
  }   
@@ -768,7 +768,6 @@ int sqlite3SelectExprHeight(Select *p){
 ** Expr.flags. 
 */
 void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
-  if( pParse->nErr ) return;
  if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){
    p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
  }
@@ -1413,9 +1413,9 @@ void sqlite3FkDelete(sqlite3 *db, Table *pTab){
  FKey *pFKey;                    /* Iterator variable */
  FKey *pNext;                    /* Copy of pFKey->pNextFrom */

-  for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
-    assert( db==0 || IsVirtual(pTab)
+  assert( db==0 || IsVirtual(pTab)
         || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
+  for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){

    /* Remove the FK from the fkeyHash hash table. */
    if( !db || db->pnBytesFreed==0 ){
@@ -1159,17 +1159,6 @@ static void disconnectAllVtab(sqlite3 *db){
        if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
      }
    }
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    if( IsSharedSchema(db) && i!=1 ){
-      VTable *pVTable;
-      VTable *pNext;
-      for(pVTable=db->aDb[i].pVTable; pVTable; pVTable=pNext){
-        pNext = pVTable->pNext;
-        sqlite3VtabUnlock(pVTable);
-      }
-      db->aDb[i].pVTable = 0;
-    }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
  }
  for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){
    Module *pMod = (Module *)sqliteHashData(p);
@@ -1308,7 +1297,6 @@ void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
      sqlite3BtreeClose(pDb->pBt);
      pDb->pBt = 0;
      if( j!=1 ){
-        sqlite3SchemaDisconnect(db, j, 0);
        pDb->pSchema = 0;
      }
    }
@@ -3661,7 +3649,7 @@ int sqlite3_table_column_metadata(
  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
  int *pAutoinc               /* OUTPUT: True if column is auto-increment */
 ){
-  int rc = SQLITE_OK;
+  int rc;
  char *zErrMsg = 0;
  Table *pTab = 0;
  Column *pCol = 0;
@@ -3671,7 +3659,7 @@ int sqlite3_table_column_metadata(
  int notnull = 0;
  int primarykey = 0;
  int autoinc = 0;
-  int bUnlock;
+

 #ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
@@ -3681,29 +3669,14 @@ int sqlite3_table_column_metadata(

  /* Ensure the database schema has been loaded */
  sqlite3_mutex_enter(db->mutex);
-  bUnlock = sqlite3LockReusableSchema(db);
  sqlite3BtreeEnterAll(db);
-  if( IsSharedSchema(db)==0 ){
-    rc = sqlite3Init(db, &zErrMsg);
+  rc = sqlite3Init(db, &zErrMsg);
+  if( SQLITE_OK!=rc ){
+    goto error_out;
  }

  /* Locate the table in question */
-  if( rc==SQLITE_OK ){
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    Parse sParse;                   /* Fake Parse object for FindTable */
-    Parse *pSaved = db->pParse;
-    memset(&sParse, 0, sizeof(sParse));
-    db->pParse = &sParse;
-#endif
-    pTab = sqlite3FindTable(db, zTableName, zDbName);
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    sqlite3_free(sParse.zErrMsg);
-    rc = sParse.rc;
-    db->pParse = pSaved;
-#endif
-  }
-  if( SQLITE_OK!=rc ) goto error_out;
-
+  pTab = sqlite3FindTable(db, zTableName, zDbName);
  if( !pTab || pTab->pSelect ){
    pTab = 0;
    goto error_out;
@@ -3776,7 +3749,6 @@ error_out:
  sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg);
  sqlite3DbFree(db, zErrMsg);
  rc = sqlite3ApiExit(db, rc);
-  sqlite3UnlockReusableSchema(db, bUnlock);
  sqlite3_mutex_leave(db->mutex);
  return rc;
 }
@@ -3850,9 +3822,7 @@ int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
      }
      rc = SQLITE_OK;
    }else{
-      int nSave = db->busyHandler.nBusy;
      rc = sqlite3OsFileControl(fd, op, pArg);
-      db->busyHandler.nBusy = nSave;
    }
    sqlite3BtreeLeave(pBtree);
  }
@@ -1544,9 +1544,6 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
  return rc;
 }

-/* Forward declaration*/
-static int unixSleep(sqlite3_vfs*,int);
-
 /*
 ** Set a posix-advisory-lock.
 **
@@ -1576,7 +1573,7 @@ static int osSetPosixAdvisoryLock(
    ** generic posix, however, there is no such API.  So we simply try the
    ** lock once every millisecond until either the timeout expires, or until
    ** the lock is obtained. */
-    unixSleep(0,1000);
+    usleep(1000);
    rc = osFcntl(h,F_SETLK,pLock);
    tm--;
  }
@@ -2147,7 +2144,6 @@ static int unixClose(sqlite3_file *id){
  }
  sqlite3_mutex_leave(pInode->pLockMutex);
  releaseInodeInfo(pFile);
-  assert( pFile->pShm==0 );
  rc = closeUnixFile(id);
  unixLeaveMutex();
  return rc;
@@ -6547,8 +6543,7 @@ static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){
  UNUSED_PARAMETER(NotUsed);
  return microseconds;
 #elif defined(HAVE_USLEEP) && HAVE_USLEEP
-  if( microseconds>=1000000 ) sleep(microseconds/1000000);
-  if( microseconds%1000000 ) usleep(microseconds%1000000);
+  usleep(microseconds);
  UNUSED_PARAMETER(NotUsed);
  return microseconds;
 #else
@@ -7121,7 +7116,7 @@ static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
      
      if( nTries==1 ){
        conchModTime = buf.st_mtimespec;
-        unixSleep(0,500000); /* wait 0.5 sec and try the lock again*/
+        usleep(500000); /* wait 0.5 sec and try the lock again*/
        continue;  
      }

@@ -7147,7 +7142,7 @@ static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
          /* don't break the lock on short read or a version mismatch */
          return SQLITE_BUSY;
        }
-        unixSleep(0,10000000); /* wait 10 sec and try the lock again */
+        usleep(10000000); /* wait 10 sec and try the lock again */
        continue; 
      }
      
@@ -469,13 +469,7 @@ void sqlite3Pragma(

  /* Make sure the database schema is loaded if the pragma requires that */
  if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){
-    if( IsSharedSchema(db) && (zDb || (pPragma->mPragFlg & PragFlg_OneSchema)) ){
-      assert( iDb>=0 && iDb<db->nDb );
-      pParse->rc = sqlite3SchemaLoad(db, iDb, 0, &pParse->zErrMsg);
-      if( pParse->rc ) goto pragma_out;
-    }else{
-      if( sqlite3ReadSchema(pParse) ) goto pragma_out;
-    }
+    if( sqlite3ReadSchema(pParse) ) goto pragma_out;
  }

  /* Register the result column names for pragmas that return results */
@@ -1909,10 +1903,9 @@ void sqlite3Pragma(
  ** applications for any purpose.
  */
  case PragTyp_HEADER_VALUE: {
-    int iCookie;                  /* Which cookie to read or write */
-    iCookie = pPragma->iArg & PRAGMA_HEADER_VALUE_MASK;     
+    int iCookie = pPragma->iArg;  /* Which cookie to read or write */
    sqlite3VdbeUsesBtree(v, iDb);
-    if( zRight && (pPragma->iArg & PRAGMA_HEADER_VALUE_READONLY)==0 ){
+    if( zRight && (pPragma->mPragFlg & PragFlg_ReadOnly)==0 ){
      /* Write the specified cookie value */
      static const VdbeOpList setCookie[] = {
        { OP_Transaction,    0,  1,  0},    /* 0 */
@@ -55,19 +55,12 @@
 #define PragFlg_NeedSchema 0x01 /* Force schema load before running */
 #define PragFlg_NoColumns  0x02 /* OP_ResultRow called with zero columns */
 #define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */
-#define PragFlg_OneSchema  0x08 /* Only a single schema required */
+#define PragFlg_ReadOnly   0x08 /* Read-only HEADER_VALUE */
 #define PragFlg_Result0    0x10 /* Acts as query when no argument */
 #define PragFlg_Result1    0x20 /* Acts as query when has one argument */
 #define PragFlg_SchemaOpt  0x40 /* Schema restricts name search if present */
 #define PragFlg_SchemaReq  0x80 /* Schema required - "main" is default */

-/* For PragTyp_HEADER_VALUE pragmas the Pragma.iArg value is set
-** to the index of the header field to access (always 10 or less).
-** Ored with HEADER_VALUE_READONLY if the field is read only. */
-#define PRAGMA_HEADER_VALUE_READONLY 0x0100
-#define PRAGMA_HEADER_VALUE_MASK 0x00FF
-
-
 /* Names of columns for pragmas that return multi-column result
 ** or that return single-column results where the name of the
 ** result column is different from the name of the pragma
@@ -162,7 +155,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_AUTOVACUUM)
 {/* zName:     */ "auto_vacuum",
  /* ePragTyp:  */ PragTyp_AUTO_VACUUM,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -183,7 +176,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "cache_size",
  /* ePragTyp:  */ PragTyp_CACHE_SIZE,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -244,21 +237,21 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "data_version",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
-  /* iArg:      */ BTREE_DATA_VERSION|PRAGMA_HEADER_VALUE_READONLY },
+  /* iArg:      */ BTREE_DATA_VERSION },
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "database_list",
  /* ePragTyp:  */ PragTyp_DATABASE_LIST,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0,
  /* ColNames:  */ 41, 3,
  /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
 {/* zName:     */ "default_cache_size",
  /* ePragTyp:  */ PragTyp_DEFAULT_CACHE_SIZE,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 49, 1,
  /* iArg:      */ 0 },
 #endif
@@ -295,7 +288,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_FOREIGN_KEY)
 {/* zName:     */ "foreign_key_list",
  /* ePragTyp:  */ PragTyp_FOREIGN_KEY_LIST,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
  /* ColNames:  */ 0, 8,
  /* iArg:      */ 0 },
 #endif
@@ -311,9 +304,9 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
 {/* zName:     */ "freelist_count",
  /* ePragTyp:  */ PragTyp_HEADER_VALUE,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_ReadOnly|PragFlg_Result0,
  /* ColNames:  */ 0, 0,
-  /* iArg:      */ BTREE_FREE_PAGE_COUNT|PRAGMA_HEADER_VALUE_READONLY },
+  /* iArg:      */ BTREE_FREE_PAGE_COUNT },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 {/* zName:     */ "full_column_names",
@@ -353,7 +346,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_AUTOVACUUM)
 {/* zName:     */ "incremental_vacuum",
  /* ePragTyp:  */ PragTyp_INCREMENTAL_VACUUM,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_NoColumns|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_NoColumns,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -384,7 +377,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "journal_mode",
  /* ePragTyp:  */ PragTyp_JOURNAL_MODE,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "journal_size_limit",
@@ -422,7 +415,7 @@ static const PragmaName aPragmaName[] = {
  /* iArg:      */ 0 },
 {/* zName:     */ "max_page_count",
  /* ePragTyp:  */ PragTyp_PAGE_COUNT,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "mmap_size",
@@ -450,7 +443,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "page_count",
  /* ePragTyp:  */ PragTyp_PAGE_COUNT,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 {/* zName:     */ "page_size",
@@ -549,14 +542,14 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG)
 {/* zName:     */ "stats",
  /* ePragTyp:  */ PragTyp_STATS,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
  /* ColNames:  */ 27, 5,
  /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
 {/* zName:     */ "synchronous",
  /* ePragTyp:  */ PragTyp_SYNCHRONOUS,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1,
  /* ColNames:  */ 0, 0,
  /* iArg:      */ 0 },
 #endif
@@ -640,7 +633,7 @@ static const PragmaName aPragmaName[] = {
  /* iArg:      */ 0 },
 {/* zName:     */ "wal_checkpoint",
  /* ePragTyp:  */ PragTyp_WAL_CHECKPOINT,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_OneSchema,
+  /* ePragFlg:  */ PragFlg_NeedSchema,
  /* ColNames:  */ 44, 3,
  /* iArg:      */ 0 },
 #endif
@@ -34,11 +34,6 @@ static void corruptSchema(
    pData->rc = SQLITE_ERROR;
  }else if( db->flags & SQLITE_WriteSchema ){
    pData->rc = SQLITE_CORRUPT_BKPT;
-  }else if( IsSharedSchema(db) 
-         && 0==sqlite3StrNICmp(zExtra, "malformed database schema", 17)
-  ){
-    pData->rc = SQLITE_CORRUPT_BKPT;
-    *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
  }else{
    char *z;
    if( zObj==0 ) zObj = "?";
@@ -49,28 +44,6 @@ static void corruptSchema(
  }
 }

-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-/*
-** Update the Schema.cksum checksum to account for the database object
-** specified by the three arguments following the first.
-*/
-static void schemaUpdateChecksum(
-  InitData *pData,                /* Schema parse context */
-  const char *zName,              /* Name of new database object */
-  const char *zRoot,              /* Root page of new database object */
-  const char *zSql                /* SQL used to create new database object */
-){
-  int i;
-  u64 cksum = pData->cksum;
-  if( zName ){
-    for(i=0; zName[i]; i++) cksum += (cksum<<3) + zName[i];
-  }
-  if( zRoot ) for(i=0; zRoot[i]; i++) cksum += (cksum<<3) + zRoot[i];
-  if( zSql ) for(i=0; zSql[i]; i++) cksum += (cksum<<3) + zSql[i];
-  pData->cksum = cksum;
-}
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-
 /*
 ** Check to see if any sibling index (another index on the same table)
 ** of pIndex has the same root page number, and if it does, return true.
@@ -94,15 +67,6 @@ static int sqlite3Prepare(
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const char **pzTail       /* OUT: End of parsed string */
 );
-static int sqlite3LockAndPrepare(
-  sqlite3 *db,              /* Database handle. */
-  const char *zSql,         /* UTF-8 encoded SQL statement. */
-  int nBytes,               /* Length of zSql in bytes. */
-  u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
-  Vdbe *pReprepare,         /* VM being reprepared */
-  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
-  const char **pzTail       /* OUT: End of parsed string */
-);


 /*
@@ -161,11 +125,7 @@ int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
    db->init.orphanTrigger = 0;
    db->init.azInit = argv;
    pStmt = 0;
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    TESTONLY(rcp = ) sqlite3LockAndPrepare(db, argv[4], -1, 0, 0, &pStmt, 0);
-#else
    TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
-#endif
    rc = db->errCode;
    assert( (rc&0xFF)==(rcp&0xFF) );
    db->init.iDb = saved_iDb;
@@ -177,12 +137,7 @@ int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
        if( rc > pData->rc ) pData->rc = rc;
        if( rc==SQLITE_NOMEM ){
          sqlite3OomFault(db);
-        }else if( rc!=SQLITE_INTERRUPT 
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-               && (rc&0xFF)!=SQLITE_LOCKED 
-               && (rc&0xFF)!=SQLITE_IOERR
-#endif
-        ){
+        }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
          corruptSchema(pData, argv[1], sqlite3_errmsg(db));
        }
      }
@@ -212,12 +167,6 @@ int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
      }
    }
  }
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  if( IsSharedSchema(db) && iDb!=1 ){
-    schemaUpdateChecksum(pData, argv[0], argv[1], argv[2]);
-  }
-#endif
  return 0;
 }

@@ -245,28 +194,10 @@ int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){

  assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
  assert( iDb>=0 && iDb<db->nDb );
-  assert( db->aDb[iDb].pSchema || (IsSharedSchema(db) && iDb!=1) );
+  assert( db->aDb[iDb].pSchema );
  assert( sqlite3_mutex_held(db->mutex) );
  assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );

-  pDb = &db->aDb[iDb];
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  assert( pDb->pSPool==0 || IsSharedSchema(db) );
-  if( pDb->pSPool ){
-    /* See if there is a free schema object in the schema-pool. If not,
-    ** disconnect from said schema pool and continue. This function will
-    ** connect to a (possibly different) schema-pool before returning. */
-    Schema *pNew = sqlite3SchemaExtract(pDb->pSPool);
-    if( pNew ){
-      pDb->pSchema = pNew;
-      return SQLITE_OK;
-    }
-    rc = sqlite3SchemaDisconnect(db, iDb, 1);
-    if( rc!=SQLITE_OK ) goto error_out;
-    assert( pDb->pSchema && pDb->pSPool==0 );
-  }
-#endif
-
  db->init.busy = 1;

  /* Construct the in-memory representation schema tables (sqlite_schema or
@@ -287,7 +218,6 @@ int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
  initData.pzErrMsg = pzErrMsg;
  initData.mInitFlags = mFlags;
  initData.nInitRow = 0;
-  initData.cksum = 0;
  initData.mxPage = 0;
  sqlite3InitCallback(&initData, 5, (char **)azArg, 0);
  db->mDbFlags &= mask;
@@ -298,6 +228,7 @@ int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){

  /* Create a cursor to hold the database open
  */
+  pDb = &db->aDb[iDb];
  if( pDb->pBt==0 ){
    assert( iDb==1 );
    DbSetProperty(db, 1, DB_SchemaLoaded);
@@ -452,10 +383,6 @@ int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
    rc = SQLITE_OK;
  }

-  if( rc==SQLITE_OK && iDb!=1 && IsSharedSchema(db) ){
-    rc = sqlite3SchemaConnect(db, iDb, initData.cksum);
-  }
-
  /* Jump here for an error that occurs after successfully allocating
  ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
  ** before that point, jump to error_out.
@@ -477,35 +404,6 @@ error_out:
  return rc;
 }

-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-/*
-** If this is a SHARED_SCHEMA connection and the DBFLAG_SchemaInUse flag
-** is not currently set, set it and return non-zero. Otherwise, return 0.
-*/
-int sqlite3LockReusableSchema(sqlite3 *db){
-  if( IsSharedSchema(db) && (db->mDbFlags & DBFLAG_SchemaInuse)==0 ){
-    db->mDbFlags |= DBFLAG_SchemaInuse;
-    return 1;
-  }
-  return 0;
-}
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-/*
-** This function is a no-op for non-SHARED_SCHEMA connections, or if bRelease
-** is zero. Otherwise, clear the DBFLAG_SchemaInuse flag and release all
-** schema references currently held.
-*/
-void sqlite3UnlockReusableSchema(sqlite3 *db, int bRelease){
-  if( bRelease ){
-    db->mDbFlags &= ~DBFLAG_SchemaInuse;
-    sqlite3SchemaReleaseAll(db);
-  }
-}
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-
 /*
 ** Initialize all database files - the main database file, the file
 ** used to store temporary tables, and any additional database files
@@ -516,12 +414,8 @@ void sqlite3UnlockReusableSchema(sqlite3 *db, int bRelease){
 ** bit is set in the flags field of the Db structure. 
 */
 int sqlite3Init(sqlite3 *db, char **pzErrMsg){
-  int rc = SQLITE_OK;
-  int bReleaseSchema;
-  int i;
+  int i, rc;
  int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange);
-
-  bReleaseSchema = sqlite3LockReusableSchema(db);
  
  assert( sqlite3_mutex_held(db->mutex) );
  assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
@@ -531,19 +425,20 @@ int sqlite3Init(sqlite3 *db, char **pzErrMsg){
  /* Do the main schema first */
  if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){
    rc = sqlite3InitOne(db, 0, pzErrMsg, 0);
+    if( rc ) return rc;
  }
  /* All other schemas after the main schema. The "temp" schema must be last */
-  for(i=db->nDb-1; rc==SQLITE_OK && i>0; i--){
+  for(i=db->nDb-1; i>0; i--){
    assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
    if( !DbHasProperty(db, i, DB_SchemaLoaded) ){
      rc = sqlite3InitOne(db, i, pzErrMsg, 0);
+      if( rc ) return rc;
    }
  }
-  if( rc==SQLITE_OK && commit_internal ){
+  if( commit_internal ){
    sqlite3CommitInternalChanges(db);
  }
-  sqlite3UnlockReusableSchema(db, bReleaseSchema);
-  return rc;
+  return SQLITE_OK;
 }

 /*
@@ -555,12 +450,11 @@ int sqlite3ReadSchema(Parse *pParse){
  sqlite3 *db = pParse->db;
  assert( sqlite3_mutex_held(db->mutex) );
  if( !db->init.busy ){
-    db->mDbFlags |= DBFLAG_FreeSchema;      /* For sharable-schema mode */
    rc = sqlite3Init(db, &pParse->zErrMsg);
    if( rc!=SQLITE_OK ){
      pParse->rc = rc;
      pParse->nErr++;
-    }else if( db->noSharedCache && !IsSharedSchema(db) ){
+    }else if( db->noSharedCache ){
      db->mDbFlags |= DBFLAG_SchemaKnownOk;
    }
  }
@@ -586,10 +480,6 @@ static void schemaIsValid(Parse *pParse){
    Btree *pBt = db->aDb[iDb].pBt;     /* Btree database to read cookie from */
    if( pBt==0 ) continue;

-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    if( IsSharedSchema(db) && iDb!=1 && db->aDb[iDb].pSPool==0 ) continue;
-#endif
-
    /* If there is not already a read-only (or read-write) transaction opened
    ** on the b-tree database, open one now. If a transaction is opened, it 
    ** will be closed immediately after reading the meta-value. */
@@ -835,7 +725,6 @@ static int sqlite3LockAndPrepare(
 ){
  int rc;
  int cnt = 0;
-  int bReleaseSchema = 0;

 #ifdef SQLITE_ENABLE_API_ARMOR
  if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
@@ -845,7 +734,6 @@ static int sqlite3LockAndPrepare(
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(db->mutex);
-  bReleaseSchema = sqlite3LockReusableSchema(db);
  sqlite3BtreeEnterAll(db);
  do{
    /* Make multiple attempts to compile the SQL, until it either succeeds
@@ -855,14 +743,9 @@ static int sqlite3LockAndPrepare(
    assert( rc==SQLITE_OK || *ppStmt==0 );
  }while( rc==SQLITE_ERROR_RETRY
       || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) );
-
  sqlite3BtreeLeaveAll(db);
-
-  sqlite3UnlockReusableSchema(db, bReleaseSchema);
-
  rc = sqlite3ApiExit(db, rc);
  assert( (rc&db->errMask)==rc );
-  db->busyHandler.nBusy = 0;
  sqlite3_mutex_leave(db->mutex);
  return rc;
 }
@@ -1075,7 +1075,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
      assert( !ExprHasProperty(pExpr, EP_Reduced) );
      /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
      ** and "x IS NOT FALSE". */
-      if( pRight && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
+      if( pRight && pRight->op==TK_ID ){
        int rc = resolveExprStep(pWalker, pRight);
        if( rc==WRC_Abort ) return WRC_Abort;
        if( pRight->op==TK_TRUEFALSE ){
@@ -3506,7 +3506,7 @@ static Expr *substExpr(
          ifNullRow.op = TK_IF_NULL_ROW;
          ifNullRow.pLeft = pCopy;
          ifNullRow.iTable = pSubst->iNewTable;
-          ifNullRow.flags = EP_IfNullRow;
+          ifNullRow.flags = EP_Skip;
          pCopy = &ifNullRow;
        }
        testcase( ExprHasProperty(pCopy, EP_Subquery) );
@@ -1153,14 +1153,13 @@ struct ShellState {

 /* Allowed values for ShellState.openMode
 */
-#define SHELL_OPEN_UNSPEC       0     /* No open-mode specified */
-#define SHELL_OPEN_NORMAL       1     /* Normal database file */
-#define SHELL_OPEN_APPENDVFS    2     /* Use appendvfs */
-#define SHELL_OPEN_ZIPFILE      3     /* Use the zipfile virtual table */
-#define SHELL_OPEN_READONLY     4     /* Open a normal database read-only */
-#define SHELL_OPEN_DESERIALIZE  5     /* Open using sqlite3_deserialize() */
-#define SHELL_OPEN_HEXDB        6     /* Use "dbtotxt" output as data source */
-#define SHELL_OPEN_SHAREDSCHEMA 7     /* Open for schema reuse */
+#define SHELL_OPEN_UNSPEC      0      /* No open-mode specified */
+#define SHELL_OPEN_NORMAL      1      /* Normal database file */
+#define SHELL_OPEN_APPENDVFS   2      /* Use appendvfs */
+#define SHELL_OPEN_ZIPFILE     3      /* Use the zipfile virtual table */
+#define SHELL_OPEN_READONLY    4      /* Open a normal database read-only */
+#define SHELL_OPEN_DESERIALIZE 5      /* Open using sqlite3_deserialize() */
+#define SHELL_OPEN_HEXDB       6      /* Use "dbtotxt" output as data source */

 /* Allowed values for ShellState.eTraceType
 */
@@ -4047,12 +4046,6 @@ static const char *(azHelp[]) = {
  "      --sha3-384            Use the sha3-384 algorithm",
  "      --sha3-512            Use the sha3-512 algorithm",
  "    Any other argument is a LIKE pattern for tables to hash",
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
-  ".shared-schema CMD DB1 DB2 ...",
-  "    Commands:",
-  "       check                Determine if DB1, DB2, etc have identical schemas",
-  "       fix                  Attempt to make DB1, DB2, etc compatible",
-#endif
 #ifndef SQLITE_NOHAVE_SYSTEM
  ".shell CMD ARGS...       Run CMD ARGS... in a system shell",
 #endif
@@ -4433,19 +4426,6 @@ static void shellIdQuote(
  }
 }

-/*
-** Scalar function "usleep(X)" invokes sqlite3_sleep(X) and returns X.
-*/
-static void shellUSleepFunc(
-  sqlite3_context *context, 
-  int argc, 
-  sqlite3_value **argv
-){
-  int sleep = sqlite3_value_int(argv[0]);
-  sqlite3_sleep(sleep/1000);
-  sqlite3_result_int(context, sleep);
-}
-
 /*
 ** Scalar function "shell_escape_crnl" used by the .recover command.
 ** The argument passed to this function is the output of built-in
@@ -4584,11 +4564,6 @@ static void open_db(ShellState *p, int openFlags){
            SQLITE_OPEN_READONLY|p->openFlags, 0);
        break;
      }
-      case SHELL_OPEN_SHAREDSCHEMA: {
-        sqlite3_open_v2(p->zDbFilename, &p->db,
-          SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_SHARED_SCHEMA,0);
-        break;
-      }
      case SHELL_OPEN_UNSPEC:
      case SHELL_OPEN_NORMAL: {
        sqlite3_open_v2(p->zDbFilename, &p->db,
@@ -4634,8 +4609,6 @@ static void open_db(ShellState *p, int openFlags){
                            shellInt32, 0, 0);
    sqlite3_create_function(p->db, "shell_idquote", 1, SQLITE_UTF8, 0,
                            shellIdQuote, 0, 0);
-    sqlite3_create_function(p->db, "usleep",1,SQLITE_UTF8,0,
-                            shellUSleepFunc, 0, 0);
 #ifndef SQLITE_NOHAVE_SYSTEM
    sqlite3_create_function(p->db, "edit", 1, SQLITE_UTF8, 0,
                            editFunc, 0, 0);
@@ -6781,237 +6754,6 @@ static char *shellMPrintf(int *pRc, const char *zFmt, ...){
  }
  return z;
 }
-static int sharedSchemaFix(ShellState *pState, const char *zDb, int eFix){
-  int rc = SQLITE_OK;
-  i64 iLast = 0;
-  int iCookie = 0;
-  int iAutoVacuum = 0;
-  sqlite3_stmt *pStmt = 0;
-
-  shellExecPrintf(pState->db, &rc, "ATTACH '%q' AS _shared_schema_tmp", zDb);
-  shellExecPrintf(pState->db, &rc, "PRAGMA writable_schema = 1");
-  shellExecPrintf(pState->db, &rc, "BEGIN");
-  shellPreparePrintf(pState->db, &rc, &pStmt, 
-      "SELECT max(rowid) FROM _shared_schema_tmp.sqlite_master"
-  );
-  sqlite3_step(pStmt);
-  iLast = sqlite3_column_int64(pStmt, 0);
-  shellFinalize(&rc, pStmt);
-  shellPreparePrintf(pState->db, &rc, &pStmt,
-      "INSERT INTO _shared_schema_tmp.sqlite_master SELECT "
-      "  type, name, tbl_name, ("
-      "    SELECT rootpage FROM _shared_schema_tmp.sqlite_master WHERE "
-      "      type IS o.type AND name IS o.name AND rowid<=?"
-      "  ), sql FROM main.sqlite_master AS o"
-  );
-  sqlite3_bind_int64(pStmt, 1, iLast);
-  sqlite3_step(pStmt);
-  shellFinalize(&rc, pStmt);
-
-  shellExecPrintf(pState->db, &rc,
-      "DELETE FROM _shared_schema_tmp.sqlite_master WHERE rowid<=%lld",
-      iLast
-  );
-  shellExecPrintf(pState->db, &rc, "COMMIT");
-  sqlite3_exec(pState->db, "PRAGMA writable_schema = 0", 0, 0, 0);
-
-  /* Copy the auto-vacuum setting from main to the target db */
-  shellPreparePrintf(pState->db, &rc, &pStmt, "PRAGMA main.auto_vacuum");
-  sqlite3_step(pStmt);
-  iAutoVacuum = sqlite3_column_int(pStmt, 0);
-  shellFinalize(&rc, pStmt);
-  shellExecPrintf(pState->db, &rc, 
-      "PRAGMA _shared_schema_tmp.auto_vacuum = %d", iAutoVacuum
-  );
-
-  /* Vacuum the db in order to standardize the rootpage numbers. */
-  shellExecPrintf(pState->db, &rc, "VACUUM _shared_schema_tmp");
-
-  /* Set the schema-cookie value to the same as database "main" */
-  shellPreparePrintf(pState->db, &rc, &pStmt, "PRAGMA main.schema_version");
-  sqlite3_step(pStmt);
-  iCookie = sqlite3_column_int(pStmt, 0);
-  shellFinalize(&rc, pStmt);
-  shellExecPrintf(pState->db, &rc, 
-      "PRAGMA _shared_schema_tmp.schema_version = %d", iCookie
-  );
-
-  sqlite3_exec(pState->db, "DETACH _shared_schema_tmp", 0, 0, 0);
-  return rc;
-}
-
-static int sharedSchemaCheck(ShellState *pState, const char *zDb, int *peFix){
-  int rc = SQLITE_OK;
-  int bFailed = 0;
-  sqlite3_stmt *pStmt = 0;
-
-  if( peFix ) *peFix = 0;
-  shellExecPrintf(pState->db, &rc, "ATTACH '%q' AS _shared_schema_tmp", zDb);
-
-  /* Check if this database has the same set of objects as the current db */
-  shellPreparePrintf(pState->db, &rc, &pStmt, 
-    "SELECT type, name FROM _shared_schema_tmp.sqlite_master AS o "
-    "WHERE NOT EXISTS ("
-    "  SELECT 1 FROM main.sqlite_master "
-    "    WHERE name IS o.name AND type IS o.type"
-    ")"
-    " UNION ALL "
-    "SELECT type, name FROM main.sqlite_master AS o "
-    "WHERE NOT EXISTS ("
-    "  SELECT 1 FROM _shared_schema_tmp.sqlite_master "
-    "    WHERE name IS o.name AND type IS o.type"
-    ")"
-  );
-  if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-    utf8_printf(pState->out, "%s is NOT compatible (objects)\n", zDb);
-    bFailed = 1;
-  }
-  shellFinalize(&rc, pStmt);
-
-  /* Check if this database has the same set of SQL statements as the 
-  ** current db. */
-  if( bFailed==0 ){
-    shellPreparePrintf(pState->db, &rc, &pStmt, 
-        "SELECT 1 FROM _shared_schema_tmp.sqlite_master AS o "
-        "WHERE sql IS NOT ("
-        "  SELECT sql FROM main.sqlite_master "
-        "    WHERE name IS o.name AND type IS o.type"
-        ")"
-    );
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-      utf8_printf(pState->out, "%s is NOT compatible (SQL)\n", zDb);
-      bFailed = 1;
-    }
-    shellFinalize(&rc, pStmt);
-  }
-
-  /* Check if this database has the same set of root pages as the current 
-  ** db. */
-  if( bFailed==0 ){
-    shellPreparePrintf(pState->db, &rc, &pStmt, 
-        "SELECT 1 FROM _shared_schema_tmp.sqlite_master AS o "
-        "WHERE rootpage IS NOT ("
-        "  SELECT rootpage FROM main.sqlite_master "
-        "    WHERE name IS o.name AND type IS o.type"
-        ")"
-    );
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-      if( peFix==0 ){
-        utf8_printf(pState->out, "%s is NOT compatible (root pages)\n", zDb);
-      }
-      bFailed = 1;
-      if( peFix ) *peFix = 1;
-    }
-    shellFinalize(&rc, pStmt);
-  }
-
-  if( bFailed==0 ){
-    shellPreparePrintf(pState->db, &rc, &pStmt, 
-        "SELECT 1 WHERE ("
-        "  SELECT group_concat(rootpage || '.' || name || '.' || sql, '.') "
-        "  FROM _shared_schema_tmp.sqlite_master"
-        ") IS NOT ("
-        "  SELECT group_concat(rootpage || '.' || name || '.' || sql, '.') "
-        "  FROM main.sqlite_master"
-        ")"
-    );
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-      if( peFix==0 ){
-        utf8_printf(pState->out, 
-            "%s is NOT compatible (order of sqlite_master rows)\n", zDb
-        );
-      }
-      bFailed = 1;
-      if( peFix ) *peFix = 2;
-    }
-    shellFinalize(&rc, pStmt);
-  }
-
-  if( bFailed==0 ){
-    int iMain = -1;
-    int iNew = +1;
-    shellPreparePrintf(pState->db, &rc, &pStmt, 
-        "PRAGMA main.schema_version"
-    );
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-      iMain = sqlite3_column_int(pStmt, 0);
-    }
-    shellFinalize(&rc, pStmt);
-    shellPreparePrintf(pState->db, &rc, &pStmt, 
-        "PRAGMA _shared_schema_tmp.schema_version"
-    );
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
-      iNew = sqlite3_column_int(pStmt, 0);
-    }
-    shellFinalize(&rc, pStmt);
-    if( rc==SQLITE_OK && iMain!=iNew ){
-      if( peFix==0 ){
-        utf8_printf(pState->out, 
-            "%s is NOT compatible (schema cookie)\n", zDb
-        );
-      }
-      bFailed = 1;
-      if( peFix ) *peFix = 3;
-    }
-  }
-
-  if( rc==SQLITE_OK && bFailed==0 ){
-    utf8_printf(pState->out, "%s is compatible\n", zDb);
-  }
-
-  sqlite3_exec(pState->db, "DETACH _shared_schema_tmp", 0, 0, 0);
-  return rc;
-}
-
-/*
-** .shared-schema check|fix DB1 DB2...
-*/
-static int sharedSchemaDotCommand(
-  ShellState *pState,             /* Current shell tool state */
-  char **azArg,                   /* Array of arguments passed to dot command */
-  int nArg                        /* Number of entries in azArg[] */
-){
-  int rc = SQLITE_OK;
-  int bFix = 0;                   /* Fix databases if possible */
-  int n1;
-  int i;
-  if( nArg<3 ){
-    goto shared_schema_usage;
-  }
-
-  n1 = (int)strlen(azArg[1]);
-  if( n1>0 && n1<=3 && memcmp("fix", azArg[1], n1)==0 ){
-    bFix = 1;
-  }else if( n1==0 || n1>5 || memcmp("check", azArg[1], n1) ){
-    goto shared_schema_usage;
-  }
-
-  for(i=2; rc==SQLITE_OK && i<nArg; i++){
-    int eFix = 0;
-    rc = sharedSchemaCheck(pState, azArg[i], bFix ? &eFix : 0);
-    if( rc==SQLITE_OK && bFix && eFix ){
-      utf8_printf(pState->out, "Fixing %s... ", azArg[i]);
-      fflush(pState->out);
-      rc = sharedSchemaFix(pState, azArg[i], eFix);
-      if( rc==SQLITE_OK ){
-        rc = sharedSchemaCheck(pState, azArg[i], &eFix);
-        if( rc==SQLITE_OK && eFix ){
-          utf8_printf(pState->out, "VACUUMing main... ");
-          fflush(pState->out);
-          rc = sqlite3_exec(pState->db, "VACUUM main", 0, 0, 0);
-          if( rc==SQLITE_OK ){
-            rc = sharedSchemaCheck(pState, azArg[i], 0);
-          }
-        }
-      }
-    }
-  }
-
-  return rc;
- shared_schema_usage:
-  raw_printf(stderr, "usage: .shared-schema check|fix DB1 DB2...\n");
-  return SQLITE_ERROR;
-}

 /*
 ** When running the ".recover" command, each output table, and the special
@@ -8903,8 +8645,6 @@ static int do_meta_command(char *zLine, ShellState *p){
        p->openMode = SHELL_OPEN_APPENDVFS;
      }else if( optionMatch(z, "readonly") ){
        p->openMode = SHELL_OPEN_READONLY;
-      }else if( optionMatch(z, "sharedschema") ){
-        p->openMode = SHELL_OPEN_SHAREDSCHEMA;
      }else if( optionMatch(z, "nofollow") ){
        p->openFlags |= SQLITE_OPEN_NOFOLLOW;
 #ifdef SQLITE_ENABLE_DESERIALIZE
@@ -9889,13 +9629,6 @@ static int do_meta_command(char *zLine, ShellState *p){
    sqlite3_free(zSql);
  }else

-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
-  if( c=='s' && strncmp(azArg[0], "shared-schema", n)==0 ){
-    open_db(p, 0);
-    sharedSchemaDotCommand(p, azArg, nArg);
-  }else
-#endif
-
 #ifndef SQLITE_NOHAVE_SYSTEM
  if( c=='s'
   && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
@@ -11198,8 +10931,6 @@ int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
 #endif
    }else if( strcmp(z,"-readonly")==0 ){
      data.openMode = SHELL_OPEN_READONLY;
-    }else if( strcmp(z,"-sharedschema")==0 ){
-      data.openMode = SHELL_OPEN_SHAREDSCHEMA;
    }else if( strcmp(z,"-nofollow")==0 ){
      data.openFlags = SQLITE_OPEN_NOFOLLOW;
 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_HAVE_ZLIB)
@@ -11313,8 +11044,6 @@ int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
 #endif
    }else if( strcmp(z,"-readonly")==0 ){
      data.openMode = SHELL_OPEN_READONLY;
-    }else if( strcmp(z,"-sharedschema")==0 ){
-      data.openMode = SHELL_OPEN_SHAREDSCHEMA;
    }else if( strcmp(z,"-nofollow")==0 ){
      data.openFlags |= SQLITE_OPEN_NOFOLLOW;
    }else if( strcmp(z,"-ascii")==0 ){
@@ -573,11 +573,10 @@ int sqlite3_exec(
 #define SQLITE_OPEN_NOFOLLOW         0x01000000  /* Ok for sqlite3_open_v2() */

 /* Reserved:                         0x00F00000 */
-#define SQLITE_OPEN_SHARED_SCHEMA    0x01000000  /* Ok for sqlite3_open_v2() */
-
 /* Legacy compatibility: */
 #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */

+
 /*
 ** CAPI3REF: Device Characteristics
 **
@@ -1113,7 +1113,6 @@ typedef struct CollSeq CollSeq;
 typedef struct Column Column;
 typedef struct Db Db;
 typedef struct Schema Schema;
-typedef struct SchemaPool SchemaPool;
 typedef struct Expr Expr;
 typedef struct ExprList ExprList;
 typedef struct FKey FKey;
@@ -1247,10 +1246,6 @@ struct Db {
  u8 safety_level;     /* How aggressive at syncing data to disk */
  u8 bSyncSet;         /* True if "PRAGMA synchronous=N" has been run */
  Schema *pSchema;     /* Pointer to database schema (possibly shared) */
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  SchemaPool *pSPool;  /* For REUSE_SCHEMA mode */
-  VTable *pVTable;     /* List of all VTable objects (REUSE_SCHEMA mode only) */
-#endif
 };

 /*
@@ -1282,9 +1277,6 @@ struct Schema {
  u8 enc;              /* Text encoding used by this database */
  u16 schemaFlags;     /* Flags associated with this schema */
  int cache_size;      /* Number of pages to use in the cache */
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  Schema *pNext;       /* Next Schema object SchemaPool (REUSE_SCHEMA) */
-#endif
 };

 /*
@@ -1600,12 +1592,6 @@ struct sqlite3 {
 #endif
 };

-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-# define IsSharedSchema(db) (((db)->openFlags & SQLITE_OPEN_SHARED_SCHEMA)!=0)
-#else
-# define IsSharedSchema(db) 0
-#endif
-
 /*
 ** A macro to discover the encoding of a database.
 */
@@ -1686,9 +1672,6 @@ struct sqlite3 {
 #define DBFLAG_InternalFunc   0x0020  /* Allow use of internal functions */
 #define DBFLAG_EncodingFixed  0x0040  /* No longer possible to change enc. */

-#define DBFLAG_SchemaInuse    0x0080  /* Do not release sharable schemas */
-#define DBFLAG_FreeSchema     0x0100  /* Free extra shared schemas on release */
-
 /*
 ** Bits of the sqlite3.dbOptFlags field that are used by the
 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
@@ -2129,9 +2112,6 @@ struct VTable {
  u8 eVtabRisk;             /* Riskiness of allowing hacker access */
  int iSavepoint;           /* Depth of the SAVEPOINT stack */
  VTable *pNext;            /* Next in linked list (see above) */
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  char *zName;              /* Table name (REUSE_SCHEMA mode) */
-#endif
 };

 /* Allowed values for VTable.eVtabRisk
@@ -2735,7 +2715,7 @@ struct Expr {
 #define EP_TokenOnly  0x004000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */
 #define EP_Win        0x008000 /* Contains window functions */
 #define EP_MemToken   0x010000 /* Need to sqlite3DbFree() Expr.zToken */
-#define EP_IfNullRow  0x020000 /* The TK_IF_NULL_ROW opcode */
+                  /*  0x020000 // available for reuse */
 #define EP_Unlikely   0x040000 /* unlikely() or likelihood() function */
 #define EP_ConstFunc  0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
 #define EP_CanBeNull  0x100000 /* Can be null despite NOT NULL constraint */
@@ -2973,9 +2953,9 @@ struct SrcList {
 #define WHERE_DISTINCTBY       0x0080 /* pOrderby is really a DISTINCT clause */
 #define WHERE_WANT_DISTINCT    0x0100 /* All output needs to be distinct */
 #define WHERE_SORTBYGROUP      0x0200 /* Support sqlite3WhereIsSorted() */
-#define WHERE_SEEK_TABLE       0x0400 /* Do not defer seeks on main table */
+                        /*     0x0400    not currently used */
 #define WHERE_ORDERBY_LIMIT    0x0800 /* ORDERBY+LIMIT on the inner loop */
-#define WHERE_SEEK_UNIQ_TABLE  0x1000 /* Do not defer seeks if unique */
+                        /*     0x1000    not currently used */
                        /*     0x2000    not currently used */
 #define WHERE_USE_LIMIT        0x4000 /* Use the LIMIT in cost estimates */
                        /*     0x8000    not currently used */
@@ -3379,6 +3359,7 @@ struct Parse {
  AutoincInfo *pAinc;  /* Information about AUTOINCREMENT counters */
  Parse *pToplevel;    /* Parse structure for main program (or NULL) */
  Table *pTriggerTab;  /* Table triggers are being coded for */
+  Parse *pParentParse; /* Parent parser if this parser is nested */
  AggInfo *pAggList;   /* List of all AggInfo objects */
  int addrCrTab;       /* Address of OP_CreateBtree opcode on CREATE TABLE */
  u32 nQueryLoop;      /* Est number of iterations of a query (10*log2(N)) */
@@ -3541,9 +3522,6 @@ struct Trigger {
  Schema *pTabSchema;     /* Schema containing the table */
  TriggerStep *step_list; /* Link list of trigger program steps             */
  Trigger *pNext;         /* Next trigger associated with the table */
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  char *zTabSchema;       /* Temp triggers in IsSharedSchema() dbs only */
-#endif
 };

 /*
@@ -3656,7 +3634,6 @@ typedef struct {
  int rc;             /* Result code stored here */
  u32 mInitFlags;     /* Flags controlling error messages */
  u32 nInitRow;       /* Number of rows processed */
-  u64 cksum;          /* Schema checksum for REUSE_SCHEMA mode */
  Pgno mxPage;        /* Maximum page number.  0 for no limit. */
 } InitData;

@@ -4666,29 +4643,6 @@ void sqlite3DefaultRowEst(Index*);
 void sqlite3RegisterLikeFunctions(sqlite3*, int);
 int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
 void sqlite3SchemaClear(void *);
-void sqlite3SchemaClearOrDisconnect(sqlite3*, int);
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA 
-int sqlite3SchemaConnect(sqlite3*, int, u64);
-int sqlite3SchemaDisconnect(sqlite3 *, int, int);
-Schema *sqlite3SchemaExtract(SchemaPool*);
-int sqlite3SchemaLoad(sqlite3*, int, int*, char**);
-void sqlite3SchemaReleaseAll(sqlite3*);
-void sqlite3SchemaRelease(sqlite3*, int);
-void sqlite3SchemaAdjustUsed(sqlite3*, int, int, int*);
-void sqlite3SchemaWritable(Parse*, int);
-void sqlite3UnlockReusableSchema(sqlite3 *db, int bRelease);
-int sqlite3LockReusableSchema(sqlite3 *db);
-#else
-# define sqlite3SchemaWritable(x,y)
-# define sqlite3UnlockReusableSchema(x,y)
-# define sqlite3LockReusableSchema(x) 0
-# define sqlite3SchemaDisconnect(x,y,z) SQLITE_OK
-# define sqlite3SchemaLoad(w,x,y,z) SQLITE_OK
-# define sqlite3SchemaRelease(y,z)
-# define sqlite3SchemaConnect(x,y,z) SQLITE_OK
-#endif
-
 Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
 int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
 KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int);
@@ -60,7 +60,11 @@
 ** The maximum depth of an expression tree. This is limited to 
 ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might 
 ** want to place more severe limits on the complexity of an 
-** expression. A value of 0 means that there is no limit.
+** expression.
+**
+** A value of 0 used to mean that the limit was not enforced.
+** But that is no longer true.  The limit is now strictly enforced
+** at all times.
 */
 #ifndef SQLITE_MAX_EXPR_DEPTH
 # define SQLITE_MAX_EXPR_DEPTH 1000
@@ -288,24 +288,11 @@ int sqlite3_db_status(
    case SQLITE_DBSTATUS_SCHEMA_USED: {
      int i;                      /* Used to iterate through schemas */
      int nByte = 0;              /* Used to accumulate return value */
-      int bReleaseSchema;

      sqlite3BtreeEnterAll(db);
-      bReleaseSchema = sqlite3LockReusableSchema(db);
      db->pnBytesFreed = &nByte;
      for(i=0; i<db->nDb; i++){
-        Schema *pSchema;
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-        int bUnload = 0;
-        int nUsed = nByte;
-        if( db->aDb[i].pSPool ){
-          char *zDummy = 0;
-          rc = sqlite3SchemaLoad(db, i, &bUnload, &zDummy);
-          sqlite3_free(zDummy);
-          if( rc ) break;
-        }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-        pSchema = db->aDb[i].pSchema;
+        Schema *pSchema = db->aDb[i].pSchema;
        if( ALWAYS(pSchema!=0) ){
          HashElem *p;

@@ -327,14 +314,7 @@ int sqlite3_db_status(
            sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
          }
        }
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-        if( db->aDb[i].pSPool ){
-          if( bUnload ) sqlite3SchemaRelease(db, i);
-          sqlite3SchemaAdjustUsed(db, i, nUsed, &nByte);
-        }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
      }
-      sqlite3UnlockReusableSchema(db, bReleaseSchema);
      db->pnBytesFreed = 0;
      sqlite3BtreeLeaveAll(db);

@@ -3666,9 +3666,6 @@ static int sqliteCmdUsage(
    "HANDLE ?FILENAME? ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"
    " ?-nofollow BOOLEAN?"
    " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    " ?-shared-schema BOOLEAN?"
-#endif
  );
  return TCL_ERROR;
 }
@@ -3800,16 +3797,6 @@ static int SQLITE_TCLAPI DbMain(
      }else{
        flags &= ~SQLITE_OPEN_URI;
      }
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    }else if( strcmp(zArg, "-shared-schema")==0 ){
-      int b;
-      if( Tcl_GetBooleanFromObj(interp, objv[i], &b) ) return TCL_ERROR;
-      if( b ){
-        flags |= SQLITE_OPEN_SHARED_SCHEMA;
-      }else{
-        flags &= ~SQLITE_OPEN_SHARED_SCHEMA;
-      }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
    }else if( strcmp(zArg, "-translatefilename")==0 ){
      if( Tcl_GetBooleanFromObj(interp, objv[i], &bTranslateFileName) ){
        return TCL_ERROR;
@@ -764,12 +764,6 @@ Tcl_SetVar2(interp, "sqlite_options", "mergesort", "1", TCL_GLOBAL_ONLY);
  Tcl_SetVar2(interp, "sqlite_options", "windowfunc", "1", TCL_GLOBAL_ONLY);
 #endif

-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  Tcl_SetVar2(interp, "sqlite_options", "sharedschema", "1", TCL_GLOBAL_ONLY);
-#else
-  Tcl_SetVar2(interp, "sqlite_options", "sharedschema", "0", TCL_GLOBAL_ONLY);
-#endif
-
 #define LINKVAR(x) { \
    static const int cv_ ## x = SQLITE_ ## x; \
    Tcl_LinkVar(interp, "SQLITE_" #x, (char *)&(cv_ ## x), \
@@ -1,282 +0,0 @@
-/*
-** 2006 June 10
-**
-** 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.
-**
-*************************************************************************
-** Code for testing the virtual table interfaces.  This code
-** is not included in the SQLite library.  It is used for automated
-** testing of the SQLite library.
-*/
-
-/*
-** None of this works unless we have virtual tables.
-*/
-#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_TEST)
-
-#include <tcl.h>
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-
-#include "sqliteInt.h"
-
-/* The code in this file defines a sqlite3 virtual-table module with
-** the following schema.
-*/
-#define SCHEMAPOOL_SCHEMA \
-"CREATE TABLE x("         \
-"  cksum   INTEGER, "     \
-"  nref    INTEGER, "     \
-"  nschema INTEGER, "     \
-"  ndelete INTEGER  "     \
-")"
-
-#define SCHEMAPOOL_NFIELD 4
-
-typedef struct schemapool_vtab schemapool_vtab;
-typedef struct schemapool_cursor schemapool_cursor;
-
-/* A schema table object */
-struct schemapool_vtab {
-  sqlite3_vtab base;
-};
-
-/* A schema table cursor object */
-struct schemapool_cursor {
-  sqlite3_vtab_cursor base;
-  sqlite3_int64 *aData;
-  int iRow;
-  int nRow;
-};
-
-/*
-** Table destructor for the schema module.
-*/
-static int schemaPoolDestroy(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return 0;
-}
-
-/*
-** Table constructor for the schema module.
-*/
-static int schemaPoolCreate(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  int rc = SQLITE_NOMEM;
-  schemapool_vtab *pVtab = sqlite3_malloc(sizeof(schemapool_vtab));
-  if( pVtab ){
-    memset(pVtab, 0, sizeof(schemapool_vtab));
-    rc = sqlite3_declare_vtab(db, SCHEMAPOOL_SCHEMA);
-    if( rc!=SQLITE_OK ){
-      sqlite3_free(pVtab);
-      pVtab = 0;
-    }
-  }
-  *ppVtab = (sqlite3_vtab *)pVtab;
-  return rc;
-}
-
-/*
-** Open a new cursor on the schema table.
-*/
-static int schemaPoolOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
-  int rc = SQLITE_NOMEM;
-  schemapool_cursor *pCur;
-  pCur = sqlite3_malloc(sizeof(schemapool_cursor));
-  if( pCur ){
-    memset(pCur, 0, sizeof(schemapool_cursor));
-    *ppCursor = (sqlite3_vtab_cursor*)pCur;
-    rc = SQLITE_OK;
-  }
-  return rc;
-}
-
-/*
-** Close a schema table cursor.
-*/
-static int schemaPoolClose(sqlite3_vtab_cursor *cur){
-  schemapool_cursor *pCur = (schemapool_cursor*)cur;
-  sqlite3_free(pCur->aData);
-  sqlite3_free(pCur);
-  return SQLITE_OK;
-}
-
-/*
-** Retrieve a column of data.
-*/
-static int schemaPoolColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
-  schemapool_cursor *pCur = (schemapool_cursor*)cur;
-  assert( i==0 || i==1 || i==2 || i==3 );
-  sqlite3_result_int64(ctx, pCur->aData[pCur->iRow*SCHEMAPOOL_NFIELD + i]);
-  return SQLITE_OK;
-}
-
-/*
-** Retrieve the current rowid.
-*/
-static int schemaPoolRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
-  schemapool_cursor *pCur = (schemapool_cursor*)cur;
-  *pRowid = pCur->iRow + 1;
-  return SQLITE_OK;
-}
-
-static int schemaPoolEof(sqlite3_vtab_cursor *cur){
-  schemapool_cursor *pCur = (schemapool_cursor*)cur;
-  return pCur->iRow>=pCur->nRow;
-}
-
-/*
-** Advance the cursor to the next row.
-*/
-static int schemaPoolNext(sqlite3_vtab_cursor *cur){
-  schemapool_cursor *pCur = (schemapool_cursor*)cur;
-  pCur->iRow++;
-  return SQLITE_OK;
-}
-
-struct SchemaPool {
-  int nRef;                       /* Number of pointers to this object */
-  int nDelete;                    /* Schema objects deleted by ReleaseAll() */
-  u64 cksum;                      /* Checksum for this Schema contents */
-  Schema *pSchema;                /* Linked list of Schema objects */
-  Schema sSchema;                 /* The single dummy schema object */
-  SchemaPool *pNext;              /* Next element in schemaPoolList */
-};
-extern SchemaPool *sqlite3SchemaPoolList(void);
-
-/*
-** Reset a schemaPool table cursor.
-*/
-static int schemaPoolFilter(
-  sqlite3_vtab_cursor *pVtabCursor, 
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  SchemaPool *pSPool;
-  schemapool_cursor *pCur = (schemapool_cursor*)pVtabCursor;
-
-  sqlite3_free(pCur->aData);
-  pCur->aData = 0;
-  pCur->nRow = 0;
-  pCur->iRow = 0;
-
-  for(pSPool = sqlite3SchemaPoolList(); pSPool; pSPool=pSPool->pNext){
-    pCur->nRow++;
-  }
-
-  if( pCur->nRow ){
-    int iRow = 0;
-    int nByte = SCHEMAPOOL_NFIELD * pCur->nRow * sizeof(i64);
-    pCur->aData = (i64*)sqlite3_malloc(nByte);
-    if( pCur->aData==0 ) return SQLITE_NOMEM;
-    for(pSPool = sqlite3SchemaPoolList(); pSPool; pSPool=pSPool->pNext){
-      Schema *p;
-      i64 nSchema = 0;
-      for(p=pSPool->pSchema; p; p=p->pNext){
-        nSchema++;
-      }
-      pCur->aData[0 + iRow*SCHEMAPOOL_NFIELD] = pSPool->cksum;
-      pCur->aData[1 + iRow*SCHEMAPOOL_NFIELD] = (i64)pSPool->nRef;
-      pCur->aData[2 + iRow*SCHEMAPOOL_NFIELD] = nSchema;
-      pCur->aData[3 + iRow*SCHEMAPOOL_NFIELD] = (i64)pSPool->nDelete;
-      iRow++;
-    }
-  }
-
-  return SQLITE_OK;
-}
-
-/*
-** Analyse the WHERE condition.
-*/
-static int schemaPoolBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
-  return SQLITE_OK;
-}
-
-/*
-** A virtual table module that merely echos method calls into TCL
-** variables.
-*/
-static sqlite3_module schemaPoolModule = {
-  0,                           /* iVersion */
-  schemaPoolCreate,
-  schemaPoolCreate,
-  schemaPoolBestIndex,
-  schemaPoolDestroy,
-  schemaPoolDestroy,
-  schemaPoolOpen,              /* xOpen - open a cursor */
-  schemaPoolClose,             /* xClose - close a cursor */
-  schemaPoolFilter,            /* xFilter - configure scan constraints */
-  schemaPoolNext,              /* xNext - advance a cursor */
-  schemaPoolEof,               /* xEof */
-  schemaPoolColumn,            /* xColumn - read data */
-  schemaPoolRowid,             /* xRowid - read data */
-  0,                           /* xUpdate */
-  0,                           /* xBegin */
-  0,                           /* xSync */
-  0,                           /* xCommit */
-  0,                           /* xRollback */
-  0,                           /* xFindMethod */
-  0,                           /* xRename */
-};
-
-/*
-** Decode a pointer to an sqlite3 object.
-*/
-extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
-
-/*
-** Register the schema virtual table module.
-*/
-static int SQLITE_TCLAPI register_schemapool_module(
-  ClientData clientData, /* Not used */
-  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
-  int objc,              /* Number of arguments */
-  Tcl_Obj *CONST objv[]  /* Command arguments */
-){
-  sqlite3 *db;
-  if( objc!=2 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "DB");
-    return TCL_ERROR;
-  }
-  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  sqlite3_create_module(db, "schemapool", &schemaPoolModule, 0);
-#endif
-  return TCL_OK;
-}
-
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_TEST) */
-
-/*
-** Register commands with the TCL interpreter.
-*/
-int Sqlitetestschemapool_Init(Tcl_Interp *interp){
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  static struct {
-     char *zName;
-     Tcl_ObjCmdProc *xProc;
-     void *clientData;
-  } aObjCmd[] = {
-     { "register_schemapool_module", register_schemapool_module, 0 },
-  };
-  int i;
-  for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
-    Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
-        aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
-  }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-  return TCL_OK;
-}
-
@@ -77,7 +77,6 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
  extern int Sqlitetest_malloc_Init(Tcl_Interp*);
  extern int Sqlitetest_mutex_Init(Tcl_Interp*);
  extern int Sqlitetestschema_Init(Tcl_Interp*);
-  extern int Sqlitetestschemapool_Init(Tcl_Interp*);
  extern int Sqlitetestsse_Init(Tcl_Interp*);
  extern int Sqlitetesttclvar_Init(Tcl_Interp*);
  extern int Sqlitetestfs_Init(Tcl_Interp*);
@@ -148,7 +147,6 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
  Sqlitetest_malloc_Init(interp);
  Sqlitetest_mutex_Init(interp);
  Sqlitetestschema_Init(interp);
-  Sqlitetestschemapool_Init(interp);
  Sqlitetesttclvar_Init(interp);
  Sqlitetestfs_Init(interp);
  SqlitetestThread_Init(interp);
@@ -562,7 +562,6 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  int lastTokenParsed = -1;       /* type of the previous token */
  sqlite3 *db = pParse->db;       /* The database connection */
  int mxSqlLen;                   /* Max length of an SQL string */
-  Parse *pParentParse = db->pParse;
 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
  yyParser sEngine;    /* Space to hold the Lemon-generated Parser object */
 #endif
@@ -598,6 +597,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  assert( pParse->pNewTrigger==0 );
  assert( pParse->nVar==0 );
  assert( pParse->pVList==0 );
+  pParse->pParentParse = db->pParse;
  db->pParse = pParse;
  while( 1 ){
    n = sqlite3GetToken((u8*)zSql, &tokenType);
@@ -724,7 +724,8 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
    pParse->pZombieTab = p->pNextZombie;
    sqlite3DeleteTable(db, p);
  }
-  db->pParse = pParentParse;
+  db->pParse = pParse->pParentParse;
+  pParse->pParentParse = 0;
  assert( nErr==0 || pParse->rc!=SQLITE_OK );
  return nErr;
 }
@@ -56,30 +56,15 @@ Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
  }

  if( pTmpSchema!=pTab->pSchema ){
-    sqlite3 *db = pParse->db;
    HashElem *p;
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-    char *zSchema = 0;
-    if( IsSharedSchema(db) ){
-      zSchema = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
-    }
-#endif
-    assert( sqlite3SchemaMutexHeld(db, 0, pTmpSchema) );
+    assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
    for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){
      Trigger *pTrig = (Trigger *)sqliteHashData(p);
-
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-      if( (zSchema==0 && pTrig->pTabSchema==pTab->pSchema)
-       || (zSchema!=0 && 0==sqlite3StrICmp(pTrig->zTabSchema, zSchema)) )
-#else 
-      if( pTrig->pTabSchema==pTab->pSchema )
-#endif
-      {
-        if( 0==sqlite3StrICmp(pTrig->table, pTab->zName) ){
-          pTrig->pTabSchema = pTab->pSchema;
-          pTrig->pNext = (pList ? pList : pTab->pTrigger);
-          pList = pTrig;
-        }
+      if( pTrig->pTabSchema==pTab->pSchema
+       && 0==sqlite3StrICmp(pTrig->table, pTab->zName) 
+      ){
+        pTrig->pNext = (pList ? pList : pTab->pTrigger);
+        pList = pTrig;
      }
    }
  }
@@ -264,12 +249,6 @@ void sqlite3BeginTrigger(
  pTrigger->zName = zName;
  zName = 0;
  pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  if( IsSharedSchema(db) && iDb==1 ){
-    int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    pTrigger->zTabSchema = sqlite3DbStrDup(db, db->aDb[iTabDb].zDbSName);
-  }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
  pTrigger->pSchema = db->aDb[iDb].pSchema;
  pTrigger->pTabSchema = pTab->pSchema;
  pTrigger->op = (u8)op;
@@ -359,7 +338,7 @@ void sqlite3FinishTrigger(
       pTrig->table, z);
    sqlite3DbFree(db, z);
    sqlite3ChangeCookie(pParse, iDb);
-    sqlite3VdbeAddParseSchemaOp(pParse, iDb,
+    sqlite3VdbeAddParseSchemaOp(v, iDb,
        sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
  }

@@ -577,9 +556,6 @@ void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
  sqlite3DeleteTriggerStep(db, pTrigger->step_list);
  sqlite3DbFree(db, pTrigger->zName);
  sqlite3DbFree(db, pTrigger->table);
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  sqlite3DbFree(db, pTrigger->zTabSchema);
-#endif
  sqlite3ExprDelete(db, pTrigger->pWhen);
  sqlite3IdListDelete(db, pTrigger->pColumns);
  sqlite3DbFree(db, pTrigger);
@@ -651,7 +627,6 @@ void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){

  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
-  sqlite3SchemaWritable(pParse, iDb);
  pTable = tableOfTrigger(pTrigger);
  assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
 #ifndef SQLITE_OMIT_AUTHORIZATION
@@ -705,7 +705,7 @@ void sqlite3Update(
      ** be deleted as a result of REPLACE conflict handling. Any of these
      ** things might disturb a cursor being used to scan through the table
      ** or index, causing a single-pass approach to malfunction.  */
-      flags = WHERE_ONEPASS_DESIRED|WHERE_SEEK_UNIQ_TABLE;
+      flags = WHERE_ONEPASS_DESIRED;
      if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
        flags |= WHERE_ONEPASS_MULTIROW;
      }
@@ -681,7 +681,6 @@ int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
    incr = 1;
  }else{
    incr = 2;
-    length &= ~1;
    assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
    for(i=3-enc; i<length && zNum[i]==0; i+=2){}
    nonNum = i<length;
@@ -125,7 +125,6 @@ void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){
  }
  if( iDb!=1 ){
    int iIntoReg = 0;
-    sqlite3SchemaWritable(pParse, iDb);
    if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){
      iIntoReg = ++pParse->nMem;
      sqlite3ExprCode(pParse, pInto, iIntoReg);
@@ -3570,6 +3570,13 @@ case OP_Transaction: {
   && (iMeta!=pOp->p3
      || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
  ){
+    /*
+    ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
+    ** version is checked to ensure that the schema has not changed since the
+    ** SQL statement was prepared.
+    */
+    sqlite3DbFree(db, p->zErrMsg);
+    p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
    /* If the schema-cookie from the database file matches the cookie 
    ** stored with the in-memory representation of the schema, do
    ** not reload the schema from the database file.
@@ -3586,13 +3593,6 @@ case OP_Transaction: {
    if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
      sqlite3ResetOneSchema(db, pOp->p1);
    }
-    /*
-    ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
-    ** version is checked to ensure that the schema has not changed since the
-    ** SQL statement was prepared.
-    */
-    sqlite3DbFree(db, p->zErrMsg);
-    p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
    p->expired = 1;
    rc = SQLITE_SCHEMA;
  }
@@ -223,7 +223,7 @@ VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);
 #else
 # define sqlite3ExplainBreakpoint(A,B) /*no-op*/
 #endif
-void sqlite3VdbeAddParseSchemaOp(Parse*,int,char*);
+void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
 void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8);
 void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
 void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
@@ -471,10 +471,8 @@ void sqlite3VdbeExplainPop(Parse *pParse){
 ** The zWhere string must have been obtained from sqlite3_malloc().
 ** This routine will take ownership of the allocated memory.
 */
-void sqlite3VdbeAddParseSchemaOp(Parse *pParse, int iDb, char *zWhere){
-  Vdbe *p = pParse->pVdbe;
+void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
  int j;
-  sqlite3SchemaWritable(pParse, iDb);
  sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
  for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
 }
@@ -131,9 +131,7 @@ int sqlite3_blob_open(
  char *zErr = 0;
  Table *pTab;
  Incrblob *pBlob = 0;
-  Parse *pParentParse = db->pParse;
  Parse sParse;
-  int bUnlock;            /* True to unlock reusable schemas before returning */

 #ifdef SQLITE_ENABLE_API_ARMOR
  if( ppBlob==0 ){
@@ -150,13 +148,11 @@ int sqlite3_blob_open(

  sqlite3_mutex_enter(db->mutex);

-  bUnlock = sqlite3LockReusableSchema(db);
  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
  do {
    memset(&sParse, 0, sizeof(Parse));
    if( !pBlob ) goto blob_open_out;
    sParse.db = db;
-    db->pParse = &sParse;
    sqlite3DbFree(db, zErr);
    zErr = 0;

@@ -335,8 +331,6 @@ int sqlite3_blob_open(
  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );

 blob_open_out:
-  db->pParse = pParentParse;
-  sqlite3UnlockReusableSchema(db, bUnlock);
  if( rc==SQLITE_OK && db->mallocFailed==0 ){
    *ppBlob = (sqlite3_blob *)pBlob;
  }else{
@@ -970,16 +970,13 @@ int sqlite3VdbeSorterInit(
  if( pSorter==0 ){
    rc = SQLITE_NOMEM_BKPT;
  }else{
-    Btree *pBt = db->aDb[0].pBt;
    pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
    memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
    pKeyInfo->db = 0;
    if( nField && nWorker==0 ){
      pKeyInfo->nKeyField = nField;
    }
-    sqlite3BtreeEnter(pBt);
-    pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(pBt);
-    sqlite3BtreeLeave(pBt);
+    pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
    pSorter->nTask = nWorker + 1;
    pSorter->iPrev = (u8)(nWorker - 1);
    pSorter->bUseThreads = (pSorter->nTask>1);
@@ -192,24 +192,6 @@ void sqlite3VtabLock(VTable *pVTab){
 VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
  VTable *pVtab;
  assert( IsVirtual(pTab) );
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  if( IsSharedSchema(db) ){
-    int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    if( iDb!=1 ){
-      VTable **pp;
-      for(pp=&db->aDb[iDb].pVTable; *pp; pp=&(*pp)->pNext){
-        if( sqlite3StrICmp(pTab->zName, (*pp)->zName)==0 ) break;
-      }
-      pVtab = *pp;
-      if( pVtab && pTab->nCol<=0 ){
-        *pp = pVtab->pNext;
-        sqlite3VtabUnlock(pVtab);
-        pVtab = 0;
-      }
-      return pVtab;
-    }
-  }
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
  for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
  return pVtab;
 }
@@ -507,7 +489,7 @@ void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){

    sqlite3VdbeAddOp0(v, OP_Expire);
    zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
-    sqlite3VdbeAddParseSchemaOp(pParse, iDb, zWhere);
+    sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
    sqlite3DbFree(db, zStmt);

    iReg = ++pParse->nMem;
@@ -581,7 +563,6 @@ static int vtabCallConstructor(
  char *zModuleName;
  int iDb;
  VtabCtx *pCtx;
-  int nByte;                      /* Bytes of space to allocate */

  /* Check that the virtual-table is not already being initialized */
  for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
@@ -598,11 +579,7 @@ static int vtabCallConstructor(
    return SQLITE_NOMEM_BKPT;
  }

-  nByte = sizeof(VTable);
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  nByte += sqlite3Strlen30(pTab->zName) + 1;
-#endif
-  pVTable = (VTable*)sqlite3MallocZero(nByte);
+  pVTable = sqlite3MallocZero(sizeof(VTable));
  if( !pVTable ){
    sqlite3OomFault(db);
    sqlite3DbFree(db, zModuleName);
@@ -610,10 +587,6 @@ static int vtabCallConstructor(
  }
  pVTable->db = db;
  pVTable->pMod = pMod;
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-  pVTable->zName = (char*)&pVTable[1];
-  memcpy(pVTable->zName, pTab->zName, nByte-sizeof(VTable));
-#endif
  pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;

  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
@@ -656,22 +629,12 @@ static int vtabCallConstructor(
      int iCol;
      u16 oooHidden = 0;
      /* If everything went according to plan, link the new VTable structure
-      ** into the linked list headed by pTab->pVTable. Or, if this is a
-      ** reusable schema, into the linked list headed by Db.pVTable.
-      **
-      ** Then loop through the columns of the table to see if any of them
-      ** contain the token "hidden". If so, set the Column COLFLAG_HIDDEN flag
-      ** and remove the token from the type string.  */
-#ifdef SQLITE_ENABLE_SHARED_SCHEMA
-      if( IsSharedSchema(db) && iDb!=1 ){
-        pVTable->pNext = db->aDb[iDb].pVTable;
-        db->aDb[iDb].pVTable = pVTable;
-      }else
-#endif /* ifdef SQLITE_ENABLE_SHARED_SCHEMA */
-      {
-        pVTable->pNext = pTab->pVTable;
-        pTab->pVTable = pVTable;
-      }
+      ** into the linked list headed by pTab->pVTable. Then loop through the 
+      ** columns of the table to see if any of them contain the token "hidden".
+      ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
+      ** the type string.  */
+      pVTable->pNext = pTab->pVTable;
+      pTab->pVTable = pVTable;

      for(iCol=0; iCol<pTab->nCol; iCol++){
        char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
@@ -724,7 +687,6 @@ int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){

  assert( pTab );
  if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){
-    assert( !IsVirtual(pTab) || pTab->nCol>0 );
    return SQLITE_OK;
  }

@@ -5246,6 +5246,7 @@ WhereInfo *sqlite3WhereBegin(

  /* Done. */
  VdbeModuleComment((v, "Begin WHERE-core"));
+  pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v);
  return pWInfo;

  /* Jump here if malloc fails */
@@ -5289,6 +5290,7 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
  WhereLoop *pLoop;
  SrcList *pTabList = pWInfo->pTabList;
  sqlite3 *db = pParse->db;
+  int iEnd = sqlite3VdbeCurrentAddr(v);

  /* Generate loop termination code.
  */
@@ -5426,7 +5428,7 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
  assert( pWInfo->nLevel<=pTabList->nSrc );
  for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
    int k, last;
-    VdbeOp *pOp;
+    VdbeOp *pOp, *pLastOp;
    Index *pIdx = 0;
    struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
    Table *pTab = pTabItem->pTab;
@@ -5484,20 +5486,31 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
      pIdx = pLevel->u.pCovidx;
    }
    if( pIdx
-     && (pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable))
     && !db->mallocFailed
    ){
-      last = sqlite3VdbeCurrentAddr(v);
-      k = pLevel->addrBody;
+      if( pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable) ){
+        last = iEnd;
+      }else{
+        last = pWInfo->iEndWhere;
+      }
+      k = pLevel->addrBody + 1;
 #ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeAddopTrace ){
        printf("TRANSLATE opcodes in range %d..%d\n", k, last-1);
      }
+      /* Proof that the "+1" on the k value above is safe */
+      pOp = sqlite3VdbeGetOp(v, k - 1);
+      assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur );
+      assert( pOp->opcode!=OP_Rowid  || pOp->p1!=pLevel->iTabCur );
+      assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur );
 #endif
      pOp = sqlite3VdbeGetOp(v, k);
-      for(; k<last; k++, pOp++){
-        if( pOp->p1!=pLevel->iTabCur ) continue;
-        if( pOp->opcode==OP_Column
+      pLastOp = pOp + (last - k);
+      assert( pOp<pLastOp );
+      do{
+        if( pOp->p1!=pLevel->iTabCur ){
+          /* no-op */
+        }else if( pOp->opcode==OP_Column
 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
         || pOp->opcode==OP_Offset
 #endif
@@ -5528,7 +5541,10 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
          pOp->p1 = pLevel->iIdxCur;
          OpcodeRewriteTrace(db, k, pOp);
        }
-      }
+#ifdef SQLITE_DEBUG
+        k++;
+#endif
+      }while( (++pOp)<pLastOp );
 #ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n");
 #endif
@@ -488,6 +488,7 @@ struct WhereInfo {
  unsigned sorted :1;          /* True if really sorted (not just grouped) */
  LogEst nRowOut;           /* Estimated number of output rows */
  int iTop;                 /* The very beginning of the WHERE loop */
+  int iEndWhere;            /* End of the WHERE clause itself */
  WhereLoop *pLoops;        /* List of all WhereLoop objects */
  WhereExprMod *pExprMods;  /* Expression modifications */
  Bitmask revMask;          /* Mask of ORDER BY terms that need reversing */
@@ -1909,17 +1909,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
    if( omitTable ){
      /* pIdx is a covering index.  No need to access the main table. */
    }else if( HasRowid(pIdx->pTable) ){
-      if( (pWInfo->wctrlFlags & WHERE_SEEK_TABLE)
-       || ( (pWInfo->wctrlFlags & WHERE_SEEK_UNIQ_TABLE)!=0
-           && (pWInfo->eOnePass==ONEPASS_SINGLE || pLoop->nLTerm==0) )
-      ){
-        iRowidReg = ++pParse->nMem;
-        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
-        sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowidReg);
-        VdbeCoverage(v);
-      }else{
-        codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
-      }
+      codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
    }else if( iCur!=iIdxCur ){
      Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
      iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
@@ -2046,7 +2036,6 @@ Bitmask sqlite3WhereCodeOneLoopStart(
    int iRetInit;                             /* Address of regReturn init */
    int untestedTerms = 0;             /* Some terms not completely tested */
    int ii;                            /* Loop counter */
-    u16 wctrlFlags;                    /* Flags for sub-WHERE clause */
    Expr *pAndExpr = 0;                /* An ".. AND (...)" expression */
    Table *pTab = pTabItem->pTab;

@@ -2147,7 +2136,6 @@ Bitmask sqlite3WhereCodeOneLoopStart(
    ** eliminating duplicates from other WHERE clauses, the action for each
    ** sub-WHERE clause is to to invoke the main loop body as a subroutine.
    */
-    wctrlFlags =  WHERE_OR_SUBCLAUSE | (pWInfo->wctrlFlags & WHERE_SEEK_TABLE);
    ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR"));
    for(ii=0; ii<pOrWc->nTerm; ii++){
      WhereTerm *pOrTerm = &pOrWc->a[ii];
@@ -2166,7 +2154,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
        ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));
        WHERETRACE(0xffff, ("Subplan for OR-clause:\n"));
        pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
-                                      wctrlFlags, iCovCur);
+                                      WHERE_OR_SUBCLAUSE, iCovCur);
        assert( pSubWInfo || pParse->nErr || db->mallocFailed );
        if( pSubWInfo ){
          WhereLoop *pSubLoop;
@@ -2264,6 +2252,9 @@ Bitmask sqlite3WhereCodeOneLoopStart(
          }else{
            pCov = 0;
          }
+          if( sqlite3WhereUsesDeferredSeek(pSubWInfo) ){
+            pWInfo->bDeferredSeek = 1;
+          }

          /* Finish the loop through table entries that match term pOrTerm. */
          sqlite3WhereEnd(pSubWInfo);
@@ -75,10 +75,10 @@ do_execsql_test atof1-2.30 {
  CREATE INDEX i1 ON t1(a);
  SELECT count(*) FROM t1 WHERE substr(a,',');
 } {1}
-# 2020-08-27 OSSFuzz find related to the above.
-do_execsql_test atof1-2.40 {
-  SELECT randomblob(0) - 1;
-} {-1}
+
+
+
+


 finish_test
@@ -131,41 +131,5 @@ do_multiclient_test tn {
  }
 }

-#-------------------------------------------------------------------------
-# Check that even if the busy-handler fails (returns zero) within a
-# call to sqlite3_prepare() (or _v2(), or _v3()), it is still invoked
-# the next time an SQLITE_BUSY is encountered.
-#
-
-do_multiclient_test tn {
-  code1 {
-    set ::busy_called 0
-    proc busy {args} {
-      if {$::busy_called} { return 1 }
-      set ::busy_called 1
-      return 0
-    }
-    db busy busy
-  }
-
-  do_test 3.$tn.1 {
-    sql2 {
-      CREATE TABLE t1(x);
-      BEGIN EXCLUSIVE;
-        INSERT INTO t1 VALUES('x');
-    }
-  } {}
-
-  do_test 3.$tn.2 {
-    set ::busy_called 0
-    list [catch { sql1 { SELECT * FROM t1 } } msg] $msg $::busy_called
-  } {1 {database is locked} 1}
-
-  do_test 3.$tn.3 {
-    set ::busy_called 0
-    list [catch { sql1 { SELECT * FROM t1 } } msg] $msg $::busy_called
-  } {1 {database is locked} 1}
-}
-
 finish_test

@@ -791,10 +791,4 @@ do_execsql_test in-19.40 {
  PRAGMA integrity_check;
 } {ok}

-# Ticket f3ff1472887
-#
-do_execsql_test in-20.1 {
-  SELECT (1 IN (2 IS TRUE));
-} {1}
-
 finish_test
@@ -294,10 +294,7 @@ do_execsql_test 8.1 {
 }

 #-------------------------------------------------------------------------
-# Ticket [45f4bf4eb] reported by Manuel Rigger (2020-04-25)
-#
-# Follow up error reported by Eric Speckman on the SQLite forum
-# https://sqlite.org/forum/info/c49496d24d35bd7c (2020-08-19)
+# Ticket [45f4bf4eb].
 #
 reset_db
 do_execsql_test 9.0 {
@@ -327,17 +324,5 @@ do_execsql_test 9.5 {
  UNION SELECT 0,0 WHERE 0; 
 } {0 0}

-do_execsql_test 9.10 {
-  CREATE TABLE t1 (aaa);
-  INSERT INTO t1 VALUES(23456);
-  CREATE TABLE t2(bbb);
-  CREATE VIEW v2(ccc) AS SELECT bbb IS 1234 FROM t2;
-  SELECT ccc, ccc IS NULL AS ddd FROM t1 LEFT JOIN v2;
-} {{} 1}
-optimization_control db query-flattener 0
-do_execsql_test 9.11 {
-  SELECT ccc, ccc IS NULL AS ddd FROM t1 LEFT JOIN v2;
-} {{} 1}
-

 finish_test
@@ -147,22 +147,6 @@ ifcapable compound {
  } {1 91 92 3 93 5}
 }

-do_execsql_test join6-5.1 {
-  CREATE TABLE tx(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o PRIMARY KEY) 
-  WITHOUT ROWID;
-  INSERT INTO tx VALUES(
-    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
-  );
-} {}
-do_execsql_test joint6-5.2 {
-  SELECT o FROM tx NATURAL JOIN tx;
-} {15}
-
-do_execsql_test join6-5.3 {
-  CREATE TABLE ty(a,Ñ,x6,x7,x8,Q,I,v,x1,L,E,x2,x3,x4,x5,s,g PRIMARY KEY,b,c)
-  WITHOUT ROWID;
-  SELECT a FROM ty NATURAL JOIN ty;
-}



@@ -135,11 +135,6 @@ array set ::Configs [strip_comments {
    -DSQLITE_MUTATION_TEST
    --enable-fts5 --enable-json1
  }
-  "Debug-Two" {
-    -DSQLITE_DEFAULT_MEMSTATUS=0
-    -DSQLITE_MAX_EXPR_DEPTH=0
-    --enable-debug
-  }
  "Fast-One" {
    -O6
    -DSQLITE_ENABLE_FTS4=1
@@ -289,7 +284,6 @@ array set ::Platforms [strip_comments {
    "Check-Symbols*"          checksymbols
    "Fast-One"                "fuzztest test"
    "Debug-One"               "mptest test"
-    "Debug-Two"               "test"
    "Have-Not"                test
    "Secure-Delete"           test
    "Unlock-Notify"           "QUICKTEST_INCLUDE=notify2.test test"
@@ -1,394 +0,0 @@
-# 2017 August 9
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse1
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-forcedelete test.db2
-sqlite3 db2 test.db2
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE, z);
-  CREATE INDEX i1 ON t1(z);
-  PRAGMA schema_version;
-} {2}
-
-do_execsql_test -db db2 1.1 {
-  CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE, z);
-  CREATE INDEX i1 ON t1(z);
-  PRAGMA schema_version;
-} {2}
-
-do_test 1.2 {
-  db close
-  db2 close
-  sqlite3 db2 test.db2 -shared-schema 1
-  sqlite3 db  test.db -shared-schema 1
-} {}
-
-do_execsql_test -db db2 1.3.1 {
-  INSERT INTO t1 VALUES(1, 2, 3);
-  INSERT INTO t1 VALUES(4, 5, 6);
-}
-
-do_execsql_test 1.3.2 {
-  SELECT * FROM t1;
-  PRAGMA integrity_check;
-} {ok}
-
-do_execsql_test -db db2 1.3.3 {
-  SELECT * FROM t1;
-  PRAGMA integrity_check;
-} {1 2 3 4 5 6 ok}
-
-sqlite3 db3 test.db2
-do_execsql_test -db db3 1.4.1 {
-  ALTER TABLE t1 ADD COLUMN a;
-}
-do_execsql_test -db db2 1.4.2 {
-  SELECT * FROM t1;
-} {1 2 3 {} 4 5 6 {}}
-do_execsql_test 1.4.3 {
-  SELECT * FROM t1;
-} {}
-
-db3 close
-sqlite3 db3 test.db
-do_execsql_test -db db3 1.5.0 {
-  CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN
-    SELECT 1, 2, 3;
-  END;
-}
-
-# Check that the schema cannot be modified if the db was opened with
-# SQLITE_OPEN_REUSE_SCHEMA.
-#
-foreach {tn sql} {
-  1  { CREATE TABLE t2(x, y) }
-  2  { CREATE INDEX i2 ON t1(z) }
-  3  { CREATE VIEW v2 AS SELECT * FROM t2 }
-  4  { ALTER TABLE t1 RENAME TO t3 }
-  5  { ALTER TABLE t1 ADD COLUMN xyz }
-  6  { VACUUM }
-  7  { DROP INDEX i1 }
-  8  { DROP TABLE t1 }
-  9  { DROP TRIGGER tr1 }
-  10 { ANALYZE }
-  11 { ALTER TABLE t1 RENAME z TO zzz }
-} {
-  do_catchsql_test 1.5.$tn $sql {1 {attempt to modify read-only schema}}
-}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-forcedelete test.db2
-ifcapable fts5 {
-  do_execsql_test 2.0 {
-    CREATE VIRTUAL TABLE ft USING fts5(a);
-    INSERT INTO ft VALUES('one'), ('two'), ('three');
-    ATTACH 'test.db2' AS aux;
-    CREATE VIRTUAL TABLE aux.ft USING fts5(a);
-    INSERT INTO aux.ft VALUES('aux1'), ('aux2'), ('aux3');
-  }
-
-  db close
-  sqlite3 db  test.db -shared-schema 1
-
-  do_execsql_test 2.1 {
-    ATTACH 'test.db2' AS aux;
-    SELECT * FROM main.ft;
-  } {one two three}
-
-breakpoint
-  do_execsql_test 2.2 {
-    SELECT * FROM aux.ft;
-  } {aux1 aux2 aux3}
-
-  do_execsql_test 2.2 {
-    SELECT * FROM aux.ft_content;
-  } {1 aux1 2 aux2 3 aux3}
-}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-forcedelete test.db2
-do_execsql_test 3.0 {
-  CREATE TABLE t1(a PRIMARY KEY, b, c);
-  CREATE VIEW v1 AS SELECT * FROM t1;
-  CREATE TRIGGER v1_ins INSTEAD OF INSERT ON v1 BEGIN
-    INSERT INTO t1 VALUES(new.a, new.b, new.c);
-  END;
-  CREATE TRIGGER v1_del INSTEAD OF DELETE ON v1 BEGIN
-    DELETE FROM t1 WHERE a=old.a;
-  END;
-  CREATE TRIGGER v1_up INSTEAD OF UPDATE ON v1 BEGIN
-    UPDATE t1 SET a=new.a, b=new.b, c=new.c WHERE a=old.a;
-  END;
-}
-forcecopy test.db test.db2
-
-do_test 3.1 {
-  sqlite3 db2 test.db2
-  execsql { INSERT INTO t1 VALUES(1, 2, 3) } db
-  execsql { INSERT INTO t1 VALUES(4, 5, 6) } db2
-  db2 close
-  execsql { ATTACH 'test.db2' AS aux; }
-} {}
-
-do_execsql_test 3.2 {
-  SELECT * FROM main.v1;
-} {1 2 3}
-
-do_execsql_test 3.3 {
-  SELECT * FROM aux.v1;
-} {4 5 6}
-
-db close
-sqlite3 db test.db -shared-schema 1
-
-do_execsql_test 3.4 { ATTACH 'test.db2' AS aux } {}
-do_execsql_test 3.5 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.6 { SELECT * FROM aux.v1  } {4 5 6}
-
-do_execsql_test 3.7.1 { INSERT INTO aux.t1 VALUES(8, 9, 10); }
-do_execsql_test 3.7.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.7.3 { SELECT * FROM aux.v1  } {4 5 6 8 9 10}
-
-do_execsql_test 3.8.1 { DELETE FROM aux.t1 WHERE b=5 }
-do_execsql_test 3.8.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.8.3 { SELECT * FROM aux.v1  } {8 9 10}
-
-do_execsql_test 3.9.1 { UPDATE aux.t1 SET b='abc' }
-do_execsql_test 3.9.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.9.3 { SELECT * FROM aux.v1  } {8 abc 10}
-
-do_execsql_test 3.10.1 { INSERT INTO aux.v1 VALUES(11, 12, 13) }
-do_execsql_test 3.10.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.10.3 { SELECT * FROM aux.v1  } {8 abc 10 11 12 13}
-
-do_execsql_test 3.11.1 { DELETE FROM aux.v1 WHERE b='abc' }
-do_execsql_test 3.11.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.11.3 { SELECT * FROM aux.v1  } {11 12 13}
-
-do_execsql_test 3.12.1 { UPDATE aux.v1 SET b='def' }
-do_execsql_test 3.12.2 { SELECT * FROM main.v1 } {1 2 3}
-do_execsql_test 3.12.3 { SELECT * FROM aux.v1  } {11 def 13}
-
-do_execsql_test 3.13.1 {
-  CREATE TEMP TRIGGER xyz AFTER INSERT ON aux.t1 BEGIN
-    INSERT INTO v1 VALUES(new.a, new.b, new.c);
-  END
-}
-do_execsql_test 3.13.2 {
-  INSERT INTO aux.v1 VALUES('x', 'y', 'z');
-}
-do_execsql_test 3.13.3 {
-  SELECT * FROM v1;
-} {1 2 3 x y z}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-forcedelete test.db2
-do_execsql_test 4.0 {
-  CREATE TABLE t1(a PRIMARY KEY, b, c UNIQUE);
-  CREATE TABLE del(a, b, c);
-  CREATE TRIGGER tr1 AFTER DELETE ON t1 BEGIN
-    INSERT INTO del VALUES(old.a, old.b, old.c);
-  END;
-}
-forcecopy test.db test.db2
-
-db close
-sqlite3 db test.db -shared-schema 1
-execsql { 
-  ATTACH 'test.db2' AS aux;
-  PRAGMA recursive_triggers = 1;
-}
-
-do_execsql_test 4.1 {
-  INSERT INTO main.t1 VALUES(1, 2, 3);
-  INSERT INTO aux.t1 VALUES(4, 5, 6);
-}
-
-do_execsql_test 4.2.1 {
-  INSERT OR REPLACE INTO aux.t1 VALUES('a', 'b', 6);
-  SELECT * FROM aux.t1;
-} {a b 6}
-do_execsql_test 4.2.2 { SELECT * FROM aux.del  } {4 5 6}
-do_execsql_test 4.2.3 { SELECT * FROM main.del } {}
-
-do_execsql_test 4.3.1 {
-  INSERT INTO aux.t1 VALUES('x', 'y', 'z');
-  UPDATE OR REPLACE aux.t1 SET c='z' WHERE a='a';
-} {}
-do_execsql_test 4.3.2 { SELECT * FROM aux.del  } {4 5 6 x y z}
-do_execsql_test 4.3.3 { SELECT * FROM main.del } {}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-do_execsql_test 5.0 {
-  CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
-  CREATE TABLE t2(a INTEGER PRIMARY KEY, b, c);
-  CREATE INDEX i1 ON t1(b);
-  INSERT INTO t1 VALUES(1, 2, 3), (4, 5, 6);
-  ANALYZE;
-  PRAGMA writable_schema = 1;
-  DELETE FROM sqlite_stat1;
-}
-db close
-forcecopy test.db test.db2
-sqlite3 db test.db -shared-schema 1
-execsql { ATTACH 'test.db2' AS aux }
-
-foreach {tn sql} {
-  1 { CREATE TABLE t3(x) }
-  2 { DROP TABLE t2 }
-  3 { CREATE INDEX i2 ON t2(b) }
-  4 { DROP INDEX i1 }
-  5 { ALTER TABLE t1 ADD COLUMN d }
-  6 { ALTER TABLE t1 RENAME TO t3 }
-  7 { ALTER TABLE t1 RENAME c TO d }
-} {
-  do_catchsql_test 5.1.$tn $sql {1 {attempt to modify read-only schema}}
-}
-
-do_execsql_test 5.2.1 { ANALYZE aux.t1 } {}
-do_execsql_test 5.2.2 { SELECT * FROM aux.sqlite_stat1  } {t1 i1 {2 1}}
-do_execsql_test 5.2.3 { SELECT * FROM main.sqlite_stat1 } {}
-
-do_test 5.3.0 {
-  sqlite3 db2 test.db2
-  db2 eval { 
-    PRAGMA writable_schema = 1;
-    DELETE FROM sqlite_stat1;
-  }
-} {}
-
-do_execsql_test 5.3.1 { SELECT * FROM aux.sqlite_stat1  } {}
-do_execsql_test 5.3.2 { ANALYZE aux } {}
-do_execsql_test 5.3.3 { SELECT * FROM aux.sqlite_stat1  } {t1 i1 {2 1}}
-do_execsql_test 5.3.4 { SELECT * FROM main.sqlite_stat1 } {}
-
-#-------------------------------------------------------------------------
-# Attempting to run ANALYZE when the required sqlite_statXX functions
-# are missing is an error (because it would modify the database schema).
-#
-reset_db
-do_execsql_test 5.4 {
-  CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
-  CREATE TABLE t2(a INTEGER PRIMARY KEY, b, c);
-  CREATE INDEX i1 ON t1(b);
-  INSERT INTO t1 VALUES(1, 2, 3), (4, 5, 6);
-}
-db close
-sqlite3 db test.db -shared-schema 1
-foreach {tn sql} {
-  1 { ANALYZE }
-  2 { ANALYZE t1 }
-  3 { ANALYZE i1 }
-  4 { ANALYZE main }
-  5 { ANALYZE main.t1 }
-  6 { ANALYZE main.i1 }
-} {
-  do_catchsql_test 5.4.$tn $sql {1 {attempt to modify read-only schema}}
-}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-do_execsql_test 6.0 {
-  CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
-  CREATE VIEW v1 AS SELECT * FROM t1;
-}
-db close
-forcecopy test.db test.db2
-sqlite3 db test.db -shared-schema 1
-execsql { ATTACH 'test.db2' AS aux }
-
-do_execsql_test 6.1 {
-  INSERT INTO main.t1(a) VALUES(1), (2), (3);
-  INSERT INTO aux.t1(a) VALUES(4), (5), (6);
-  CREATE TEMP TABLE t2(i,t);
-  INSERT INTO t2 VALUES(2, 'two'), (5, 'five');
-}
-
-do_execsql_test 6.2 {
-  SELECT t FROM t2 WHERE i IN (SELECT a FROM aux.t1)
-} {five}
-do_execsql_test 6.3 {
-  SELECT t FROM t2 WHERE i IN (SELECT a FROM aux.v1)
-} {five}
-
-#-------------------------------------------------------------------------
-#
-reset_db
-do_execsql_test 7.0 {
-  CREATE TABLE p1(a PRIMARY KEY, b);
-  CREATE TABLE p2(a PRIMARY KEY, b);
-  CREATE TABLE c1(x REFERENCES p1 ON UPDATE CASCADE ON DELETE CASCADE);
-}
-
-db close
-forcecopy test.db test.db2
-sqlite3 db test.db -shared-schema 1
-execsql { ATTACH 'test.db2' AS aux }
-
-do_execsql_test 7.1 {
-  INSERT INTO aux.p1 VALUES(1, 'one');
-  INSERT INTO aux.p1 VALUES(2, 'two');
-  PRAGMA foreign_keys = on;
-}
-
-do_execsql_test 7.2 {
-  INSERT INTO aux.c1 VALUES(2);
-}
-
-do_execsql_test 7.3.1 {
-  PRAGMA foreign_keys = off;
-  INSERT INTO main.p2 SELECT * FROM aux.p1;
-}
-do_execsql_test 7.3.2 {
-  SELECT * FROM main.p2;
-} {1 one 2 two}
-
-do_execsql_test 7.3.3 {
-  INSERT INTO aux.p2 VALUES(1, 2);
-}
-
-do_execsql_test 7.3.4 {
-  SELECT main.p2.a FROM main.p2, aux.p2;
-} {1 2}
-
-do_execsql_test 7.3.5 {
-  SELECT * FROM main.p2, aux.p2;
-} {1 one 1 2   2 two 1 2}
-
-do_execsql_test 7.4 {
-  SELECT count(*) FROM aux.p2;
-} {1}
-
-
-finish_test
-
-
@@ -1,336 +0,0 @@
-# 2017 August 9
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse2
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE, z);
-  CREATE INDEX i1 ON t1(z);
-  PRAGMA schema_version;
-} {2}
-
-do_test 1.2 {
-  catch { db close }
-  catch { db2 close }
-  sqlite3 db2 test.db -shared-schema 1
-  sqlite3 db  test.db -shared-schema 1
-} {}
-
-do_execsql_test -db db2 1.3.1 {
-  INSERT INTO t1 VALUES(1, 2, 3);
-}
-
-do_execsql_test -db db2 1.3.2 {
-  INSERT INTO t1 VALUES(4, 5, 6);
-}
-
-do_execsql_test 1.3.3 {
-  SELECT * FROM t1;
-} {1 2 3 4 5 6}
-
-#--------------------------------------------------------------------------
-reset_db
-ifcapable fts5 {
-  do_execsql_test 2.0 {
-    CREATE VIRTUAL TABLE ft USING fts5(c);
-    INSERT INTO ft VALUES('one two three');
-  }
-  db close
-  sqlite3 db test.db -shared-schema 1
-
-  do_execsql_test 2.1 {
-    SELECT * FROM ft
-  } {{one two three}}
-}
-
-#--------------------------------------------------------------------------
-reset_db
-do_execsql_test 3.0 {
-  CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE, z);
-  CREATE INDEX i1 ON t1(z);
-  PRAGMA schema_version;
-} {2}
-
-do_test 3.1 {
-  sqlite3 db1 test.db -shared-schema 1
-  sqlite3 db2 test.db -shared-schema 1
-} {}
-
-do_execsql_test -db db1 3.2.1 { SELECT * FROM t1 }
-do_execsql_test -db db2 3.2.2 { SELECT * FROM t1 }
-
-register_schemapool_module db
-do_execsql_test 3.3 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=2 nschema=1 ndelete=0}
-
-sqlite3 db3 test.db -shared-schema 1
-register_schemapool_module db3
-
-do_execsql_test 3.5 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=2 nschema=1 ndelete=0}
-
-do_execsql_test -db db3 3.6 { 
-  SELECT * FROM t1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=3 nschema=1 ndelete=0}
-
-do_execsql_test 3.7 { 
-  CREATE TABLE t2(x);
-}
-
-do_execsql_test 3.8 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=3 nschema=1 ndelete=0}
-
-do_execsql_test -db db1 3.9.1 { SELECT * FROM t1 }
-do_execsql_test 3.9.2 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=1 nschema=1 ndelete=0 nref=2 nschema=1 ndelete=0}
-
-do_execsql_test -db db2 3.10.1 { SELECT * FROM t1 }
-do_execsql_test 3.10.2 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool ORDER BY 1;
-} {nref=1 nschema=1 ndelete=0 nref=2 nschema=1 ndelete=0}
-
-do_execsql_test -db db3 3.11.1 { SELECT * FROM t1 }
-do_execsql_test 3.11.2 { 
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=3 nschema=1 ndelete=0}
-
-#--------------------------------------------------------------------------
-catch {db1 close}
-catch {db2 close}
-catch {db3 close}
-reset_db
-do_execsql_test 4.0.1 {
-  CREATE TABLE x1(a, b, c);
-  CREATE INDEX x1a ON x1(a);
-  CREATE INDEX x1b ON x1(b);
-}
-do_test 4.0.2 {
-  db close
-  for {set i 1} {$i < 6} {incr i} {
-    forcedelete test.db${i}-journal test.db${i}-wal test.db${i}-wal2 
-    forcecopy test.db test.db${i}
-  }
-  sqlite3 db  test.db
-  sqlite3 db2 test.db -shared-schema 1
-} {}
-
-register_schemapool_module db
-do_execsql_test 4.0.3 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {}
-
-do_test 4.1.1 {
-  execsql { 
-    ATTACH 'test.db1' AS db1; 
-    ATTACH 'test.db2' AS db2;
-    ATTACH 'test.db3' AS db3;
-    ATTACH 'test.db4' AS db4;
-    ATTACH 'test.db5' AS db5;
-  } db2
-} {}
-do_execsql_test 4.1.2 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {}
-do_execsql_test -db db2 4.1.3 {
-  SELECT * FROM db3.x1
-}
-do_execsql_test 4.1.4 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=1 nschema=1 ndelete=0}
-do_execsql_test -db db2 4.1.5 {
-  SELECT * FROM db2.x1
-}
-do_execsql_test 4.1.6 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=2 nschema=1 ndelete=0}
-do_execsql_test -db db2 4.1.7 {
-  SELECT * FROM x1
-}
-do_execsql_test 4.1.8 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=6 nschema=1 ndelete=0}
-
-do_test 4.2.1 {
-  catchsql { SELECT * FROM abc } db2
-} {1 {no such table: abc}}
-do_execsql_test 4.2.2 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=6 nschema=1 ndelete=0}
-
-register_schemapool_module db2
-do_execsql_test -db db2 4.3.1 {
-  INSERT INTO x1 VALUES(1, 2, 3);
-  INSERT INTO db1.x1 VALUES(4, 5, 6);
-  INSERT INTO db2.x1 VALUES(7, 8, 9);
-  INSERT INTO db3.x1 VALUES(10, 11, 12);
-  INSERT INTO db4.x1 VALUES(13, 14, 15);
-  INSERT INTO db5.x1 VALUES(16, 17, 18);
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=6 nschema=1 ndelete=0}
-
-do_execsql_test -db db2 4.3.2 {
-  SELECT * FROM db5.x1;
-  SELECT * FROM db4.x1;
-  SELECT * FROM db3.x1;
-  SELECT * FROM db2.x1;
-  SELECT * FROM db1.x1;
-  SELECT * FROM x1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {
-  16 17 18  13 14 15  10 11 12  7 8 9  4 5 6  1 2 3
-  nref=6 nschema=1 ndelete=0
-}
-
-do_execsql_test -db db2 4.3.3 {
-  UPDATE x1 SET a=a+10;
-  UPDATE db5.x1 SET a=a+10;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {
-  nref=6 nschema=1 ndelete=0
-}
-
-do_execsql_test -db db2 4.3.4 {
-  SELECT * FROM db5.x1;
-  SELECT * FROM db4.x1;
-  SELECT * FROM db3.x1;
-  SELECT * FROM db2.x1;
-  SELECT * FROM db1.x1;
-  SELECT * FROM x1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {
-  26 17 18  13 14 15  10 11 12  7 8 9  4 5 6  11 2 3
-  nref=6 nschema=1 ndelete=0
-}
-
-do_execsql_test -db db2 4.3.5 {
-  DELETE FROM db3.x1;
-  DELETE FROM x1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {
-  nref=6 nschema=1 ndelete=0
-}
-
-do_execsql_test -db db2 4.3.6 {
-  SELECT * FROM db5.x1;
-  SELECT * FROM db4.x1;
-  SELECT * FROM db3.x1;
-  SELECT * FROM db2.x1;
-  SELECT * FROM db1.x1;
-  SELECT * FROM x1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {
-  26 17 18  13 14 15  7 8 9  4 5 6 
-  nref=6 nschema=1 ndelete=0
-}
-
-do_execsql_test -db db2 4.3.6 {
-  SELECT * FROM db5.x1, db4.x1, db1.x1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {26 17 18 13 14 15 4 5 6 nref=6 nschema=3 ndelete=0}
-
-#--------------------------------------------------------------------------
-# Test the incremental-blob API with REUSE_SCHEMA connections.
-#
-catch {db1 close}
-catch {db2 close}
-catch {db3 close}
-reset_db
-do_execsql_test 5.0.1 {
-  CREATE TABLE bbb(a INTEGER PRIMARY KEY, b);
-}
-db close
-do_test 5.0.2 {
-  sqlite3 db2 test.db -shared-schema 1
-  register_schemapool_module db2
-  for {set i 1} {$i<6} {incr i} {
-    forcedelete test.db${i}-journal test.db${i}-wal test.db${i}-wal2 
-    forcecopy test.db test.db${i}
-    sqlite3 db test.db${i}
-    db eval { INSERT INTO bbb VALUES(123, 'database_' || $i) }
-    db close
-    db2 eval "ATTACH 'test.db${i}' AS db${i}"
-  }
-  execsql {
-    SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-      FROM schemapool;
-  } db2
-} {nref=6 nschema=1 ndelete=0}
-
-do_test 5.1.1 {
-  set res [list]
-  for {set i 1} {$i<6} {incr i} {
-    set chan [db2 incrblob db${i} bbb b 123]
-    lappend res [gets $chan]
-    close $chan
-  }
-  set res
-} {database_1 database_2 database_3 database_4 database_5}
-
-do_execsql_test -db db2 5.1.2 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=6 nschema=1 ndelete=0}
-
-do_test 5.2.1 {
-  sqlite3_table_column_metadata db2 main bbb a
-} {INTEGER BINARY 0 1 0}
-do_test 5.2.2 {
-  sqlite3_table_column_metadata db2 main bbb b
-} {{} BINARY 0 0 0}
-
-do_execsql_test -db db2 5.2.3 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {nref=6 nschema=1 ndelete=0}
-
-do_execsql_test -db db2 5.2.4 {
-  PRAGMA integrity_check;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete
-  FROM schemapool;
-} {ok nref=6 nschema=1 ndelete=5}
-
-finish_test
-
@@ -1,355 +0,0 @@
-# 2019 February 12
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse3
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE, z);
-  CREATE INDEX i1 ON t1(z);
-  CREATE TABLE t2(a);
-} {}
-
-db close
-sqlite3 db test.db -shared-schema 1
-
-do_execsql_test 1.1 {
-  CREATE TEMP VIEW v1 AS SELECT * FROM t1;
-  SELECT * FROM v1;
-}
-
-do_execsql_test 1.2 {
-  CREATE TEMP TRIGGER tr1 AFTER INSERT ON t1 BEGIN
-    INSERT INTO t2 VALUES(new.x);
-  END;
-}
-
-do_execsql_test 1.3 {
-  INSERT INTO t1 VALUES(1, 2, 3);
-}
-
-do_execsql_test 1.4 {
-  SELECT * FROM t2
-} {1}
-
-do_execsql_test 1.5 {
-  SELECT * FROM v1
-} {1 2 3}
-
-do_execsql_test 1.6 {
-  BEGIN;
-    DROP TRIGGER tr1;
-  ROLLBACK;
-}
-
-do_execsql_test 1.7 {
-  SELECT * FROM v1
-} {1 2 3}
-
-do_execsql_test 1.8 {
-  INSERT INTO t1 VALUES(4, 5, 6);
-  SELECT * FROM t2
-} {1 4}
-
-do_execsql_test 1.9 {
-  SELECT * FROM v1
-} {1 2 3 4 5 6}
-
-#-------------------------------------------------------------------------
-# Test error messages when parsing the schema with a REUSE_SCHEMA 
-# connection.
-reset_db
-do_execsql_test 2.0 {
-  CREATE TABLE x1(a, b, c);
-  CREATE TABLE y1(d, e, f);
-  PRAGMA writable_schema = 1;
-  UPDATE sqlite_master SET sql = 'CREATE TBL y1(d, e, f)' WHERE name = 'y1';
-}
-db close
-
-sqlite3 db test.db -shared-schema 1
-do_catchsql_test 2.1 {
-  SELECT * FROM x1;
-} {1 {malformed database schema (y1) - near "TBL": syntax error}}
-
-do_catchsql_test 2.2 {
-  SELECT * FROM x1;
-} {1 {malformed database schema (y1) - near "TBL": syntax error}}
-
-#-------------------------------------------------------------------------
-reset_db
-do_execsql_test 3.0 {
-  CREATE TABLE x1(a, b, c);
-  CREATE INDEX i1 ON x1(a, b, c);
-  CREATE TRIGGER tr1 AFTER INSERT ON x1 BEGIN
-    SELECT 1, 2, 3, 4, 5;
-  END;
-  INSERT INTO x1 VALUES(1, 2, 3);
-}
-sqlite3 db1 test.db -shared-schema 1
-
-do_test 3.1 {
-  execsql { SELECT * FROM x1 } db1
-  set N [lindex [sqlite3_db_status db1 SCHEMA_USED 0] 1]
-  expr $N==$N
-} 1
-
-sqlite3 db2 test.db -shared-schema 1
-do_test 3.2 {
-  execsql { SELECT * FROM x1 } db2
-  set N2 [lindex [sqlite3_db_status db2 SCHEMA_USED 0] 1]
-  expr $N2>($N/2) && $N2<($N/2)+400
-} 1
-
-sqlite3 db3 test.db -shared-schema 1
-sqlite3 db4 test.db -shared-schema 1
-do_test 3.3 {
-  execsql { SELECT * FROM x1 } db3
-  execsql { SELECT * FROM x1 } db4
-  set N4 [lindex [sqlite3_db_status db2 SCHEMA_USED 0] 1]
-  set M [expr 2*($N-$N2)]
-  set {} {}
-} {}
-do_test 3.3.1 { expr {(($M / 4) + $N-$M)} } "#/$N4/"
-
-catch { db1 close }
-catch { db2 close }
-catch { db3 close }
-catch { db4 close }
-
-#-------------------------------------------------------------------------
-# 4.1 Test the REINDEX command.
-# 4.2 Test CREATE TEMP ... commands.
-#
-reset_db
-do_execsql_test 4.1.0 {
-  CREATE TABLE x1(a, b, c);
-  CREATE INDEX x1a ON x1(a);
-  CREATE INDEX x1b ON x1(b);
-  CREATE INDEX x1c ON x1(c);
-}
-db close
-sqlite3 db test.db -shared-schema 1
-
-do_execsql_test 4.1.1 {
-  REINDEX x1;
-  REINDEX x1a;
-  REINDEX x1b;
-  REINDEX x1c;
-  REINDEX;
-}
-
-do_test 4.1.2 {
-  for {set i 1} {$i < 5} {incr i} {
-    forcedelete test.db${i} test.db${i}-wal test.db${i}-journal
-    forcecopy test.db test.db${i}
-    execsql "ATTACH 'test.db${i}' AS db${i}"
-  }
-  register_schemapool_module db
-  set {} {}
-  execsql { 
-    SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool 
-  }
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.1.3 {
-  REINDEX  x1;
-  REINDEX  x1a;
-  REINDEX  x1b;
-  REINDEX  x1c;
-  REINDEX  db1.x1a;
-  REINDEX  db2.x1b;
-  REINDEX  db3.x1c;
-}
-
-do_execsql_test 4.1.4 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool 
-} {nref=5 nschema=1 ndelete=28}
-
-#-------------------------------------------------------------------------
-db close
-sqlite3 db test.db -shared-schema 1
-register_schemapool_module db
-do_execsql_test 4.2.0 {
-  ATTACH 'test.db1' AS db1;
-  ATTACH 'test.db2' AS db2;
-  ATTACH 'test.db3' AS db3;
-  ATTACH 'test.db4' AS db4;
-
-  SELECT * FROM db1.x1;
-  SELECT * FROM db2.x1;
-  SELECT * FROM db3.x1;
-  SELECT * FROM db4.x1;
-}
-
-do_execsql_test 4.2.1 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.2 {
-  CREATE TEMP TABLE t1(a, b, c);
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.3 {
-  CREATE INDEX t1a ON t1(a);
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.4 {
-  CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN
-    SELECT 1,2,3,4;
-  END;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.5 {
-  DROP TABLE t1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.6 {
-  CREATE TEMP TRIGGER tr1 AFTER INSERT ON db2.x1 BEGIN
-    SELECT 1,2,3,4;
-  END;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=0}
-
-do_execsql_test 4.2.7 {
-  DROP TRIGGER tr1;
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema, 'ndelete=' || nDelete 
-    FROM schemapool; 
-} {nref=5 nschema=1 ndelete=4}
-
-#--------------------------------------------------------------------------
-reset_db
-do_execsql_test 5.0 {
-  CREATE TABLE t1(a, b);
-  CREATE TABLE t2(a, b);
-  CREATE TABLE t3(a, b);
-}
-
-sqlite3 db2 test.db -shared-schema 1
-register_schemapool_module db2
-
-do_execsql_test 5.1 {
-  PRAGMA writable_schema = 1;
-  UPDATE sqlite_master SET sql='CREATE TABLE t3 a,b' WHERE name = 't3';
-}
-
-do_test 5.2 { 
-  catchsql { SELECT * FROM t1 } db2
-} {1 {malformed database schema (t3) - near "a": syntax error}}
-
-do_test 5.3 { 
-  catchsql { SELECT nref,nschema FROM schemapool } db2
-} {1 {vtable constructor failed: schemapool}}
-
-do_execsql_test 5.4 {
-  PRAGMA writable_schema = 1;
-  UPDATE sqlite_master SET sql='CREATE TABLE t3(a,b)' WHERE name = 't3';
-}
-
-do_test 5.5 { 
-  catchsql { SELECT nref,nschema FROM schemapool } db2
-} {0 {1 1}}
-
-db2 close
-db close
-do_test 5.6.1 {
-  forcedelete test.db2 test.db2-wal test.db2-journal
-  forcecopy test.db test.db2
-  sqlite3 db test.db
-  sqlite3 db2 test.db  -shared-schema 1
-  sqlite3 db3 test.db2 -shared-schema 1
-  register_schemapool_module db
-} {}
-
-do_execsql_test -db db2 5.6.2 { SELECT * FROM t1 }
-do_execsql_test -db db3 5.6.3 { SELECT * FROM t1 }
-do_execsql_test 5.6.4 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema FROM schemapool; 
-  CREATE TABLE t4(x);
-  DROP TABLE t4;
-} {nref=2 nschema=1}
-do_execsql_test -db db2 5.6.5 { SELECT * FROM t1 }
-do_execsql_test -db db3 5.6.6 { SELECT * FROM t1 }
-do_execsql_test 5.6.7 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema FROM schemapool; 
-  ATTACH 'test.db2' AS db2;
-  CREATE TABLE db2.t4(x);
-  DROP TABLE db2.t4;
-} {nref=1 nschema=1 nref=1 nschema=1}
-do_execsql_test -db db2 5.6.8 { SELECT * FROM t1 }
-do_execsql_test -db db3 5.6.9 { SELECT * FROM t1 }
-do_execsql_test 5.6.10 {
-  SELECT 'nref=' || nRef, 'nschema=' || nSchema FROM schemapool; 
-} {nref=2 nschema=1}
-
-#-------------------------------------------------------------------------
-reset_db
-do_execsql_test 6.0 {
-  CREATE TABLE t1(a, b);
-  CREATE TABLE t2(a, b);
-  CREATE TABLE t3(a, b);
-}
-
-do_test 6.1 {
-  db close
-  sqlite3 db test.db -shared-schema 1
-  for {set i 1} {$i < 5} {incr i} {
-    set base "test.db$i"
-    set nm "aux$i"
-    forcedelete $base $base-wal $base-journal
-    forcecopy test.db $base
-    execsql "ATTACH '$base' AS $nm"
-  }
-} {}
-
-do_test 6.2 {
-  set N1 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  set N2 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  expr ($N1==0 && $N2==0)
-} {1}
-
-do_test 6.3 {
-  execsql { SELECT * FROM main.t1 }
-  set N1 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  set N2 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  expr {$N1>0 && $N2>0 && $N1==$N2}
-} {1}
-
-do_test 6.4 {
-  execsql { SELECT * FROM aux1.t1 }
-  set N3 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  set N4 [lindex [sqlite3_db_status db SCHEMA_USED 0] 1]
-  list $N3 $N4
-} "#/$N1 $N1/"
-
-finish_test
-
@@ -1,173 +0,0 @@
-# 2019 February 12
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse4
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-foreach {tn sharedschema} {
-  1 0  
-  2 1  
-} {
-  reset_db
-
-  do_execsql_test 1.$tn.0 {
-    CREATE TABLE x1(a, b);
-    CREATE INDEX x1a ON x1(a);
-    CREATE INDEX x1b ON x1(b);
-    CREATE TABLE x2(a, b);
-  }
-  db close
-  
-  do_test 1.$tn.1 {
-    for {set i 1} {$i<4} {incr i} {
-      forcedelete test.db$i test.db$i-journal test.db$i-wal
-      forcecopy test.db test.db$i
-    }
-  
-    sqlite3 db test.db -shared-schema $sharedschema
-    for {set i 1} {$i<4} {incr i} {
-      execsql " ATTACH 'test.db$i' AS db$i "
-    }
-  } {}
-  
-  do_execsql_test 1.$tn.2 {
-    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<10 )
-    INSERT INTO x1 SELECT i, i FROM s;
-  
-    INSERT INTO db3.x2 SELECT * FROM x1;
-    INSERT INTO db2.x1 SELECT * FROM db3.x2;
-    CREATE TEMP TRIGGER tr1 AFTER INSERT ON db2.x2 BEGIN
-      INSERT INTO x1 VALUES(new.a, new.b);
-    END;
-    INSERT INTO db2.x2 SELECT * FROM x1 WHERE a%2;
-    DELETE FROM x1 WHERE a<3;
-    INSERT INTO db3.x1 SELECT * FROM db2.x2;
-  
-    DETACH db3;
-    ATTACH 'test.db3' AS db3;
-  
-    UPDATE db3.x1 SET a=a-10 WHERE b NOT IN (SELECT b FROM db2.x2);
-  
-    CREATE TEMP TABLE x1(a, b);
-    INSERT INTO db2.x2 VALUES(50, 60), (60, 70), (80, 90);
-    ALTER TABLE x1 RENAME TO x2;
-    ALTER TABLE x2 ADD COLUMN c;
-    ALTER TABLE x2 RENAME a TO aaa;
-    DELETE FROM x1 WHERE b>8;
-    UPDATE db3.x2 SET b=b*10;
-  
-    BEGIN;
-      CREATE TEMP TABLE x5(x);
-      INSERT INTO x5 VALUES(1);
-    ROLLBACK;
-  
-    INSERT INTO main.x2 VALUES(123, 456);
-  }
-  
-  integrity_check 1.$tn.3
-  
-  do_execsql_test 1.$tn.4 {
-    SELECT * FROM main.x1; SELECT 'xxx';
-    SELECT * FROM main.x2; SELECT 'xxx';
-    SELECT * FROM temp.x2; SELECT 'xxx';
-  
-    SELECT * FROM db1.x1; SELECT 'xxx';
-    SELECT * FROM db1.x2; SELECT 'xxx';
-    SELECT * FROM db2.x1; SELECT 'xxx';
-    SELECT * FROM db2.x2; SELECT 'xxx';
-    SELECT * FROM db3.x1; SELECT 'xxx';
-    SELECT * FROM db3.x2; SELECT 'xxx';
-  } {
-    3 3 4 4 5 5 6 6 7 7 8 8 3 3 5 5 7 7 xxx 
-    123 456 xxx 
-    50 60 {} 60 70 {} 80 90 {} xxx
-    xxx
-    xxx
-    1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 xxx
-    1 1 3 3 5 5 7 7 9 9 50 60 60 70 80 90 xxx
-    1 1 3 3  5 5 7 7 9 9 xxx 
-    1 10 2 20 3 30 4 40 5 50 6 60 7 70 8 80 9 90 10 100 xxx
-  }
-  
-  do_test 1.$tn.5.1 {
-    sqlite3 db2 test.db
-    db2 eval { CREATE TABLE x3(x) }
-  } {}
-  do_execsql_test 1.$tn.5.2 {
-    SELECT * FROM main.x1; SELECT 'xxx';
-    SELECT * FROM main.x2; SELECT 'xxx';
-    SELECT * FROM main.x3; SELECT 'xxx';
-  } {
-    3 3 4 4 5 5 6 6 7 7 8 8 3 3 5 5 7 7 xxx 
-    123 456 xxx 
-    xxx
-  }
-}
-
-#-------------------------------------------------------------------------
-# Test some PRAGMA statements with shared-schema connections.
-#
-reset_db
-do_execsql_test 2.0 {
-  CREATE TABLE t1(a, b, c);
-  CREATE INDEX t1abc ON t1(a, b, c);
-}
-
-foreach {tn pragma nSchema nDelete} {
-  1 "PRAGMA synchronous = OFF"     1 0
-  2 "PRAGMA cache_size = 200"      1 0
-  3 "PRAGMA aux2.integrity_check"  1 0
-  4 "PRAGMA      integrity_check"  1 5
-  5 "PRAGMA index_info=t1abc"      1 5
-  6 "PRAGMA aux3.index_info=t1abc" 1 0
-  7 "PRAGMA journal_mode"          1 0
-  8 "PRAGMA aux2.wal_checkpoint"   1 0
-  9 "PRAGMA wal_checkpoint"        1 0
-} {
-  do_test 2.$tn.1 {
-    catch { db close }
-    catch { db2 close }
-    for {set i 1} {$i < 6} {incr i} {
-      forcedelete "test.db$i" "test.db${i}-wal" "test.db${i}-journal"
-      forcecopy test.db test.db$i
-    }
-    sqlite3 db2 test.db -shared-schema 1
-    for {set i 1} {$i < 6} {incr i} {
-      execsql "ATTACH 'test.db$i' AS aux$i" db2
-    }
-  } {}
-
-  sqlite3 db test.db
-  register_schemapool_module db
-
-  do_test 2.$tn.2 {
-    execsql $pragma db2
-    execsql { SELECT 'nschema='||nschema, 'ndelete='||nDelete FROM schemapool }
-  } "nschema=$nSchema ndelete=$nDelete"
-
-  do_test 2.$tn.3 {
-    execsql {
-      SELECT * FROM main.t1,aux1.t1,aux2.t1,aux3.t1,aux4.t1,aux5.t1
-    } db2
-    execsql { SELECT 'nschema=' || nschema, 'nref=' || nref FROM schemapool }
-  } "nschema=6 nref=6"
-}
-
-finish_test
-
@@ -1,125 +0,0 @@
-# 2019 February 26
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse5
-set CLI [test_find_cli]
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(x, y);
-  CREATE TABLE t2(a, b, c);
-  CREATE INDEX t1x ON t1(x);
-  CREATE INDEX t1y ON t1(y);
-  CREATE VIEW v1 AS SELECT * FROM t2;
-}
-
-foreach {tn sql out1 out2} {
-  1 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1x ON t1(x);
-    CREATE INDEX t1y ON t1(y);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-  } {
-    test.db2 is compatible
-  } {}
-
-  2 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1x ON t1(x);
-    CREATE INDEX t1y ON t1(y);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-    CREATE TABLE x1(x);
-    DROP TABLE x1;
-  } {
-    test.db2 is NOT compatible (schema cookie)
-  } {
-    Fixing test.db2... test.db2 is compatible
-  }
-
-  3 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1y ON t1(y);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-  } {
-    test.db2 is NOT compatible (objects)
-  } {}
-
-  4 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1x ON t1(X);
-    CREATE INDEX t1y ON t1(y);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-  } {
-    test.db2 is NOT compatible (SQL)
-  } {}
-
-  5 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1y ON t1(y);
-    CREATE INDEX t1x ON t1(x);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-  } {
-    test.db2 is NOT compatible (root pages)
-  } {
-    Fixing test.db2... test.db2 is compatible
-  }
-
-  6 {
-    CREATE TABLE t1(x, y);
-    CREATE TABLE t2(a, b, c);
-    CREATE INDEX t1x ON t1(x);
-    CREATE INDEX t1y ON t1(y);
-    CREATE VIEW v1 AS SELECT * FROM t2;
-    DROP INDEX t1x;
-    CREATE INDEX t1x ON t1(x);
-  } {
-    test.db2 is NOT compatible (order of sqlite_master rows)
-  } {
-    Fixing test.db2... test.db2 is compatible
-  }
-
-} {
-  forcedelete test.db2
-  sqlite3 db2 test.db2
-  db2 eval $sql
-  db2 close
-
-  if {$out2==""} {set out2 $out1}
-
-  do_test 1.$tn.1 {
-    catchcmd test.db ".shared-schema check test.db2"
-  } [list 0 [string trim $out1]]
-
-  do_test 1.$tn.2 {
-    catchcmd test.db ".shared-schema fix test.db2"
-  } [list 0 [string trim $out2]]
-
-  do_test 1.$tn.3 {
-    catchcmd test.db2 "PRAGMA integrity_check"
-  } [list 0 ok]
-}
-
-
-finish_test
-
@@ -1,143 +0,0 @@
-# 2019 February 26
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reuse6
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(x, y);
-  CREATE TABLE t2(a, b, c);
-  CREATE INDEX t1x ON t1(x);
-  CREATE INDEX t1y ON t1(y);
-  CREATE VIEW v1 AS SELECT * FROM t2;
-
-  INSERT INTO t1 VALUES(1, 2), (3, 4), (5, 6);
-  INSERT INTO t2 VALUES('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'h', 'i');
-
-  ATTACH 'test.db2' AS aux;
-  CREATE TABLE t3(i, ii);
-  INSERT INTO t3 VALUES(10, 20);
-}
-
-sqlite3 db1 test.db -shared-schema 1
-sqlite3 db2 test.db -shared-schema 1
-
-do_execsql_test -db db1 1.1 {
-  ATTACH 'test.db2' AS aux;
-}
-
-do_test 1.2 {
-  execsql {SELECT * FROM t3} db1
-} {10 20}
-
-do_execsql_test -db db2 1.3 {
-  ATTACH 'test.db2' AS aux;
-}
-
-do_test 1.3 {
-  execsql {SELECT * FROM t3} db1
-} {10 20}
-
-do_execsql_test -db db2 1.5 {
-  SELECT * FROM t3;
-} {10 20}
-
-do_test 1.6 {
-  execsql {SELECT * FROM t3} db1
-} {10 20}
-
-db1 close
-db2 close
-
-#-------------------------------------------------------------------------
-reset_db
-forcedelete test.db2
-forcedelete test.db3
-do_execsql_test 2.0 {
-  CREATE TABLE t1(x, y);
-  ATTACH 'test.db2' AS aux2;
-  CREATE TABLE aux2.t2(x, y);
-  ATTACH 'test.db3' AS aux3;
-  CREATE TABLE aux3.t3(x, y);
-}
-
-sqlite3 db1 test.db -shared-schema 1
-do_execsql_test -db db1 2.1 {
-  ATTACH 'test.db2' AS aux2;
-  ATTACH 'test.db3' AS aux3;
-}
-
-do_test 2.2.1 {
-  catchsql { SELECT * FROM aux2.nosuchtable } db1
-} {1 {no such table: aux2.nosuchtable}}
-do_test 2.2.2 {
-  sqlite3_errcode db1
-} {SQLITE_ERROR}
-db1 close
-
-#-------------------------------------------------------------------------
-reset_db
-forcedelete test.db2
-ifcapable fts5 {
-  do_execsql_test 3.0 {
-    CREATE VIRTUAL TABLE ft USING fts5(a, b);
-    ATTACH 'test.db2' AS aux;
-    CREATE TABLE aux.t1(x, y, z);
-  }
-
-  sqlite3 db1 test.db -shared-schema 1
-  do_execsql_test -db db1 3.1 {
-    ATTACH 'test.db2' AS aux;
-  }
-
-  do_execsql_test -db db1 3.2 {
-    SELECT * FROM main.ft, aux.t1;
-  }
-  db1 close
-}
-
-#-------------------------------------------------------------------------
-reset_db
-forcedelete test.db2
-ifcapable fts5 {
-  do_execsql_test 4.0 {
-    CREATE VIRTUAL TABLE ft USING fts5(a, b);
-  }
-  forcecopy test.db test.db2
-
-  sqlite3 db1 test.db -shared-schema 1
-  do_execsql_test -db db1 4.1 {
-    ATTACH 'test.db2' AS aux;
-    SELECT * FROM main.ft;
-    SELECT * FROM aux.ft;
-  }
-
-  do_execsql_test -db db1 4.2 {
-    SELECT * FROM main.ft, aux.ft
-  }
-}
-
-
-
-
-
-
-
-finish_test
-
@@ -1,54 +0,0 @@
-# 2019 February 12
-#
-# 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.
-#
-#***********************************************************************
-#
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix reusefault
-
-ifcapable !sharedschema {
-  finish_test
-  return
-}
-
-do_execsql_test 1.0 {
-  PRAGMA cache_size = 10;
-  CREATE TABLE t1(a UNIQUE, b UNIQUE);
-  INSERT INTO t1 VALUES(1, 2), (3, 4);
-}
-faultsim_save_and_close
-
-do_faultsim_test 1.1 -prep {
-  faultsim_restore
-  sqlite3 db test.db -shared-schema 1
-} -body {
-  execsql { SELECT * FROM t1 }
-} -test {
-  faultsim_test_result {0 {1 2 3 4}}
-}
-
-do_faultsim_test 1.2 -prep {
-  faultsim_restore
-  sqlite3 db test.db -shared-schema 1
-  execsql { SELECT * FROM t1 }
-  sqlite3 db2 test.db
-  db2 eval {CREATE TABLE a(a)}
-  db2 close
-} -body {
-  execsql { SELECT  * FROM t1 }
-} -test {
-  faultsim_test_result {0 {1 2 3 4}}
-}
-
-
-finish_test
-
@@ -26,9 +26,6 @@ set testprefix tcl
 # Check the error messages generated by tclsqlite
 #
 set r "sqlite_orig HANDLE ?FILENAME? ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN? ?-nofollow BOOLEAN? ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"
-ifcapable sharedschema {
-  append r " ?-shared-schema BOOLEAN?"
-}
 if {[sqlite3 -has-codec]} {
  append r " ?-key CODECKEY?"
 }
@@ -38,7 +38,7 @@
 #define SEL(e) ((e)->iLine = ((e)->rc ? (e)->iLine : __LINE__))

 /* Database functions */
-#define opendb(w,x,y,z,f)       (SEL(w), opendb_x(w,x,y,z,f))
+#define opendb(w,x,y,z)         (SEL(w), opendb_x(w,x,y,z))
 #define closedb(y,z)            (SEL(y), closedb_x(y,z))

 /* Functions to execute SQL */
@@ -520,14 +520,11 @@ static void opendb_x(
  Error *pErr,                    /* IN/OUT: Error code */
  Sqlite *pDb,                    /* OUT: Database handle */
  const char *zFile,              /* Database file name */
-  int bDelete,                    /* True to delete db file before opening */
-  int flags
+  int bDelete                     /* True to delete db file before opening */
 ){
  if( pErr->rc==SQLITE_OK ){
    int rc;
-    if( flags==0 ){
-      flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI;
-    }
+    int flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI;
    if( bDelete ) unlink(zFile);
    rc = sqlite3_open_v2(zFile, &pDb->db, flags, 0);
    if( rc ){
@@ -929,7 +926,7 @@ static char *walthread1_thread(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */
  int nIter = 0;                  /* Iterations so far */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    const char *azSql[] = {
      "SELECT md5sum(x) FROM t1 WHERE rowid != (SELECT max(rowid) FROM t1)",
@@ -968,7 +965,7 @@ static char *walthread1_ckpt_thread(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */
  int nCkpt = 0;                  /* Checkpoints so far */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    usleep(500*1000);
    execsql(&err, &db, "PRAGMA wal_checkpoint");
@@ -987,7 +984,7 @@ static void walthread1(int nMs){
  Threadset threads = {0};        /* Test threads */
  int i;                          /* Iterator variable */

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db,
      "PRAGMA journal_mode = WAL;"
      "CREATE TABLE t1(x PRIMARY KEY);"
@@ -1020,7 +1017,7 @@ static char *walthread2_thread(int iTid, void *pArg){
    int journal_exists = 0;
    int wal_exists = 0;

-    opendb(&err, &db, "test.db", 0, 0);
+    opendb(&err, &db, "test.db", 0);

    sql_script(&err, &db, zJournal);
    clear_error(&err, SQLITE_BUSY);
@@ -1050,7 +1047,7 @@ static void walthread2(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, "CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE)");
  closedb(&err, &db);

@@ -1070,7 +1067,7 @@ static char *walthread3_thread(int iTid, void *pArg){
  i64 iNextWrite;                 /* Next value this thread will write */
  int iArg = PTR2INT(pArg);

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 10");

  iNextWrite = iArg+1;
@@ -1107,7 +1104,7 @@ static void walthread3(int nMs){
  Threadset threads = {0};
  int i;

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
      "PRAGMA journal_mode = WAL;"
      "CREATE TABLE t1(cnt PRIMARY KEY, sum1, sum2);"
@@ -1130,7 +1127,7 @@ static char *walthread4_reader_thread(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    integrity_check(&err, &db);
  }
@@ -1145,7 +1142,7 @@ static char *walthread4_writer_thread(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */
  i64 iRow = 1;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 15;");
  while( !timetostop(&err) ){
    execsql_i64(
@@ -1165,7 +1162,7 @@ static void walthread4(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
      "PRAGMA journal_mode = WAL;"
      "CREATE TABLE t1(a INTEGER PRIMARY KEY, b UNIQUE);"
@@ -1185,7 +1182,7 @@ static char *walthread5_thread(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */
  i64 nRow;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  nRow = execsql_i64(&err, &db, "SELECT count(*) FROM t1");
  closedb(&err, &db);

@@ -1198,7 +1195,7 @@ static void walthread5(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
      "PRAGMA wal_autocheckpoint = 0;"
      "PRAGMA page_size = 1024;"
@@ -1289,7 +1286,7 @@ static void cgt_pager_1(int nMs){
  Error err = {0};
  Sqlite db = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db,
      "PRAGMA cache_size = 2000;"
      "PRAGMA page_size = 1024;"
@@ -1318,7 +1315,7 @@ static char *dynamic_triggers_1(int iTid, void *pArg){
  int nDrop = 0;
  int nCreate = 0;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    int i;

@@ -1371,7 +1368,7 @@ static char *dynamic_triggers_2(int iTid, void *pArg){
  int nInsert = 0;
  int nDelete = 0;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    do {
      iVal = (iVal+1)%100;
@@ -1396,7 +1393,7 @@ static void dynamic_triggers(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
      "PRAGMA page_size = 1024;"
      "PRAGMA journal_mode = WAL;"
@@ -1436,8 +1433,6 @@ static void dynamic_triggers(int nMs){
 #include "tt3_lookaside1.c"
 #include "tt3_vacuum.c"
 #include "tt3_stress.c"
-#include "tt3_reuseschema.c"
-#include "tt3_shared.c"

 int main(int argc, char **argv){
  struct ThreadTest {
@@ -1462,8 +1457,6 @@ int main(int argc, char **argv){
    { vacuum1,             "vacuum1", 10000 },
    { stress1,             "stress1", 10000 },
    { stress2,             "stress2", 60000 },
-    { reuse_schema_1,      "reuse_schema_1", 20000 },
-    { shared1,             "shared1", 10000 },
  };
  static char *substArgv[] = { 0, "*", 0 };
  int i, iArg;
@@ -70,7 +70,7 @@ static char *checkpoint_starvation_reader(int iTid, void *pArg){
  Error err = {0};
  Sqlite db = {0};

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    i64 iCount1, iCount2;
    sql_script(&err, &db, "BEGIN");
@@ -96,7 +96,7 @@ static void checkpoint_starvation_main(int nMs, CheckpointStarvationCtx *p){
  int nInsert = 0;
  int i;

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
      "PRAGMA page_size = 1024;"
      "PRAGMA journal_mode = WAL;"
@@ -19,7 +19,7 @@ static char *create_drop_index_thread(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */

  while( !timetostop(&err) ){
-    opendb(&err, &db, "test.db", 0, 0);
+    opendb(&err, &db, "test.db", 0);

    sql_script(&err, &db, 
      "DROP INDEX IF EXISTS i1;"
@@ -51,7 +51,7 @@ static void create_drop_index_1(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
     "CREATE TABLE t11(a, b, c, d);"
     "WITH data(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM data WHERE x<100) "
@@ -22,7 +22,7 @@ static char *lookaside1_thread_reader(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);

  while( !timetostop(&err) ){
    sqlite3_stmt *pStmt = 0;
@@ -47,7 +47,7 @@ static char *lookaside1_thread_writer(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);

  do{
    sql_script(&err, &db, 
@@ -68,7 +68,7 @@ static void lookaside1(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
     "CREATE TABLE t1(x PRIMARY KEY) WITHOUT ROWID;"
     "WITH data(x,y) AS ("
@@ -1,73 +0,0 @@
-/*
-** 2014 December 9
-**
-** 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.
-**
-*************************************************************************
-**
-**     reuse_schema_1
-*/
-
-
-static char *reuse_schema_thread(int iTid, void *pArg){
-  Error err = {0};                /* Error code and message */
-  Sqlite db = {0};                /* SQLite database connection */
-  int iRep = 0;
-
-  while( !timetostop(&err) ){
-    int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_SHARED_SCHEMA;
-    opendb(&err, &db, "test.db", 0, f);
-
-    execsql_i64(&err, &db, "SELECT count(*) FROM t1");
-    sql_script(&err, &db, "ATTACH 'test.db2' AS aux");
-    execsql_i64(&err, &db, "SELECT count(*) FROM t1");
-
-    closedb(&err, &db);
-    iRep++;
-  }
-
-  print_and_free_err(&err);
-  return sqlite3_mprintf("%d", iRep);
-}
-
-static void reuse_schema_1(int nMs){
-  Error err = {0};
-  Sqlite db = {0};
-  Threadset threads = {0};
-
-  opendb(&err, &db, "test.db", 1, 0);
-  sql_script(&err, &db, 
-     "CREATE TABLE t1(a, b, c, d);"
-     "WITH data(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM data WHERE x<100) "
-     "INSERT INTO t1 SELECT x,x,x,x FROM data;"
-  );
-  closedb(&err, &db);
-  opendb(&err, &db, "test.db2", 1, 0);
-  sql_script(&err, &db, 
-#ifdef SQLITE_ENABLE_FTS5
-     "CREATE VIRTUAL TABLE t2 USING fts5(a, b, c, d);"
-#else
-     "CREATE TABLE t2(a, b, c, d);"
-#endif
-     "WITH data(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM data WHERE x<100) "
-     "INSERT INTO t2 SELECT x*2,x*2,x*2,x*2 FROM data;"
-  );
-  closedb(&err, &db);
-
-  setstoptime(&err, nMs);
-
-  launch_thread(&err, &threads, reuse_schema_thread, 0);
-  launch_thread(&err, &threads, reuse_schema_thread, 0);
-  launch_thread(&err, &threads, reuse_schema_thread, 0);
-  launch_thread(&err, &threads, reuse_schema_thread, 0);
-  launch_thread(&err, &threads, reuse_schema_thread, 0);
-
-  join_all_threads(&err, &threads);
-  sqlite3_enable_shared_cache(0);
-  print_and_free_err(&err);
-}
@@ -1,55 +0,0 @@
-/*
-** 2020 September 5
-**
-** 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.
-**
-*************************************************************************
-**
-**
-*/
-
-
-/*
-*/
-static char *shared_thread1(int iTid, void *pArg){
-  Error err = {0};                /* Error code and message */
-
-  while( !timetostop(&err) ){
-    Sqlite db = {0};              /* SQLite database connection */
-    opendb(&err, &db, "test.db", 0);
-    sql_script(&err, &db, "SELECT * FROM t1");
-    closedb(&err, &db);
-  }
-  print_and_free_err(&err);
-  return sqlite3_mprintf("done!");
-}
-
-
-static void shared1(int nMs){
-  Error err = {0};
-  Sqlite db = {0};              /* SQLite database connection */
-  Threadset threads = {0};
-  int ii;
-
-  opendb(&err, &db, "test.db", 1);
-  sql_script(&err, &db, "CREATE TABLE t1(x)");
-  closedb(&err, &db);
-
-  setstoptime(&err, nMs);
-  sqlite3_enable_shared_cache(1);
-
-  for(ii=0; ii<5; ii++){
-    launch_thread(&err, &threads, shared_thread1, 0);
-  }
-
-  join_all_threads(&err, &threads);
-  sqlite3_enable_shared_cache(0);
-
-  print_and_free_err(&err);
-}
-
@@ -21,7 +21,7 @@ static char *stress_thread_1(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    sql_script(&err, &db, "CREATE TABLE IF NOT EXISTS t1(a PRIMARY KEY, b)");
    clear_error(&err, SQLITE_LOCKED);
@@ -40,7 +40,7 @@ static char *stress_thread_2(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */
  while( !timetostop(&err) ){
-    opendb(&err, &db, "test.db", 0, 0);
+    opendb(&err, &db, "test.db", 0);
    sql_script(&err, &db, "SELECT * FROM sqlite_schema;");
    clear_error(&err, SQLITE_LOCKED);
    closedb(&err, &db);
@@ -59,7 +59,7 @@ static char *stress_thread_3(int iTid, void *pArg){
  int i1 = 0;
  int i2 = 0;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    sql_script(&err, &db, "SELECT * FROM t1 ORDER BY a;");
    i1++;
@@ -82,11 +82,11 @@ static char *stress_thread_4(int iTid, void *pArg){
  int i2 = 0;
  int iArg = PTR2INT(pArg);

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    if( iArg ){
      closedb(&err, &db);
-      opendb(&err, &db, "test.db", 0, 0);
+      opendb(&err, &db, "test.db", 0);
    }
    sql_script(&err, &db, 
        "WITH loop(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM loop LIMIT 200) "
@@ -113,12 +113,12 @@ static char *stress_thread_5(int iTid, void *pArg){
  int i1 = 0;
  int i2 = 0;

-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  while( !timetostop(&err) ){
    i64 i = (i1 % 4);
    if( iArg ){
      closedb(&err, &db);
-      opendb(&err, &db, "test.db", 0, 0);
+      opendb(&err, &db, "test.db", 0);
    }
    execsql(&err, &db, "DELETE FROM t1 WHERE (rowid % 4)==:i", &i);
    i1++;
@@ -265,7 +265,7 @@ static char *stress2_workload19(int iTid, void *pArg){
  Sqlite db = {0};                /* SQLite database connection */
  const char *zDb = (const char*)pArg;
  while( !timetostop(&err) ){
-    opendb(&err, &db, zDb, 0, 0);
+    opendb(&err, &db, zDb, 0);
    sql_script(&err, &db, "SELECT * FROM sqlite_schema;");
    clear_error(&err, SQLITE_LOCKED);
    closedb(&err, &db);
@@ -290,7 +290,7 @@ static char *stress2_thread_wrapper(int iTid, void *pArg){

  while( !timetostop(&err) ){
    int cnt;
-    opendb(&err, &db, pCtx->zDb, 0, 0);
+    opendb(&err, &db, pCtx->zDb, 0);
    for(cnt=0; err.rc==SQLITE_OK && cnt<STRESS2_TABCNT; cnt++){
      pCtx->xProc(&err, &db, i1);
      i2 += (err.rc==SQLITE_OK);
@@ -342,7 +342,7 @@ static void stress2(int nMs){
  Threadset threads = {0};

  /* To make sure the db file is empty before commencing */
-  opendb(&err, &db, zDb, 1, 0);
+  opendb(&err, &db, zDb, 1);
  sql_script(&err, &db, 
      "CREATE TABLE IF NOT EXISTS t0(x PRIMARY KEY, y, z);"
      "CREATE INDEX IF NOT EXISTS i0 ON t0(y);"
@@ -23,7 +23,7 @@
 static char *vacuum1_thread_writer(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */
-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);
  i64 i = 0;

  while( !timetostop(&err) ){
@@ -52,7 +52,7 @@ static char *vacuum1_thread_writer(int iTid, void *pArg){
 static char *vacuum1_thread_vacuumer(int iTid, void *pArg){
  Error err = {0};                /* Error code and message */
  Sqlite db = {0};                /* SQLite database connection */
-  opendb(&err, &db, "test.db", 0, 0);
+  opendb(&err, &db, "test.db", 0);

  do{
    sql_script(&err, &db, "VACUUM");
@@ -69,7 +69,7 @@ static void vacuum1(int nMs){
  Sqlite db = {0};
  Threadset threads = {0};

-  opendb(&err, &db, "test.db", 1, 0);
+  opendb(&err, &db, "test.db", 1);
  sql_script(&err, &db, 
     "CREATE TABLE t1(x PRIMARY KEY, y BLOB);"
     "CREATE INDEX i1 ON t1(y);"
@@ -12,7 +12,7 @@

 # Flag meanings:
 set flagMeaning(NeedSchema) {Force schema load before running}
-set flagMeaning(OneSchema)  {Only a single schema required}
+set flagMeaning(ReadOnly)   {Read-only HEADER_VALUE}
 set flagMeaning(Result0)    {Acts as query when no argument}
 set flagMeaning(Result1)    {Acts as query when has one argument}
 set flagMeaning(SchemaReq)  {Schema required - "main" is default}
@@ -150,7 +150,7 @@ set pragma_def {
  ARG:  SQLITE_CellSizeCk

  NAME: default_cache_size
-  FLAG: NeedSchema Result0 SchemaReq NoColumns1 OneSchema
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  COLS: cache_size
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)

@@ -163,12 +163,12 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: page_count
-  FLAG: NeedSchema Result0 SchemaReq OneSchema
+  FLAG: NeedSchema Result0 SchemaReq
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: max_page_count
  TYPE: PAGE_COUNT
-  FLAG: NeedSchema Result0 SchemaReq OneSchema
+  FLAG: NeedSchema Result0 SchemaReq
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: locking_mode
@@ -176,7 +176,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: journal_mode
-  FLAG: NeedSchema Result0 SchemaReq OneSchema
+  FLAG: NeedSchema Result0 SchemaReq
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: journal_size_limit
@@ -184,18 +184,18 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: cache_size
-  FLAG: NeedSchema Result0 SchemaReq NoColumns1 OneSchema
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: mmap_size
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: auto_vacuum
-  FLAG: NeedSchema Result0 SchemaReq NoColumns1 OneSchema
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_AUTOVACUUM)

  NAME: incremental_vacuum
-  FLAG: NeedSchema NoColumns OneSchema
+  FLAG: NeedSchema NoColumns
  IF:   !defined(SQLITE_OMIT_AUTOVACUUM)

  NAME: temp_store
@@ -215,7 +215,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE

  NAME: synchronous
-  FLAG: NeedSchema Result0 SchemaReq NoColumns1 OneSchema
+  FLAG: NeedSchema Result0 SchemaReq NoColumns1
  IF:   !defined(SQLITE_OMIT_PAGER_PRAGMAS)

  NAME: table_info
@@ -232,7 +232,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

  NAME: stats
-  FLAG: NeedSchema Result0 SchemaReq OneSchema
+  FLAG: NeedSchema Result0 SchemaReq
  COLS: tbl idx wdth hght flgs
  IF:   !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG)

@@ -256,7 +256,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

  NAME: database_list
-  FLAG: NeedSchema Result0 OneSchema
+  FLAG: NeedSchema Result0
  COLS: seq name file
  IF:   !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

@@ -284,7 +284,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)

  NAME: foreign_key_list
-  FLAG: NeedSchema Result1 SchemaOpt OneSchema
+  FLAG: NeedSchema Result1 SchemaOpt
  COLS: id seq table from to on_update on_delete match
  IF:   !defined(SQLITE_OMIT_FOREIGN_KEY)

@@ -330,14 +330,14 @@ set pragma_def {

  NAME: data_version
  TYPE: HEADER_VALUE
-  ARG:  BTREE_DATA_VERSION|PRAGMA_HEADER_VALUE_READONLY
-  FLAG: Result0
+  ARG:  BTREE_DATA_VERSION
+  FLAG: ReadOnly Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: freelist_count
  TYPE: HEADER_VALUE
-  ARG:  BTREE_FREE_PAGE_COUNT|PRAGMA_HEADER_VALUE_READONLY
-  FLAG: Result0
+  ARG:  BTREE_FREE_PAGE_COUNT
+  FLAG: ReadOnly Result0
  IF:   !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)

  NAME: application_id
@@ -351,7 +351,7 @@ set pragma_def {
  IF:   !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)

  NAME: wal_checkpoint
-  FLAG: NeedSchema OneSchema
+  FLAG: NeedSchema
  COLS: busy log checkpointed
  IF:   !defined(SQLITE_OMIT_WAL)

@@ -510,12 +510,6 @@ foreach f [lsort [array names allflags]] {
  set fv [expr {$fv*2}]
 }

-puts $fd "\n/* For PragTyp_HEADER_VALUE pragmas the Pragma.iArg value is set"
-puts $fd "** to the index of the header field to access (always 10 or less)."
-puts $fd "** Ored with HEADER_VALUE_READONLY if the field is read only. */"
-puts $fd "#define PRAGMA_HEADER_VALUE_READONLY 0x0100"
-puts $fd "#define PRAGMA_HEADER_VALUE_MASK 0x00FF\n"
-
 # Sort the column lists so that longer column lists occur first
 #
 proc colscmp {a b} {