diff --git a/commits.txt b/commits.txt
new file mode 100644
index 0000000000..03e1a3be04
--- /dev/null
+++ b/commits.txt
@@ -0,0 +1,8446 @@
+09fd124d6 fix apidif
+a83913da2 fix: bundle size validator: ammount compressed scenarios should be lower than < ~1MB and add improvement to show uncompressed ammount
+83f54fb91 fix: ensure that all load bundle methods will check the size (#227)
+f3020cb05 add bundle size validator check (#210)
+447bc9dfd add some extra clarifications (#222)
+c0df2142e .github/workflows: Update the pull_request trigger for the Go workflow (#224)
+f26d95a78 feat: add warning for olm.properties being defined when validating csv (#217)
+0f4bb3351 .github/workflows: Add workflow_dispatch event trigger (#214)
+18b8a45d3 Purge the root vendor directory (#213)
+3f7eaca28 deprecate-api validator: add checks for removed APIs on 1.25 and 1.26 (#208)
+e02b0c82d Add perdasilva to approvers
+3f727364a (catsrc) add custom unmarshaller for registry poll interval (#169)
+ae0da0ed5 Add awgreene to list of approvers in OWNERS file (#218)
+8f57b5bfb Update OWNERS (#216)
+f7893af5e Added field for optional manifests (#209)
+cf9801f23 fix: alm-example parse check should not fail when the annotation if empty (#215)
+95132180d chore: Bump k8s dependencies to 1.23 (#212)
+ce0eb3266 csv_validator: add check to ensure that the example is a valid JSON (#207)
+4a8d766f5 validator/good practices: Improve message (#206)
+1f091bee4 Add perdasilva to list of reviewers (#201)
+19432e845 chore(modules): vendor dependencies
+3725e1e0d Remove operator-registry from vendor folder
+d7e151aa4 chore(modules): update vendor directory
+08e78fa2e chore(modules): update vendor directory
+353c9f9f1 with vendor directory
+76d1f5a30 Remove unused cache.AtLeast function. (#2681)
+be44ec354 Remove cache.OperatorCacheProvider interface. (#2680)
+e5c8de4b1 fix(operatorconditions): don't retry on 404 (#2679)
+03729c3f9 Remove ConstraintProvider from the exported solver package API. (#2675)
+3bab7c39e decrease logging level to debug for noisy catalog and olm operator logs
+0dc886807 Update Catalog e2e tests to use rawInterval
+845b4ec11 Bump k8s dependencies to 1.23 to align with o-f/api - logr updated from v0.4.0 to v1.2.0 (cascading implications) - Bumped to go 1.17 in Dockerfile - Amended the github action for unit tests:   - the envtest binaries were very very old (K8 1.16)   - the distribution of kubebuilder binaries and envtest changed in the meantime   - kubebuilder is not really needed for the tests and not part of the envtest installation ->  check disabled in Makefile - Used `kubectl create` instead of `kubectl apply` to avoid too long annotations for CRDs
+18a2b947b Mitigate flaky install plan e2e test (#2668)
+181b6b886 Remove import of operators.coreos.com lister package from resolver. (#2661)
+ae0ca1e51 .github: Avoid disabling the go mod pkg cache for the golangci-lint action (#2660)
+440c7f8ad Remove unused ttl field from cache.Cache. (#2658)
+b478c7708 Remove vestigal cache.OperatorSet type. (#2656)
+6dbccd82c cmd/catalog: Migrate to using cobra for CLI flag management (#2362)
+33572e6ca Give Sources control of invalidation for Snapshots they produce.
+b73845712 Replace hardcoded resolver cache mutation with CSV cache.Source. (#2632)
+031b21336 Remove unused GHA workflows (#2650)
+5c6bf8a8e Remove generated and unused resolver/fakes subpackage.
+ac516dad5 Remove CatalogSourceLister usage from resolver/cache. (#2648)
+004e1ae22 (Partially) mitigate flaky tests (#2625)
+6f4a176db Clarify solver package responsibility. (#2647)
+98eb1cb86 Fix cpb traverses unneeded paths (#2239)
+0a915a5e8 docs: add logo for github dark mode (#2622)
+3aecccf97 README: Remove reference to subscribing to packages through the tectonic UI (#2301)
+8471feded .github: Remove the automatic rebase action (#2620)
+804512ca4 cmd/catalog: Default to the $KUBECONFIG environment variable (#2303)
+710c96e8d [BZ #2048441] Fix a bug in deletion of webhook service for replacement (#2606)
+897a53add change Lister to DynamicClient for subscription clean up (#2616)
+ac9236f7c Remove the out-of-date CHANGELOG.md (#2608)
+5d7eff1ae Add workflow for automatically rebasing open PRs (#2612)
+b12032a75 fix: remove hardcoded minikube version from build_local.sh to support minikube users locally (#2607)
+59fdf61c4 wait for operatorhubio-catalog ready before test starts (#2605)
+f9ca416da Stop corrupting resolver cache. (#2604)
+7238d11ba Makefile: Remove unused targets/variables (#2567)
+e348996d8 count only active ns and wait for namespace clean up (#2585)
+de32e593a OWNERS: Add akihikokuroda as a reviewer (#2602)
+c55f7783f wait for catalogsource ready (#2601)
+f1bd02858 Remove unused ipLister field from OperatorStepResolver. (#2587)
+6fb02d292 put mutex around installplan creation (#2545)
+50799623e ci: Support configuring the logging level for the splitter package (#2579)
+864d921d3 Introduce Experimental Metrics (#2435)
+5b014484e use unique name for each test (#2541)
+1631f3e49 chore(e2e): naively parallelize CI jobs by chunking alphabetically (#2520)
+37a7ac7d9 recover nil GRPCConnectionState by update failure (#2561)
+5752fa97d wait for catalogsource pod deletion (#2444)
+107e14ff0 wait for condition update (#2510)
+ba3d06fd9 fix e2e config map update triggers registry pod rollout failure (#2532)
+918e393b7 add possible error message patterns (#2565)
+2f70f164d add wait for config injection in e2e test (#2547)
+ee469ae84 CSV e2e - wait for 2 pods ready before delete one pod (#2554)
+74d8e2575 Bump olmConfig controller logging message to debug (#2568)
+5faf373a1 Update goreleaser go version to 1.17 (#2557)
+ca99f270c Bump repository to Go 1.17 (#2556)
+3135ea9a8 Remove the unused 'lint' Makefile target (#2555)
+a8df88582 fix disable copied csv e2e test failure (#2543)
+55452a94f doc/design: Update the release documentation (#2549)
+7d6a04c95 Update OWNERS file (#2551)
+1b1b094b6 Fix goreleaser image repository configuration (#2548)
+2f8b4be05 Remove NamespaceSourceQuerier API that is no longer in use (#2380)
+e1ade2169 fix registry grpc unit test intermittent failure (#2521)
+fde47792d Add MagicCatalog for creating arbitrary file-based catalogs (#2527)
+44654f283 Integrate golangci-lint to run aggregate linting checks for CI (#2536)
+483bbe0b5 Remove bill-of-materials.json (#2535)
+24985a7aa chore(github): run e2e workflow against master periodically (#2528)
+2bfc3795e chore(api): Vendor the new version of api repo (#2525)
+9d3db1d1a .github/workflows: Enable workflow_dispatch event triggers (#2464)
+9c47cd6c0 .github/workflows: Update the checkouts action to use the v1 version (#2463)
+06d5c0d30 Fix github alias links in MAINTAINERS.md (#2533)
+6ea929d31 Add system constraint provider logic to resolver and add step resolver init hooks (#2523)
+c6f885f2d Introduce GRPC Proxy unit tests (#2428)
+6fa712d60 (vendor) bump go-sqlite to 1.14.10 (#896)
+f445d567b Update extract.go (#876)
+fe41e9b13 feat(constraint): Add constraint type validation to bundle validation (#888)
+d045f587f (.gitignore): Do not ignore debug/ (#890)
+8112836b1 (vendor) bump api to v0.11.0 (#887)
+5fb335a9e bump grpc dependency to latest (#810)
+5f7fb114e Bump operator-framework API to 0.10.5 (#737)
+ca5bcd0e8 remove darwin builds, disable goreleaser github releasers, re-add .github/workflows/release.yaml
+198d00f16 Merge pull request #258 from perdasilva/fix_kubebuilder_install
+59947b919 Fix install_kubebuilder.sh script
+99d2f8c64 Merge pull request #257 from timflannagan/ci/bump-base-dockerfile-go-version
+62ddd2079 Update the build root Dockerfile base image
+1b60477a5 Merge pull request #250 from openshift-bot/art-consistency-openshift-4.11-operator-lifecycle-manager
+f96daca5a Merge pull request #249 from openshift-bot/art-consistency-openshift-4.11-operator-registry
+6858269bd Merge pull request #228 from eggfoobar/leader_election_config
+6182cf61f Merge pull request #227 from ankitathomas/cleanup-scripts
+928cd2246 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/0059e470a61eba28225165168b22d9e77c33c926/images/operator-lifecycle-manager.yml
+fbc18d65c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/0059e470a61eba28225165168b22d9e77c33c926/images/operator-registry.yml
+5863540f4 Merge pull request #248 from tylerslaton/sync-constraint-changes
+fbfd54eeb feat: update api version to be 0.12.0 in order to use new Not constraint (#2603)
+a2896729a chore: update o-f/api version to v0.12.0 (#911)
+6a95e25a7 refactor(constraint): update none compound constraint to be not (#221)
+0d3db5544 fix(render/diff): Support olm.constraint in opm render/diff cmd (#901)
+6dce29c1b chore(constraint): Correct message to failureMessage in olm.constraint schema (#2572)
+46ea48565 fix(constraint): Correct the message field to be failureMessage (#211)
+b2d3ba890 test: added unit tests for leader election
+da97b0d3f upkeep: ran make verify
+9e56f4f53 feat: added leader election conventons
+d795a1d8e Merge pull request #240 from awgreene/grpc-address-bug-fix
+e8f3aa69a Merge pull request #247 from benluddy/patch-1
+06306d85d Remove benluddy from approvers.
+3820d16f4 Merge pull request #241 from perdasilva/add_per_to_owners
+9379df58f Merge pull request #242 from awgreene/bz-2003164
+2cd20d241 Do not modify object from the lister cache (#2562)
+79c782526 Merge pull request #239 from timflannagan/bz-1952576
+78d2b0af3 Merge pull request #238 from kevinrizza/master
+4c4835a0c Add perdasilva to OWNERS
+12e83f9b9 Address Invalid Address in GRPC Catalogs (#2499)
+7baca835c fix e2e CSV metric is preserved failure (#2530)
+91b949ae2 Emit CSV metric on startup (#2216)
+0bb2c07f6 Bug 2037168: Remove incorrect cvo annotations
+13f7723ba Merge pull request #237 from awgreene/olmconfig-create-only-annotation
+423c68713 Add the create-only annotation to the olmconfig/cluster manifest
+6efdf7acb Merge pull request #236 from timflannagan/sync-olm-copied-csv
+9c548f2fd manifests: Add the OLMConfig CRD
+e3ea532e5 Introduce olmConfig controller (#2466)
+cf218f7fe Merge pull request #232 from dinhxuanvu/synx-12-14-test
+325983e6d feat: catalog source pod scheduling config overrides (#2512)
+4efba59f3 feat(resolver): support generic constraint using CEL (#2506)
+b59e7342c feat(resolver): resolve compound dep constraints from bundle properties (#2418)
+9e65a9a5b chore(deps): bump o-f/api for new constraint types (#2515)
+d87c0de02 go.*,pkg,vendor: Bump controller-runtime to v0.10.1 (#2368)
+a494ce140 doc: further information and example of usage (#205)
+f73f86c7c feat(constraints): add compound constraints and olm.constraint value parser (#203)
+7ff5e4a1f test: skip image polling test if running in a kind cluster (#2445)
+0c319f5c7 test/e2e: Fix unset  when gathering CI testing artifacts (#2450)
+5bb028dbf Introduce a mechanism for gathering test artifacts during individual test failures (#2442)
+6b141273d Merge pull request #231 from anik120/sync-registry-12-15
+7e3871875 fix(diff): prune empty channel when old model is empty (#884)
+30b39543f chore(deps): upgrade of/api for new constraint type (#880)
+e58ffe0dd Merge pull request #225 from anik120/sync-api-10-12-2021
+aafc7b5fe clean up unused scripts
+5485c64e2 bugfix: make spec.grpcPodConfig.priorityClassName a *string
+54b083fd5 feat(cel): Add CEL custom library for semver comparison (#202)
+ddc7ca9ce add new good-practices validator (#197)
+2ae9059da Introduce OLMConfig CRD (#198)
+ff03d62c6 Merge pull request #223 from anik120/sync-olm-12-10-21
+33fa1102c Add grpcPodConfig attribute to spec (#173)
+d065c9745 Add format as a prerequisite to verify target (#200)
+6d609e9bd deprecate: CommunityValidator (#199)
+d073e45eb doc: fix layout of the doc (#171)
+923c6c035 Merge pull request #224 from anik120/op-registry-sync-10-09-2021
+dbd7e9a77 Introduce Maintainers File (#2456)
+635f3c78f Add instructions for setting up envtest and checking go version (#2504)
+0c485c8a0 .github/workflows: Avoid specifying the paths-ignore keyword (#2511)
+184f0ae86 cmd: Silence warning about logrus.Fatal usage when directive has been supplied (#2462)
+93fc88a07 fix unexpected deployment hash value change (#2508)
+7bd61f0fa test/e2e: Collect CatalogSource testing artifacts and delete empty files (#2460)
+5f9ca66da pkg,test: Remove duplicate package imports (#2501)
+f84457507 Rename CI github workflows (#2446)
+09a43ac78 alpha/declcfg: re-encode olm.bundle.object data to JSON when loading (#874)
+dc5f6de60 Merge pull request #218 from timflannagan/sync/11-30-and-registry-no-grpc-bump
+5ba7d1af0 drop trailing slash for catalog directory on opm alpha generate dockerfile (#831)
+8957e5ebc pkg/sqlite: use consistent starting depth when building channel_entry table (#868)
+02663b502 (fix) database is locked during removal (#828)
+b95ad9bfc Block cross-package skips/replaces on add (#826)
+32b7b0653 Adding equivalent opm index flags to opm registry (#827)
+3099308f3 opm validate: fail on duplicate packages, channels, and bundles (#824)
+6b96c00a3 feat(diff): change default behavior to prune by omission (#819)
+ada17ab6e goreleaser: use netgo and osusergo to ensure completely static binary builds (#821)
+64ce5b90e render: include olm.bundle.object properties in rendered bundle images (#807)
+76dfb74c2 .github/workflows/goreleaser.yaml: fix cross-compiler install step (#818)
+fb9d689ba Log a warning when loading bundle manifests with multiple documents (#708)
+442bcb774 retain single bundle default channel for overwrite (#812)
+26c0883d1 e2e local test for mac (#785)
+8f7c15376 alpha/declcfg: Include bundle name in version parsing failure message (#811)
+67d84fdde Makefile: Add a .PHONY target for the opm build target (#813)
+6b326f926 fix(opm): ignore empty include file args (#808)
+ea627a90a build(deps): bump github.com/containerd/containerd from 1.4.8 to 1.4.11 (#806)
+3ac596922 (opm) Introduce deprecatetruncate for `opm registry` (#804)
+bbdb874c7 registry: vacuum db on commands that remove data (#803)
+f85f31221 ensure use of bash as Makefile shell (#802)
+e1229be42 Makefile: fix major and major-minor docker release tags (#801)
+ed6edb359 Check only for new bundles on add (#798)
+6f0b8ebe1 Use the proper grpc_health_probe command per architectures. (#796)
+254dfdd84 render: populate related images even when CSV has none explicitly defined (#797)
+a7fdfdf9f Enable cgo in multiarch builds (#793)
+b8e5cc27d migrate: add subcommand to migrate sqlite catalogs to file-based catalogs (#770)
+52e90015a handle deprecating branch points (#767)
+4947f3406 fix: update opm commands to specify if they don't take args (#786)
+47cee9b7a fix(alpha): update long description indentation (#789)
+80e4a9241 feat(diff): optionally include bundle names (#787)
+8dca80f68 fix: Unable to deprecate bundles that are head of a NOT default channel with opm deprecatetruncate (#780)
+121ef6b7c Update CASE to match resource. (#694)
+a4fe1851e opm serve: pre-compute and store api.Bundles to disk; requests read from disk  (#783)
+41c7be418 feat(opm): include arbitrary packages, channels, and versions in diffs (#716)
+ccc08edd1 use static distroless image instead of base (#778)
+a28216b0b fix: clarifies message error regards service account (#174)
+798dfd6af fix: Scorecard configuration ServiceAccount tag (#166)
+8a250a513 fix: add missing allowed category (#164)
+704d0ad3e doc operatorhub validator (#159)
+ad3f39546 chore(docs): emphasize release versioning requirements (#162)
+509e6725d fix(validators): check object GVK in bundle service account validator (#161)
+840c9134c Validate SA names do not match csv deployment spec (#144)
+6af63ed22 Add Service Account Config to Scorecard (#153)
+84f7ca58f feat: add new validator to only check the usage of deprecate apis (#156)
+d1d38138a Merge pull request #213 from njhale/sync/10-18
+a4147d89f fix(sub): Only update subscriptions that have changes in status (#2399)
+a6861acaf remove panic (#2448)
+4a0f091dc test/e2e: Fix 'resource name may not be empty' failure in catalog templating test case (#2457)
+a2f4723f1 test/e2e: Reduce subscription e2e test pollution (#2438)
+b57566008 .github,test: Upload container logs during e2e runs as artifacts (#2432)
+f7fdf89cf Makefile: Explicitly override the default OLM install and test namespaces
+47d8f3cd8 Fix typo and add clarity to replacing transition (#2426)
+a42e9b430 Expose pprof endpoint if tls is not configured (#2422)
+55508edd9 Makefile: Update the e2e-local target and add CI-friendly ginkgo options (#2414)
+bd293096d Improve reliability of e2e tests that include GRPC CatalogSources (#2419)
+e37952b2f fix: use v1 pdb object under e2e bundle test (#2398)
+2248662df fix: wrap csv e2e test create in Eventually statements in the BeforeEach block (#2387)
+5d2375154 test/e2e: Wrap flake-prone garbage collection tests in eventually assertions (#2403)
+baea59c5b chore(make): add e2e test options (#2393)
+2f2caa4d1 Rename resolver/cache.Operator to Entry. (#2359)
+fb8b0f463 fix(e2e): Remove the PreExistingCRDOwnerIsReplaced e2e test case (#2388)
+26182b4f5 fix(e2e): Using Eventually to check subscription state (#2396)
+5cfd98e82 fix: wrap subscription e2e test logic in Eventually statement (#2392)
+09bc47556 test(e2e): use server-side apply to update fixture (#2385)
+9941e120b Makefile: Update the e2e target to use ginkgo (#2367)
+295c1dcb7 Integrate goreleaser to produce draft releases when new tags are pushed (#2365)
+e37e7d67c Update default catalog namespace (#2371)
+064c435dd pkg/controller: Fix panic when creating cluster-scoped RBAC in OG controller (#2349)
+1023034ab Add olm-managed label to configmap-based catalogsource for e2e test (#2370)
+fb8b5724a test/e2e: Remove the unused e2e.sh and tap.jq files (#2366)
+336f02eb7 Add summary and description for prometheus alerts (#2361)
+25fb2651e Makefile,test: Remove the test/rh-operators directory (#2354)
+cb3b165d1 .github/workflows: Don't run the sanity jobs for markdown-only updates (#2356)
+9674465bd fail gracefully when client-ca file is not set or doesn't exist (#2358)
+eb55029e4 .github/workflows: Bump the docker/build-push-action to the v2 version
+afa6ef4dc Update the CONTRIBUTING.md guidelines (#2344)
+5c838276a pkg,test: Fix linting violations in relevant packages
+b33b6b58d .github/workflows: Introduce a sanity check that runs static linting/style checks
+011db68b5 Makefile: Add a linting target that runs gofmt/goimports
+e02906a77 fix(og): Fix missing MultiOperatorGroups condition in some cases (#2305)
+8970fc081 Merge pull request #211 from dinhxuanvu/upgrade-delay
+807c857a6 pkg/controller: Migrate to using a read lock instead of a readwrite lock when checking for any namespace caching errors (#2382)
+f70bd92b8 Remove oudated subscription update logic to improve resolution delay (#2369)
+6d684d4d9 Merge pull request #208 from awgreene/update-collect-profile-namespace
+0c261a1fa Use arguments to configure pprof-secret
+dde7292f1 Merge pull request #206 from njhale/sync/grpc-no-proxy
+76afb08a4 Merge pull request #205 from njhale/sync/quarter-2
+c4e244763 Introduce GRPC_PROXY EnvVar Support (#2364)
+6a39a9a46 feat(opm): fine-grained dependency selection in diffs (#756)
+8fa95ac5c .github/workflows: Don't run CI checks for markdown-only updates (#2347)
+b1e86958c fix(release): upgrade goreleaser so script requests correct checksum file (#773)
+e3dc18c5c chore: update manifests
+b3bc3eba3 Bump OLM_VERSION to 0.19.0 (#2348)
+d7faee734 doc(readme): add chat badge (#2345)
+f1f6a3343 .github/workflows: Separate out the e2e jobs into workflows (#2158)
+f610b0985 chore: update manifests
+dcbe7701f modified the controller-runtime and controller-tools versions (#154)
+4314d89a7 Remove hardcoded references to the registry gRPC API from the resolver packages. (#2340)
+63b841586 Add validation for Kind and APIVersion (#152)
+5ee92ca8d Add Timestamp to Scorecard Test Results (#137)
+a46d4c876 Remove unneeded replace pin for sigs.k8s.io/structured-merge-diff (#2338)
+9f1a51d79 Reduce resolver dependencies on operator-registry and operator-lifecycle-manager. (#2337)
+af5c4c2ed fix: ensure operator images are included in rendered bundles related images (#771)
+301587ba0 Merge pull request #200 from njhale/sync/half
+c98b23dee update default scaffolded opm base image (#762)
+44b39b1ae Fix 2327: Detecting OLM existence before start to install (#2334)
+1b1751a31 (fix) : Fix check to verify OCP label versions when it is =v4.x (#148)
+54a82e931 bump gini (#2336)
+2eda531c1 fix broken URL in unit.yaml GH action (#2335)
+baf84fad5 move internal to alpha to make subpackages available for importing from other projects (#759)
+b5953c971 feat(opm): configure diff to not include dependency bundles with --skip-deps (#753)
+0b7711578 Fix upstream-opm-builder (#758)
+1fca926f8 Use of/gini instead of inifrance/gini (#2331)
+42dc86b42 Add vu dinh to OLM approvers (#2332)
+da994b77a Prune API of the resolver package. (#2330)
+a8ad0d24f Add joelanford as an approver in OWNERS (#751)
+f8cb8dbb5 cli doc: opm serve does not detect DC changes after startup (#750)
+13f3cc8be add further console customization types (#2319)
+4e8f0d541 feat(release): X.Y, X, and latest opm image tags (#738)
+7cff3298b feat: support removing the default channel head in deprecatetrunace (#734)
+761b51f93 .github/workflows: Replace the e2e-kind job name with e2e in the test workflow (#730)
+ef6614148 add further console customization types
+efbfe0477 Move operator caching from resolver into a new package. (#2316)
+84c660776 setup multi-arch builds with goreleaser
+c553dde9a internal/declcfg: Avoid processing the .indexignore file when walking the root fs (#733)
+f405a8ecb let net.Listen pick a port for grpc servers generated in tests (#2310)
+9e3125208 don't return an error if the singleton rbac doesn't exist (#2309)
+999506f9a .github/workflows: Avoid running the e2e-tests workflow on doc-only pull requests (#2299)
+327f6b774 doc/design: Update the changelog release documentation (#2298)
+e9be950d8 Update containerd dependency to fix vulnerabilities (#719)
+a2c7df0e6 v0.18.3 OLM release
+2b6872781 Expose errors generated while retrieving catalog content.
+282bb6e1f .github/workflows: Fix the release quickstart.yaml GH action
+001135e9b Merge pull request #199 from kevinrizza/add-readme
+bf964279f Add a readme
+a768ef8e8 Merge pull request #189 from openshift-bot/art-consistency-openshift-4.10-operator-lifecycle-manager
+3cef91bfe Merge pull request #188 from openshift-bot/art-consistency-openshift-4.10-operator-registry
+a5303ed3d Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/79fa14aac4fe70e2d6b85876bf225f546a8e73a7/images/operator-lifecycle-manager.yml
+206d2a09c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/79fa14aac4fe70e2d6b85876bf225f546a8e73a7/images/operator-registry.yml
+f2feb108c Merge pull request #185 from timflannagan/remove-scripts-readme
+4a8195458 scripts: Update the README.md to point to the downstream gdoc
+e80f0524b Merge pull request #183 from timflannagan/update-build-root-config
+7a7c6b453 Introduce the .ci-operator.yaml file
+32eb25914 Merge pull request #179 from benluddy/bz-2000144
+247887f1f Merge pull request #181 from joelanford/bz-2000146
+bbd687b8e Introduce olm.channel schema, remove channel metadata-related bundle properties
+98b8c0fbc Mark GetBundleForChannel as deprecated and trim its response.
+01e1cf8ca Merge pull request #178 from awgreene/owners-update
+ca5d761a8 Merge pull request #137 from timflannagan/packageserver-ha-expectations
+9647632b7 pkg,scripts: Ensure the PackageServer CSV contains a hard pod anti-affinity configuration
+f4e67294b manifests,scripts: Add a PodDisruptionBudget resources for the PackageServer component
+5f4c7ea2a Update OWNERS file
+859291e1c Merge pull request #176 from joelanford/bz-1994648
+d4a3aa1c3 Merge pull request #177 from joelanford/bz-1996878
+c3c64d40c Add deprecation warnings for CLIs that use or depend on sqlite
+7a6282c8b manifests,scripts: Update the PSM deployment filename to be consistent with the rest of the YAML manifests
+0178564d0 Merge pull request #175 from joelanford/bz-1995300
+52aa59c71 fix(sub): Reset ResolutionFailed cond when error is resolved (#2296)
+6ee2f331d Merge pull request #157 from timflannagan/fix-multi-arch-opm-version
+1841f3076 opm validate: check for cycles and stranded bundles in channel validation (#755)
+d1dea1028 Merge pull request #170 from timflannagan/k8s-bump
+0ba8af9f5 Merge pull request #172 from timflannagan/fix-build-root-dockerfile
+f55f561cd Update kubebuilder installation in the build root dockerfile
+0934d42a4 Merge pull request #150 from timflannagan/fix-opm-index-prune-panic
+b82547dc5 scripts: Ignore upstream commits touching the root go.[sum,mod] files
+b5bc8b5fb fix: update make generate directive to be crossplatform
+97e684566 feat: bump k8s dependencies to v0.22.0 (#2323)
+e65faeb8c feat: bump k8s dependencies to v0.22.0 (#747)
+6a09badd6 feat: bump k8s to v0.22.0 (#145)
+b5600cf63 Merge pull request #171 from njhale/fix/verify-commits
+40493e689 Merge pull request #169 from ankitathomas/maxocperror
+69171128d chore(verify-commits): initialize variable
+5bd4cad68 Merge pull request #138 from njhale/verify-commits
+43b502193 chore: add verify-commits make target
+a5bcfe06a add maxOpenShiftVersion test for parsing full version string (#147)
+9caf73f4e warn on maxOpenShiftVersion specifying more than major.minor (#146)
+cc481dfd4 clarify maxOpenShiftVersion upgrade error message (#2326)
+fc5e9b57f Merge pull request #164 from estroz/bz/1989431
+4f3624c69 Merge pull request #166 from njhale/fix/drop-z
+9f21b6b0d fix(opm): clarify that bundle declcfgs are not valid refs alone (#741)
+f9bff9e54 fix(openshift): drop z from next calculated y-stream (#2324)
+edcddea0f Merge pull request #163 from estroz/bz/1989796
+859431bd1 Merge pull request #161 from estroz/bz/1989460
+f62aaf31c Merge pull request #162 from njhale/fix/rmpkg-deprecate
+a856ed067 Merge pull request #160 from ankitathomas/bz1983673
+4895c84a9 docs(diff): add point about versions that differ (#735)
+b3c146f57 chore(opm): note that whole dependency packages are added to the diff for now (#740)
+c41b52357 fix(deprecate): explicit pkg rm drops latest deprecated
+fb92eba59 Merge pull request #144 from kevinrizza/catalog-switcher
+a766f625d check for pruned bundles on add in replaces mode (#732)
+e6840f9ce Merge pull request #159 from benluddy/bz-1990850
+512dde7b5 Handle property and dependency values of type BLOB in ListBundles.
+3a21821b7 Merge pull request #136 from timflannagan/update-leader-election-psm-config
+e47245b42 Merge pull request #154 from njhale/fix/invalid-max
+e4e78e51f Makefile: Ensure cross-compiled opm binaries produce non-empty version information
+9889a1ad7 Merge pull request #151 from dinhxuanvu/catsrc-priorityclass
+a47e7c1b4 Merge pull request #149 from benluddy/bz-1989710
+f848f27a1 Use GitVersion to parse version from discovery (#2312)
+552292e08 Merge pull request #147 from benluddy/bz-1989600
+90140470a fix(openshift): block upgrades on invalid max properties (#2302)
+06abc61a5 Merge pull request #148 from dinhxuanvu/catsrc-priority
+42f4b533e Add PriorityClass setting to registry pods for default CatalogSource (#2304)
+bb05a865e Fix nil function in buildContext return values (#610)
+4f39a6fb6 Prune unused ClusterServiceVersion fields from catalog's informer.
+64cf2683c fix(og): Fix missing MultiOperatorGroups condition in some cases (#2305)
+d4bc691a2 Set soft_heap_limit for SQLite-based registry servers. (#728)
+36a8575d9 Omit manifests from ListBundles result if bundle image is available. (#725)
+d6d2b6d14 Update Registry to stream bundles (#723)
+1b907c7ed Set legacy API fields in ListBundles using available properties. (#724)
+ba7041aac Aggregate properties/dependencies in-query for ListBundles. (#720)
+82328e004 Wrap catalog update test with retry logic (#2311)
+85f5cf292 Catalog switcher (#2281)
+cf7140bf3 Merge pull request #143 from joelanford/bz-1923111
+298bdf6da Merge pull request #142 from joelanford/bz-1987160
+b6361dd3f installplans: retry crd updates on conflicts (#2293)
+295bf0213 fix(diff): heads-only mode should not attempt to parse old refs (#727)
+5c57b2841 Merge pull request #139 from timflannagan/opm-alpha-diff-fix
+4e6b4bad7 cmd/opm: Fix panic in opm alpha diff when accessing the --skip-tls flag (#721)
+088bd07ea Merge pull request #135 from joelanford/bz-1969902
+50b71a7ec cmd/psm: Update the leader election configurations
+e736f4e14 resolver: remove legacy support for fallback parsing of CSVs
+3475b1d5d Merge pull request #130 from awgreene/remove-cluster-monitoring-label
+4a5ad031b Merge pull request #133 from kevinrizza/staging-temp-sync
+633919c08 Add managed label to configmap to reduce cache size
+6c855c7d1 Drop inline manifests from resolver cache.
+d20b7197f Hash and prune copied ClusterServiceVersions in olm-operator.
+eb186f880 Add openapi markers for csv (#141)
+e64a02403 opm alpha diff: generate a diff between two sets of catalog/bundle refs
+759381e2d Bump to k8s.io 1.22-rc.0.
+8b7f5fffe add declcfg.WalkFS function
+5fb2bda3a Add conditions to catalog source
+a37952102 feat(resolver): Indicate dependency class in resolution constraint text
+48a386dad Merge pull request #131 from kevinrizza/sync
+e5ee15397 Merge pull request #112 from awgreene/continuous-profiling
+887534217 feat(resolver): Move all predicates to its own file
+8e85501b5 add short description for generate subcommand
+6f67054dc add note explaining duplicate label keys
+25485737a add generate_dockerfile_test.go, fix format string
+352cceb3b add command to generate DC dockerfile
+a21216621 fix psm deployment
+0c3dd77e3 Introduce continuous profiling
+74ed30d7f feat(sub): Indicate resolution conflicts on Subscription statuses
+814dfec7c vendor of/api v0.10.2
+d3eb9c841 Add filter labels to catalog pod cache
+5e7648af0 Remove monitoring label from openshift-operators namespace
+ae9214651 Merge pull request #129 from kevinrizza/upstream-sync-branch
+ec51a3dd2 Update getMetricsFromPort to infer port number
+b77c2c064 Add optional opm image argument to chart template
+b04906462 Update OLM Deployment template
+a85c6423c feat: add GVK existence check for OLM supported resources by querying discovery in case of 404 not found errors when applying installplan steps.
+6eb4891e5 type(sub): Add ResolutionFailed condition type for subscription (#138)
+aa687ed16 Update olm and catalog deployment templates
+327d2471a Temporarily use controller-runtime fork with data race patch.
+a18a15545 remove unused scripts
+56a5579e3 fix(openshift): handle unquoted short max versions
+cf30b9f75 Use metadata-only watches when possible for Operator component APIs.
+62bd80fe3 Update extractMessage func
+0a118aa92 improve tests
+0a07b4624 Add list subcommands for packages, channels, and bundles
+c23e5ec56 add a resolver test for completely disjoint graphs within a channel
+92abe27ba feat(sub): Include IP failure condition message in sub status condition
+d8e537ed3 Don't cache copied CSVs in the controller-runtime-based controllers.
+9951b9553 Fix ClusterOperator selector for excluding copied CSVs.
+aad1cb2f0 Correctly omit skipped channel entries during resolution.
+7d0d57246 Explain unique replaces chain requirement in channel sort errors.
+e95915d80 Update test-scripts check to use go1.16
+ba29f0fa0 Regenerate mocks
+3626e03b2 Bump operator-registry to v1.17.5
+83eb1ce14 Enable gzip compression when unpacking bundles to ConfigMap
+cb9cb9fc7 Add a catalog-operator flag to set opmImage
+0d1d1f22a Remove unused trace log from LegacySyncHandler.
+0745028cb Use one HTTP server for healthz, metrics, and profiling.
+1529be474 Translate legacy "bundle dependencies" to properties.
+1e5aef296 move DC opm commands out of alpha
+246e0ce81 Remove pin of etcd and grpc (resolved in etcd v3.5.0).
+a0c78850a declcfg: improve and fix model tests to eliminate possibility of false negatives
+1dc76f08e Merge pull request #99 from timflannagan/packageserver-csv
+f465cc354 cmd,pkg: Filter out non-PackageServer CSV resources at the cache level
+1389cc834 pkg,scripts: Fix quoting around the release annotations key value
+d7ef83204 manifests,scripts: Fix environment variable not being evaluated
+40c7a64c7 pkg,scripts: Re-add the release annotations and default values in the PackageServer CSV resource
+41cdf6323 manifests: Update manifests after modifying manifest generation script
+9708bdda7 scripts: Update the manifest generation script
+a95a2d226 Makefile,Dockerfile: Add the package-server-manager binary to OLM container image
+91496b668 cmd,pkg: Introduce a secondary-level controller that manages the PackageServer CSV
+490b91128 manifests: Remove the PackageServer CSV YAML manifest
+f105c2f5d go.*,vendor: Update the o/api, k8s, and controller-runtime dependencies
+8740cee32 Merge pull request #116 from timflannagan/rebase-master-bluddy-main
+6c75da9ca OWNERS: Add additional reviewers
+94234302f Create OWNERS
+23c71d219 Fix release manifest generation and regenerate manifests.
+1f8f81035 Bump root module to Go 1.16, tidy, and vendor.
+dae62e798 Add grpc-health-probe to cmds (part of registry image build).
+8c2e98ae1 Build cpb directly from staging.
+2797a1bc0 Fixes to CRD v1 compatibility in tests.
+145c9df74 Fix endless loop
+4559b89fd fix: update e2e test CRDs to use v1 structural schemas
+625fd6f8c bump VPA crd to v1; use new embed directive in vpa e2e test
+1d3f32990 fix: remove v1beta1 CRDs from all e2e tests; add deprecation e2e tests
+0c5cc08cf don't watch unlabelled secrets in the operator controller
+21973f1d8 Fix error check for list operatorgroup call
+43299f840 Vendor api v0.10.1 and regen code and manifests
+0bdf52d9a feat(og): Project OperatorGroup errors to status conditions
+3461fb97a feat(render): render sqlite database files
+dc800e161 model: fix test for ReplacesNotInChannel
+e4d6a3101 Add a label to secrets managed by OLM, and don't watch secrets that omit the label.
+fcdd8831f declcfg: validation should allow non-existent replaces value
+bc1b56e50 feat: bump k8s.io/* components to v0.22.0-beta.0
+4bb90c822 doc/design: Fix broken milestone link in the release.md
+b67943920 remove cleanup from startup
+a49736922 doc/design: Add a version prefix to the release tag in release.md
+6d4870098 Cleanup residual appregistry-server image references
+b05e7f74a Bump OLM to v0.18.3
+4de6a5b95 (fix)InstallPlan: Do not tranisition IP to failed on OG/SA failure
+056e101b9 add storage spec to scorecard config (#135)
+06dff04e8 Add conditions array to OperatorGroup v1 status (#133)
+65673206b Add validation to CSV name length (#134)
+4d9061009 Add UID Optional field to scorecard config types (#110)
+6dd3f7078 feat: update the channel nammming conv (#129)
+03b6e7e51 chore: bump k8s to 1.21 (#130)
+7dc6cb5ce Fixed CSV deployments label field doc
+929df256b Add an option to store Gzip-encoded bundle data in ConfigMaps
+2f8ddb603 remove testdata index.db (generate it instead)
+3871c6ab0 add defer statements to close rows and db
+05aca3841 Query related_image table when rendering DC from sqlite
+d03380e06 bump kind to 0.11.1, print bundle unpack pod logs in e2e test
+a44654cc5 (fix)registry: fix configmap registry server liveness probe timeouts
+5bbc8b894 ignore recursive self referential suberrors
+777620be8 fix formatting issue for empty leaf suberrors
+8d98b256f use filesystem instead of directory path string, other minor improvements
+da01c7232 declcfg validation: output errors as tree
+6ea414b45 declcfg: validation should allow non-existent replaces value
+79ea08c06 remove path checks from deprecate
+8952c05ef Resolve InstallPlanStepAppliedWithWarnings alert after some time.
+ab4b3509d install.sh should not abort if openshift olm is not installed
+a2dd2b9c2 check presence of all bundles before deprecate
+e982c882d improve code coverage
+0e4024e38 change LoadFS argument name back to root
+21c772dfd declcfg: change LoadDir to LoadFS
+817d4ede7 Registry ensure methods error out if resource is not found
+ef9b01826 Resurrect deleted metrics Service templates.
+c42124c1b Remove travis build badge from README.md
+8235f338c improve code coverage
+681e5d07f Add support for .indexignore files in DC dirs
+e8cfebf3d feat(bundle): consume explicit properties
+4d814222f Address various issues with OperatorCondition codebase
+167137831 Update OperatorCondition Role and e2e test case
+44ded2699 Add OperatorCondition status sync and update operator upgradeable check
+b67b3e161 Fix Template Annotations on Webhooks/API Service CSVs
+559e733f6 Bump OLM version to 0.18.2
+bcfba8b4a Check for conflicting install
+bc194d2c1 fix example bundle dockerfile
+9552d455c improve code coverage
+cb60b277e Remove `opm alpha add`, `declcfg.WriteDir`, and related now-unused code/tests
+cc1be30fe Surface API server warnings when applying plan steps.
+4d6169ce4 Bump kind dependency to v0.11.1.
+442fcd003 Fix verify target
+aba268ae5 Fix nil pointer dereference while reporting bundle unpack status.
+793ffb31a Introduce verify github action (#127)
+5229f0fde Update generated deepcopy (#128)
+17423d53c address review comments
+83e793a9f Regen go-bindata for crd changes for OperatorCondition (#125)
+b56cd6d61 Add `opm alpha init/render` commands.
+4a4b236ab Add draft release info to opm release doc
+728fe6a14 fix(sqlite): upsert deprecation table entries
+fb14c70e9 Update 0000_50_olm_17-upstream-operators.catalogsource.yaml
+46dab665e community-validator: improve msgs raised (#124)
+2758fc261 Add polling interval for default catalogsource
+b4feafd90 Add ConditionType to v2 api (#123)
+34c4e15b9 Add conditions array to OperatorCondition's spec (#119)
+96d494863 Update OWNERS (#121)
+2c7ca5c58 additionals and improvements to dealing with deprecated API(s) (#120)
+ac555acce fix(containerd): drop xattrs during unpack
+18ca6d0a9 Remove component adoption labels before initial CSV copy.
+260261946 Explicitly set `readOnlyRootFilesystem: false` on created registry pods.
+9d79329a1 Filter secret names for registry pod's sa
+a18d45953 test(sqlite): ensure tolerant bundle removal
+2f16427ea fix: elide channels with deprecated bundle heads
+be89f91ff Make ClusterOperator Available condition sticky.
+76dfca71a fix race in test with mockRepo/mockBlobStore
+c495b766c use snake case for catalogsource_ready metric
+e278d003c Call cleanup sync.Once.Do
+fc416f754 consistently use latest go1.16 in all workflows
+3162de6ba feat(metrics): Emit metrics for CatalogSource state
+a877d40f7 deploy/charts: Any monitoring configuration for the PrometheusRule/ServiceMonitor resources
+9a7103a72 deploy/chart: Remove any OCP-related helm chart conditionals
+063cace09 Remove the deploy/ocp directory
+e2a220b11 Makefile: Remove references to the internal ART team
+0c8e70b91 Makefile,scripts: Remove references to handling OCP helm charts/manifests
+0812d1567 Add eventually to e2e test crud operations
+bed4e3617 Add unit test for varying job timeout
+e401c7691 Add unit tests for UnpackBundle
+843a0c70c Parse timeout annotation before UnpackBundle()
+e13938b97 installplan e2e test fixes
+070268778 Add annotation to override default timeout
+f41a3d389 Check for bundle unpack failure via status conditions
+4c132b124 Cleanup e2e tests and add case for invalid bundle image
+a454c1be1 Fail InstallPlan on bundle unpack timeout
+864ad064c update readme to link to olm docs
+28883598f Fix for resolution error on channels with deprecated inner entries.
+4c43a0db1 Simplify deployment status check to reduce flapping.
+ac935726e doc/design,Makefile: Remove references to root manifest directory
+c5a18bacf Remove the root list of YAML manifests stored in manifests/
+22686cfb0 pinning apiserver for delegated authentication watch request bug fix
+23aeccc97 fix(packageserver): add tolerant delegating auth config
+93b0f7b1e add SetEscapeHTML method to declcfg yamlEncoder
+0ca2008a7 always write yaml start separator
+5140b438b improve test coverage in internal/declcfg
+51c2bee14 revert WriteDir to use JSON, but keep WriteYAML support
+8edc6b1d2 Set yaml.NewYAMLOrJSONDecoder buffer size to 4096
+cdb386159 Support and default to YAML formatting for declarative config
+1b4115e48 fix(deprecated): don't verify deprecated replaces
+bf53a57fa pkg/validation: set v1 and v1beta1 CRD defaults using the correct function
+c9ccd5317 Annotate CRDs that are installed alongside CSVs.
+2eb5deb4c fix(deprecated): add sqlite table and migration
+cb99b9e2a Improve load func error handling to expose more information
+b600ecfd5 Revert "Test for bundlepaths before deprecate"
+e3de97a06 Remove OpenShift-specific Dockerfiles.
+92d8ada89 Set reason/message for Available condition in packageserver co
+b61df977a .github/workflows: Add the unit and verify workflows
+266d9e291 Add -kind.verbosity provisioner option and reduce default verbosity.
+f5881c0df v0.18.1 release
+cbf398c9e Fix mishandling of log format strings in Kind test provisioner.
+c67cf05c8 .github/workflows: Enable GH action that retests failed workflows
+a0e7b1f45 bump kube-openapi to get validation fix
+a1a7940e0 add unit test showing cr validation bug
+1320da45f v0.18.1 version bump
+6613a5042 fix(bundles): symlink cp at expected path
+5b1c56525 revert api signatures
+0d8f2542e check presence of all bundles before deprecate
+61e76c4cd .github/workflows: Remove the e2e-minikube action job
+f62f1b4f3 .github/workflows: Add action that emulates tide commands
+507752940 Use DeploymentAvailable instead of custom test for CSV status.
+5dbc27b04 Bump ginkgo to v1.16.1 and gomega to v1.11.0.
+1f48edc02 Move config serve and validate to opm alpha
+8105826d1 Add optional go-apidiff test to CI
+8bb7f1b31 Force latest install of podman to fix currently broken e2e tests
+58439d47e changelog for v0.18.0 release
+67b3f1412 v0.18.0 OLM release
+b23f0cf57 Delete operator-lifecycle-manager.Dockerfile
+43cb5c042 Bug 1952238: Report catalog pod termination logs to catalog operator on exit
+cfcb62ad0 replace dockerhub images on the upstream dockerfile
+ebdc14c13 (bug) add after deprecation
+fc7d1d8b4 bump OLM version to 0.18.0
+c0c4ecef7 Add unit test to verify resolver error handling for sync namespace
+88e89fb64 fix(catalog): Reduce namespace resync in resolution failure
+f684b8e2f Add retries when pulling images
+138139926 Fix panic due to empty version in the ClusterOperator controller.
+01549abe5 Fix resolution error if inner entry doesn't provide a required API.
+19ef710b0 fix(openshift): prevent race condition in the clusteroperator controller
+ff84b85e2 refactor(openshift): use a label selector to filter copied csvs
+25b301670 refactor(openshift): use mutator interface directly
+3723de2ba refactor(openshift): build skew message more efficiently
+dedfd87dc refactor(openshift): don't rely on reflection as version predicate
+a62b5294b test(openshift): use local timezone for timestamps
+9714f2dc4 chore(modules): bump controller-runtime
+b215ec29a feat: block openshift upgrades for incompatible operators
+7fe6b78cb Replace codecov-action with vendored upload script.
+c35e58db3 go.*,vendor: Bump the k8s dependencies to v1.20.6
+035012090 go.*,vendor: Bump the k8s dependencies to v1.20.6
+e4aea633e Update api version, vendor & enhance testing
+f2cac5762 Add resource requests for bundle unpacker
+d8acff403 .github/workflows: Fix error when installing podman
+60f84a7d9 .github/workflows: Remove unneeded docker-env command
+e40329f6a go.*: Update Go module version to 1.16
+69e7b9126 rename k8s optional key for k8s-version (#111)
+ec8fd6b0b fix merging envvars from subscription.config
+f21660dae add failing test for merging envvars from subscription.config
+8af1635cd test(sqlite): ensure annotation property validations
+3b409194a deduplicate properties from different sources
+fa5e33209 feat(sqlite): accept any property type
+d9622bd82 Revert "set packageserver replicas to 1 for single node"
+8638cc766 adding --enable-alpha feature flag
+6eb4fec2f (feat) substitutes-for logic
+fbc23fb5d Always validate CR upgrade compatibility.
+0adcd5413 Add time-limited retries to InstallPlan execution.
+ebd301563 (opm) move add from root to alpha
+d816f2c62 Add tests and fix bugs for declcfg server
+73db35eac Improve the declcfg and model validation
+dc1759e14 feat(validate): Add opm validate cmd to validate config files
+85dbd598e Delete the symbolically linked operator-registry.Dockerfile
+c9a4ae5ce add/modify e2e and unit tests
+ca3b54c01 enable tests on internal package
+0fc84d8e7 introduce space between blocks of code # Please enter the commit message for your changes. Lines starting
+7f08e8d02 rename getNoOfBundles to countBundles in model_test
+52dab5ec6 unpack and remove bundle direcotires after creating registry bundle
+da16481a9 use OnError to retry bundle pulling job
+c9a5f8da4 feat(declarative-config): opm add creates declarative configs
+9a009c1fd Bump github.com/operator-framework/api to v0.8.0.
+45f46a1ec Copy all CatalogSource annotations to its Pod
+2218d9e64 Remove more testify assertions
+346ea7b00 Fix e2e test with incorrect gomega matcher and remove testify usage
+6639326c3 Add .status.message and .status.startTime to InstallPlan. (#108)
+3ac7baf1b Consider InstallPlan phase=Complete as terminal
+6d0c894b4 Clarify status condition error message, and update architecture docs
+f1fb6d5de Add e2e tests for installplan failed on invalid operatorgroups
+51722db91 Indicate invalid OperatorGroup on InstallPlan status
+97e9c8842 Give more precise reasons for Subscriptions with no candidates.
+062a42928 go.*,vendor: Bump to k8s v0.20.4
+829737ef9 add checks for operatorhub validator (#103)
+e49b35527 add server for model.Model
+13867a1a9 disown copied csvs
+ec0560110 remove component labels when copying CSVs
+aad84fdbe test that the operator api never adopts copied CSVs
+d0b1a18d1 Preserve existing ServiceAccount owner references during installs.
+24bb8bf1a update of api dependency to 0.7.1
+468b7a4b6 bump api version to v0.7.1
+c87cb8d48 use equalsDeclarativeConfig function in load_test.go
+d574c2bb9 move newly introduced packages to internal
+996ba15e9 declcfg_to_model.go: ensure package field and property align
+4c5da9f6d pkg/(declcfg|property): PR review feedback
+24e76ecf8 Avoid stuttering "mkdir <dir>" errors
+6bae6a5ba feat(declarative config): add base packages
+ff11b3635 .github: Separate the jobs in the test workflow into their own workflows
+b9766f13b Update OWNERS (#107)
+da28dd255 go.sum: Re-sync vendor dependencies
+dd98dfc4f Update 0000_90_olm_01-prometheus-rule.yaml
+779bc586c add CsvAbnornalReplacing alerts
+dc9a25092 Bump test dependency on kind to v0.10.0.
+e731b2c18 set packageserver replicas to 1 for single node
+e5f917cd9 Dockerfile: Avoid hardcoding the kubebuilder version in the build root image
+74cdc267e Fix inconsistent dependency candidate order.
+7aa1ed5dc Allow to override download url in install.sh
+d1b737042 remove appregistry-related tooling
+e8d2a8e71 opm registry add: add --ca-file to add a PEM to the cert pool used by the command
+0c6c0e6a9 Dockerfile: Add a symbolically linked release Dockerfile
+b04bb16d8 pkg,test: Avoid setting metadata.GracePeriodSeconds to zero seconds
+c85802a6f Update the template of PRs
+c2c72f01d go.*,vendor: Bump module Go version to 1.16
+7b7bbe65a Dockerfile: Use Go 1.16 image tags
+68089a824 Dockerfile: Add a symbolically linked release Dockerfile
+fddf59338 test/e2e: Disable the bundle unpack opm e2e tests
+bc1ae68c4 .github,Makefile: Add linting check against Golang packages
+11e465220 *.go: Commit changes after running 'make lint' locally
+f81b5ef6c test: patch existing CSV for a hotfix
+db3d584af Update editverbs and Make the instruction clearer
+a6b214075 Set labels for the operator Deployment created via the ClusterServiceVersion
+cd1c5f8bf Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-lifecycle-manager.yml
+154810eea test/e2e: Remove duplicate package imports
+7ae79f13d bump to Go 1.16
+45683368a test/e2e: Capture stderr output when checking for docker and podman
+55eb49d81 test/e2e: Fix output log message when Podman is not found
+c82343867 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-registry.yml
+15a28d424 go.sum: Run 'make vendor' locally
+40d8800ef tools.go,vendor: Remove trailing slash in github.com/go-bindata/go-bindata module
+88274df70 Add optional go-apidiff test to CI
+ca77a30e7 Add skips & relatedImages to CSV Spec
+b541208ae doc: moving channel naming doc to website
+641e7a672 Bump github.com/operator-framework/api dependency to v0.7.0.
+f01584a99 fix: add lifecycle/frozen tag to exempt list to stalebot closing certain issues
+916683b54 Remove package msodbcsql17 during e2e tests
+6b082c7c5 Bump all Go binary builds to 1.15
+7be30c83c Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/5a1293dd0f380abf50c12d65c36655486d7745d0/images/operator-lifecycle-manager.yml
+a0805419f Support jittering relatively small resync intervals.
+3d8c55bd4 feat: add cleanup phase; fixup cleanup api
+44fd10578 don't change CSV phase on service unavailable error
+f099052d1 Gracefully handle service unavailable errors from kube-apiserver
+616ff1a37 Allow non-CSV-owned ServiceAccounts to satisfy CSV requirements.
+4585a8d4b Use reflect IsZero() method for checking zero values
+b5e404062 Add API for cleanup spec and status
+11e774d2c Expand validation to annotations
+862e31227 only override deployment resources when explicitly defined in subscription.spec.config
+a00af2d07 README: Address markdown violations
+55b8f4cf0 go.*,vendor: Update vendorered dependencies
+7e5579949 Makefile: Add the tidy and verify subcommands to the vendor target
+d02da0afe cmd,pkg: Deflate unnecessary conditionals
+8f1266cf1 OWNERS: Update the owner file
+1173b459a Infer package name property for unannotated CSVs, if possible.
+ef8def4ca pkg/operators/v1alpha1/subscription_types.go: make config and resources structs optional via pointer
+139232eff test/e2e: Revert disable Podman-related e2e tests
+44d597863 .github: Fix Podman installation steps
+fcfbe36ba Additional changes based on feedback
+366dbe22c Changes based on PR feedback:
+033c9ebc6 update makefile, workflow, and docs
+c5f114658 pkg/controller/operators/operator_controller_test.go: fix flaky test
+3943cfb40 test(e2e): add bundle unpack test cases
+8c8d1d4f2 chore(lib): reduce log noise from image registry test facet
+aaec691ce refactor(opm): export root cmd
+3b1b713ca style(logs): reduce info log noise
+3132dc1f2 feat(opm): add alpha bundle unpack command
+29777953b upgrade to use go 1.15
+26f354450 Add details for starting a local server to README
+13c7ffb24 doc: clarifies opm usage and what tool can help with bundles
+76e40142b Deprecate initializer and registry-server
+83d19536a fix: add apt-get-upgrade to ci script, skip podman-based tests until fix is identified
+932b6e3aa Specify cluster name when there is only one cluster in kind
+a25dcd2e8 Enable debug messgaes via klog
+263f485fd Annotate manifests for single-node-developer cluster profile
+48ec5419f Don't create default ServiceAccounts
+82c261b55 bump to go 1.15
+7095864ed Update release.md with milestone step
+8ef6f5f04 update development document to add more informations for the e2e environments
+30b2627fe chore(adoption): use debug level to log missing components
+9f853662c add missing closes
+d4accff88 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/a74468426e8d0524b2fca64bbbcda77afef25b80/images/operator-registry.yml
+eaf24068d docs/design: Remove all references to the bundle alpha opm commands
+2da4d80f4 docs/design: Minor documentation fixes
+e655c312f Fix typo in deprecate+truncate command help
+811d94bc5 .github: Use the pre-installed Podman dependency
+61838426f fix(resolver): Allow skipped versions to be installed initially
+e143c928e Fix typo in docs
+73af1b0d5 support multiple subscriptions resolving the same bundles
+481ace0e5 add package property to unit test cases
+04baa720a collapse resolver tests
+bcba38ca5 Add meaningful string representations for resolution invariants.
+7b1d7c443 Correct timflannagan GH ID on ownerfile
+48c4d5f76 Update OWNERS file
+2baf7110b Fix upstream example dockerfile
+b14f6445c Various from PR comments
+ccf62da0e fix(index): add build id ordering to channel head selection
+53f9e5d60 test(e2e): make index add regression test pluggable
+d7a06e9b1 (e2e) regression check with existing catalogs
+17be23411 Fix OperatorGroup Documentation Example
+82208735b bump k8s.io/apiserver for webhook auth panic fix
+12d8f6087 Clarify subscription constraint strings in resolution failures.
+7f96a43d0 fix: use none driver without sudo in upstream minikube e2e tests
+fa7e4ae16 fix e2e test order
+27fda6b2d Address comments from PR review: added e2e, improve unit
+7e6df5b5f operator_controller_test.go: use JustBeforeEach to ensure correct test setup order
+494108d49 Only re-create operator resource if it has existing components
+d23ea4600 Add unit tests for Operator controller deletion handling.
+6c6fb2899 Fix time comparison in CSV reconcile loop
+edc880a4c Fix zero-delay resyncs for certain registry update policies.
+a70ff7077 Use docker driver for minikube installation test.
+e29631dea add shorName for operatorcondition
+707d3f3cc fix error on missing icon
+afc259b0c fix: improve stalebot configuration for github issue tracking
+0e2b21d73 feat: use secure local registry for e2e tests
+ff436d69e Fix infinite loop when a CSV replacement chain contains a cycle.
+07f0ac6fa remove stranded bundles when packages are pruned
+735ee792f ensure foreign keys are always enabled
+06e1e2a4d RELEASE.md: add release guide
+5aee47837 chore: bump c-r to 0.8.0
+5285b1a00 Update shields
+632899a01 Bug 1909992: Allow private bundle images within private indexes
+5efeced30 Update OperatorCondition controller to watch deps
+5b1df68a3 fix: create installplan directly in e2e test
+f77b94158 fix: use OLM client when installing CRDs
+ce1b12b52 fix: load required docker images for kind cluster in ci e2e test
+ba696f755 Add joelanford to OWNERS as reviewer
+8a8c81973 Create CSV Deployments with OpCond EnvVar
+bd07f8ee4 Fix operatorcondition role verbs
+c5b60fc76 Updating Dockerfile baseimages to match ocp-build-data config
+6e2197ef6 fix: update moby/term dependency due to undefined: unix.SYS_IOCTL on macOS error when running locally
+5b3b80ee2 Use correct caBundle for 'olmcahash' annotation
+fb76eec77 Update /manifests with default cluster profile annotation
+7a8ee9480 Add the release annotation to all documents in all files
+2e03006a4 Change the "OperatorUpgradeable" condition to "Upgradeable"
+5d5c64d73 Multiple operatorconditions should not update the same deployment
+94359f6e3 CSV Annotations override pod annotations
+c161839b3 Reduce e2e test failure rate
+4de7d447f Fix windows build with golang 1.15
+d58361049 Update manifests
+d59dedc94 Fix manager start commands
+0053fea4e fix zap logger
+da304188e Fix controllers and run codegen
+764b474dd Update semver import and update SSA
+9a1c2a17e bump k8s deps
+11056a829 Rename OperatorUpgradeable condition
+669446027 Bump k8s to 1.20
+c8515dfc7 Remove operatorCondition lastTransitionTime
+0285acc3a Bump yq dependency to v3
+f0194d13c deps: bump k8s deps to v1.20
+f99f433ed Bump controller-runtime to 0.7.0
+324003da5 feat: move upstream tests from travisCI
+6838951ab cleanup formatting
+5aa8734f1 initial channel naming doc and related images
+f94e87c08 fix(olm): Verify ServiceAccount ownership before installing deployment
+93be770da Don't create OperatorConditions for copied CSVs
+b03509597 Reduce log noise from OLM
+7a20b814e Update go version to 1.15
+059877eb8 Preserve original .status.lastUpdateTime in copied CSVs.
+13753d676 fix(e2e): Fix subscription manual approval flaky test
+fcc5fd1c8 Add OLM support for the Upgradeable OperatorCondition
+af0f41914 Avoid duplicate registry binaries across downstream image layers.
+8dcf48819 Disable broken ppc64le and s390x release builds.
+89c288ed9 Change OperatorUpgradeable type to string and add utils func
+325f42b01 revert the change for e2e test
+488b082c8 format the import order
+d0820446a Only check the owner of the service account if the service account has owner
+9da07b24f update e2e test
+768fd9e65 check the service account owner in the requirement  check
+2c267134a Introduce OperatorConditions
+c3fee72a0 update manifests
+a1ddc4487 Add authentication for private index images
+87107d326 Support InstallPlan steps upgrading existing ClusterIP Services.
+6d779af35 fix: remove extra test output
+42670177d fix(index): account for default channel in index add order
+3c33a9606 Include the bundle image itself as a related image.
+d3f6dd79b Add OperatorUpgradeable condition type to OperatorCondition api
+cc2b7c1a5 Update OperatorConditionSpec
+546ab4200 Add release annotation
+6d6e033ae Bump yq from v2 to v3
+fac7d135e fix(catalog): be defensive about directly indexing catalog pods
+7f4070d4b feat: bump api dep to v0.3.22; add support for operatorhub and bundle object validation
+e17260bb7 (fix) make operatorhub validation consistent with courier
+d6f5336d1 Add OperatorCondition to the client schema
+ef2af7725 Update github action setup-go to version 1.1.3
+c9f5f4458 add default label to issues. add config file with upstream OLM contact information.
+151dc90b4 Using subscription reconciliation to clean installplan status instead
+b3a1a0419 fix(indexing): respect strict mode
+84dac3d16 fix(ip): Recreate pending installplan if deleted before approval
+51c28582e copy .git directory for build tag info
+dc0d980c1 fix(indexing): pick channel heads by semver
+b41ee2c64 fix(indexing): order bulk add by version field
+979806dd6 Introduce the OperatorCondition CRD
+d1aac6955 fix the description of validation "RegistryV1" format
+1d96b8e4e Add ConsoleYamlSamples to the supported resources
+decf662ab Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/f82a216a6a3707b80a635bace9367f1a8288b7a7/images/operator-registry.yml
+81cff1941 Generate code
+8720918a1 Bump k8s dependencies to v0.19.3
+25e0cbb07 Reconstruct replaces and skips for ListBundles from channel_entry.
+b6684c289 add skippatch unit test
+90975862d Bump k8s dependencies to v0.19.3
+d55da101e Bump k8s dependencies to v0.19.3
+19a41f8e0 Allow ConsoleYAMLSample resources from bundle manifests
+20fc6ffe6 test(certs): add a test the ensures services do not get the same ownerref added twice
+060718c64 test: scaffold a basic unit test for certresources
+f6a331a49 chore: generate fakes with inline go:generate directives
+0f182b191 Fix Go version used by release job to 1.14.z.
+6f9738842 (fix) close connection to db
+88c437768 fix the comment in package-server
+f0812c733 Generate changelog for v0.17.0.
+fd6cee1aa Replace assertions with Gomega's matcher library
+ec6a7f61b Add unit test case to grpc and configmap reconciler test
+a8d2e90b9 Add spec hash to service's label to ensure service is correct
+769dc4188 Generate manifests for v0.17.0.
+39d593c0b Bump version to 0.17.0.
+a119a3fa4 Build upstream releases with Go 1.14 instead of 1.15.
+54ce01380 Produce opm linux release binaries for ppc64le and s390x.
+9c82927c3 Convert scoped_client_test to ginkgo
+21b32d630 Add Github Actions release workflow.
+77dc76369 Replace assertions to use Gomega's Matcher library
+551710c0c Set default, min, and max values on Webhook ports
+cb6b1d2af Completely populate test database before executing tests.
+179e088f6 Remove unused file.
+f8255e1ce Add coverage report job.
+33f55c76a Set replaces in ListBundles query result using channel entries.
+f356b0e8f Default containerPort to 443
+57e9578e9 Set min and max values on Webhook Container Port
+7dfdd7be7 Start listening on test server port before running tests.
+4997cfb82 check prerelease version for semver-skippatch mode
+0897133be feat: support custom categories via environmental variable
+244aaf8ff fix(opm): properly deprecate export flag '-o'
+c732109dd fix race in Operator reconciliation
+7596881d7 Fix path separator in generated bundle Dockerfiles on Windows.
+fe312f353 prevent no-op hotlooping on Operators
+6f40c1a40 Add writable workdir to configmap registry image.
+8a5966ec3 Fix test flake based on random aggregate error order.
+60d2d4fe5 fix typo
+7fd3d1c50 Update pkg/controller/registry/resolver/resolver.go
+00513f578 update error logs for channel head querying
+0dcdb4393 OLM mounts CA Certs where Kubebuilder expects
+6c24a1f32 Make the inability to create /etc/nsswitch.conf non-fatal.
+d25fe21a1 Improve transitionCSVState error logs
+27ba9bdc9 fix typo in the error message
+2c61ceb05 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/ac81dd4ff0bd57c4e75058d25b40615b92948259/images/operator-lifecycle-manager.yml
+3d2cf4608 Retrieve CA from conversion webhooks for CA Hash
+da043a289 fix: remove extraenous manifest assignment and update CRD stepper. Add e2e test to verify configmap-based manifests.
+bef8c443c (fix) concurrent writes during image pulls
+7677c9bc1 fix(dockerfile): clean out tmp directory after binaries are placed
+ef2491b3a update the help info of the export subcommand
+0c8f594f2 Add USER for non-root image usage
+6c0a0d50d fix the comments of LabelDependency in the type definition
+c57ff1627 OWNERS: add operator-sdk reviewers estroz, joelanford, jmrodri
+645a16bfe LICENSE: add apache 2.0 license
+7cbbcc6a0 fix: pass in bundle objects
+c29c22ddd Apply suggestions from code review
+4214b5b76 doc: add reporting bugs doc and small nit improvements in the README
+168a521c7 Regenerate downstream InstallPlan CRD manifest.
+b9007041b Annotate CSVs with the properties used during dependency resolution.
+29b8930fc Bump operator-framework/api dependency to v0.3.16.
+a35b39491 Enable default channel inference for the first bundle of the package
+122b2bc9f Update upstream-builder.Dockerfile
+72a18659f set group permissions on /tmp
+5e0108fdb Bundle validation will not fail if default channel is not provided
+e5f271bd3 feat: bundle object validation
+0be88d2c3 (fix) bundle inference should not use skiprange
+a44127257 Update index add func to handle optional default channel
+8b61e24a8 The default channel info/annotation is optional & not required
+a11896d41 (fix) erroring when replacement not found
+b81f31383 fix(mockgen): use "go run" in all go:generate comments
+086ae52a5 chore(modules): bump k8s deps to v0.18.9
+fa2556e4e (fix) index add --overwrite-latest
+95314797c Add a "properties" field to bundle lookups.
+468c3c76d fix: update check from previous polling implementation
+4dcec936a Make a subscription without at least one candidate fail resolution.
+b21763379 Allow ConversionWebhooks to define targetPort
+2e631d704 Bump operator-framework/api dependency
+61df859c0 Add ConversionWebhook const
+37ca92f33 Update CSV WebhookDescription struct
+3a6af663a Add test to verify empty bundles in addition does not break
+81af525f8 Updating Dockerfile baseimages to mach ocp-build-data config
+04824ccbe Updating Dockerfile baseimages to mach ocp-build-data config
+efd42bc92 (fix) csv name should not be constrained
+686d3a407 should not compare if no imageID
+a42167a9d doc: default polling
+ff98a69a1 OLM should use valid CA certs if available
+e4269e01a Parallelize opm index export
+5eedba91b Use vanilla Alpine instead of Alpine+go for the registry image base.
+1d2129a4b Use multi-stage build for registry image.
+5c661c151 add cross build back
+4b5509802 disable cross compilation while build issues are resolved
+cc8755292 fix: update catalog pull policy to Always in case the image is not digest-based.
+157b0484c fix(build): copy bins to a tmp directory first
+2eb1f3d2d add workdir permissions back
+f5ad42fb8 fix(operator): map top-level csv phase to component conditions
+dc804f685 add correct polling interval based on modulus
+a7d23bf42 fix: resync catalogs with jitter if polling enabled
+d12d8fac6 test(install): expect revision history = 1
+e34afec44 fix(bin): don't overwrite /bin
+6eb8bdb36 Set RevisionHistoryLimit per Deployment
+b21979282 fix: remove catalog update pod if it's in a failed state to prevent cycles in the catalog reconciler.
+6dc415fa4 fix: requeue catalog source sync if update pod has not reported ready; remove duplicate pod immediately after imageID check; turn down polling logging
+0e349b031 Handle mutliple skips and add unit test
+92702cdb3 Add skips information to Operator representation
+bff757fad Genereate 0.16.1 changelog
+360e63d99 Release: Generate Manifests
+78887a8e8 Bump OLM Version to 0.16.1
+470b5332f add mac and windows binaries to the amd64 build
+34cb22d2a [typo] fixing typo in deprecatetruncate command
+21f4a58df Update OWNERS
+019bb4f17 Update OWNERS
+ac0912068 Update OWNERS
+4ae40219b Updating Dockerfile baseimages to mach ocp-build-data config
+d1d830210 Updating Dockerfile baseimages to mach ocp-build-data config
+946761b44 Move server side apply patch code to library, use ssa to update catalog source pods
+ec857b743 Update Owners file
+51d3a32ee Fix install plan creation for subscriptions that omit channel.
+32ca0cdf7 Bug 1861605: Update manifests to include the bug fix
+9e0f1375e Bug: Fix nodeSelector subscription config override
+eef955cbc set default for flag --skip-tls=false
+911539782 extend skipTLS option to podman
+7f7dbdfa2 skip TLS option for pulling indexes
+ae7d9120a fix: add dashes to semver range example
+0c5049015 Fix typos
+8bde9e6b7 Remove label dependency from bundle docs.
+a816903e9 Return empty properties and dependencies in ListBundles responses.
+3774ef812 rebased
+ccd715c54 Fix stale content in configmap due to stale bundle image in the node
+90752efa1 fix(operator): re-adopt manually disowned crds
+4fbd74dec Add Total Test Number to report
+de74109b1 Bug: Fix SubscriptionConfig NodeSelector field
+6a0274b09 Bug Clean up stranded bundles
+f5e963450 Bug 1861605: Reduce length of explanation of status of Operator resource
+851e6372c Bug 1861605: Reduce length of explanation of status of Operator resource
+0bb7fbb26 Approval: Clarify possible values
+dc85a9fca [docs] Update out of date compile step
+1e0277f22 Add Catalog Source priority for dependency resolution
+1881123f0 Vendor registry 1.13.6 and fix unit test
+42aebb4f1 feat(resolver): filtering deprecated bundles in resolver
+d75bf5b5a Add unit test to resolver for label dependency
+5acd71446 Vendor the registry changes for label dependency constraint
+f9beec09c feat(resolver): Add label dependency type to new resolver
+72242c1e7 test(e2e): pass ip test w/ created or present steps
+6888cfaf6 feat(operator): adopt referenced installplans
+e979fe72d remove legacy resolver
+0a16d8810 Remove spurious check for duplicate operators in resolver.
+9058508ba Addressed review comments
+bb0a0f6cf WIP: Add Conversion Webhook support for OLM
+b5fb6addb feat(registry): add graceful shutdown to grpc server
+64105c14e fix(query): return bundles in all channels
+e9c56be94 Remove unneeded toleration from catalog source pod
+8a4e5c0cc change default catalog to index image
+d07eb3000 chore(vendor): include v1 operator api version bump
+ccd092a6f feat(operators): reconcile v1 operator resources
+5a84ea9f1 chore(manifests): add v1 operator crd spec
+1a787a400 chore(codegen): drop v2alpha1 clients/listers/informers, add v1
+17681e567 chore(scripts): drop v2alpha1 from codegen
+a9fb39fa3 chore(modules): bump api dep to include the v1 operator spec
+ad0f19536 Add OWNERS to the repo
+c5a823429 remove scheme-related variables and scorecard output coloring
+91288de53 pkg/apis: add scorecard v1alpha3 API
+ac6994ec7 fix(codegen): add doc.go in operators/v1 to support informer-gen
+5e62dafb8 Remove unnecessary ENV directives from base.Dockerfile.
+e99d787a8 Remove sanity check from `make all`
+783aefd1f Add sanity test for opm registry serve
+1ed1a96c0 Add timeout to opm serve
+136c18a16 Update label property extraction from CSV
+bff982857 feat(registry): Add label dependency constraint and property
+d003cf1d0 Adding deprecated property type to bundles
+cb6f21038 fix(validation): Remove default channel validation from bundle lib
+63cce5ae6 Add installMode validation check for Singleton Operator conversion webhook support
+8d7b00722 feat(operators): move type to v1 from v2alpha1
+d2f0ea29a configure metrics for new resolver
+c28661f79 check for cache consistency issues when querying for a dependency
+192d912ff look in all catalogs when no catalog specified
+49e86eb54 emit events when resolution fails
+bdd657c08 fallback to standard path for kubebuilder assets
+46336752b fix catalog grpc connection state updates
+1d166e551 don't include docker image in the docker build test for kind test runs
+3d694b8ad fix crd upgrade e2e test
+7b09cff19 retry for flakes
+83df7b503 make catalog delete tests less flakey
+8c7ba08e4 add a parity test for transferring api ownership between operators
+e40737846 make catalog updates in tests less flakey
+e3818f4eb update package anti-affinity test
+230e372a0 properly handle solver invariants
+78c6e5598 track existing CSVs without subscriptions as mandatory
+c9d43d87b handle csvs that are already installed but don't have subscriptions
+f7f1c8324 extract properties/dependencies from existing operators in the cluster
+6dd346244 Fix check for whether or not a sub was added during resolution.
+1957d2295 Prefer bundles from the default channel in resolution.
+15b28d240 Try to detect kubebuilder installation path if not explicitly set.
+d266a043b Regenerate registry client test fake.
+84be8a7db Bump operator-registry dependency to v1.13.3.
+eb1a04e90 deduplicate input installables
+7645e4dac expire cache when grpc connection is READY
+831775936 fix sorting of inputs for dependencies
+1860af04c enable new resolver by default
+7a8fe42ca prefer the same catalog for dependencies
+57393d6b5 fix resolver bugs, fix cache race, and re-enable tests
+25ea8f9d7 fix nested dependency resolution
+994a99dbf fix verify
+67d71af7c feat: add parity tests to resolver
+337404579 ensure cache is filled with content before marking it as not a miss
+3c06499df renaming / refactoring
+39ffac870 rename solve package
+d9997fdca treat dependencies generically
+2ed0cfd1f refactor dependency walking to avoid recursing
+44d01f714 support skip list in bundles
+182df8da0 support startingCSV
+55b96e301 pin etcd and grpc
+db629d470 split old/new resolver and tests
+bcad82a53 test updating to a package with skiprange that is not head
+6eada4168 search for operators in catalog order
+d7babec9f move csvname filter to a predicate when finding bundles in the cache
+884c46a9a use cardinality-based AtMost constraint
+4bb534d06 resolver can resolve updates
+6773de588 chore(deps): bump operator-registry
+96affef98 don't mark virtual package nodes visited
+fe4783f25 Decouple filter predicates from the operator cache itself.
+f3990cc8f memoize bundle walking
+330eb5cf3 support semver ranges
+33d513011 use new solver interface in satresolver
+615acdeb3 Adapt resolver unit tests to run with both implementations.
+86de75273 Fix unit tests and add GVK dependencies extraction
+f530effb4 Strip plural from APISets in resolver cache
+9387be67a Extract dependencies info from bundle and add to Operator object
+a1a1a06bc (feat): Add sat resolver for version dependencies
+ba343e0bd fix(install): account for installplans when calculating generation
+9af80c094 [metrics] Dependency resolution metrics
+4d366b0f2 Added .spec.priority field on catalog source
+31bd7cf90 fix(query): list bundles would elide all but one property
+a1a738e85 Add busybox-dependencies-index image manifests
+c135637d3 Add conversionCrds field to WebhookDescriptions
+c9373188c Add additional logs to syncCatalogSources
+0eae770a7 fix(e2e): pass build tags to e2e
+7752f02ed fix(dockerfile): remove unneeded static dependencies
+4f1e14251 Bug: Fix incorrect deployment annotations
+78eec1b59 fix(installplans): GC older installplans
+cb19971fc Remove nonexistent group from Dockerfile
+9547d6da7 Embed version at link time based on git tags instead of a file.
+3fc237a52 Require csv spec.Version to be set for operatorhub
+097257259 Add flake analyzer
+068c5c6b6 fix: explicitly delete collection of catalog source pods in grpc e2e test
+a058b02ff Add GetPackage to the client interface.
+31aa9d2b7 Update OPM_VERSION
+530d21cef Update the e2e test case
+54ff40064 fix(resolver): Exclude all installed packages in dependency search
+70b28137b Omit (hopefully) redundant yum update from downstream builder stage.
+69ecef260 Fix UpdateSingleExistingCRDOwner test case
+3872318fd Fix validate CRD compatibility check and deprecated CRD test case
+5bfbcf4cb Return an error when solver input contains duplicate identifiers.
+6864de30c fix: use server-side apply in crd e2e test when changing the subscription to point to a new channel to avoid transient object modified errors
+689a8eb5d Refactor solver preference searching.
+e3f56352c Updating based on feedback
+dbab66ca8 Bug 1855088: generate unique role and binding names When same permission rules are defined for different ServiceAccounts, OLM would generate same name for (Cluster)Role and (Cluster)RoleBinding related to this rules. This change should ensure that unique names are generated, taking into account ServiceAccount name and CSV Name and CSV namespace (for ClusterRole)
+772f603d8 Bug 1855088: generate unique (Cluster)RoleBinding names
+ee5da016a fix: remove bundle e2e skip
+57d58cdea fix: Use PR head commit in artifact naming instead of merge commit
+31375e585 fix(metrics): query cache found object count metrics
+e2f65700e Setting resource to plural in relatedObjects
+f1c227a6b test(e2e): delete all subs, installplans, catalogs, and csvs in test teardown
+7e80746bc fix(e2e): make problematic test specs eventual
+fda6d7a4a fix(e2e): copy rest config from test ctx
+14d0618e0 fix(csv): prevent duplicate service ownerrefs
+18d6a8e02 feat(operator): automatically adopt generated resources
+af199f79d fixing up to return exit codes
+2cb8d1e16 Changed address for readiness probe and liveness probe on registry-server
+079a5b156 fix: install VPA CRD directly on clusterfor bundle e2e test.
+5f0093093 Adding sanity check and error message for inserting the same bundle
+a0ecedab3 Updating: adding sanity checks before insert into index
+fc5e1f301 fix(containerd): always [also] pull layers from linux/amd64
+c1f261542 fix(validate): pull bundle images before unpacking
+15a3cdaaa test(e2e): skip bundle cr install test
+45feebf6f Use go env to get architecture for building
+6a35e8e67 fix: add installplan check after subscription status check for gc tests. this will help reduce the e2e test flakiness as resources were sometimes checked before the installplan completed.
+605ab3a58 Add Label field in StrategyDeploymentSpec
+dc451bd4b fix(build): don't set -race when testing on s390x
+a79b14ea6 feat(api): add skips/replaces to listbundles api
+75747a16f fix: checkinstallplan status in bundle e2e test
+7b2414489 fix: add kubebuilder to development requirements
+b5d5ad0fd fix: broken link in PR template
+54fbe6c3e Add an AtMost cardinality constraint to the solver package.
+513b7692f Retry update in flaky test of CSV w/owned API Service.
+54783684e refactor(solver): small naming changes and iterative search
+993ee6b8d pkg/lib/bundle/generate.go: add JSON tag to AnnotationMetadata
+e0db8e7aa Introduce preference order for solver.
+ec56ad20a Bump GRPC version
+52c0daeaf feat(release): add builds for s390x and ppc64le
+753a5befa fix(opm): refactor indexer
+b941ade64 Use /. as the directory root to copy from.
+e059c5169 feat(deps): nest dependency values
+4d2c6f0c3 Add workflow to save e2e test artifacts
+837dc61a1 feat: support new bundle object types: priorityclass, pdb, and vpa objects are now resolved from the bundle by OLM.
+39f1516cc test(e2e): patch installplans w/ server-side apply
+ea09a5de0 feat(store): store provided apis and package info as generic properties
+9b44e17eb fix(docker): build grpc probe outside of gopath
+59e6e640a Update OPM_VERSION
+21586e294 Separate build/pull tool for index rm
+36e7c25a2 feat: add design docs for including additional objects in bundles
+8007c0a70 Bug 1822396: Update metric when Subscription is updated
+af4220200 feat: add pdb, vpa, and priorityclass object support to registry
+2d7f37c31 (fix) Update to go 1.14
+bdbbb1ab7 Update OPM version to 1.12.6
+f71745996 chore(deps): bump containerd
+ee0184cda fix: update README to point to the OLM book website instead of github repository
+d1e86c8fb Add more precise matching to the metric end-to-end tests.
+f011476a5 Update ocp manifests with latest template
+cd14be584 Remove failfast from operator e2e test
+51be87a6e Fix a flaky CRD test.
+e5aafa2b2 Replace assertions within async assertions.
+4922e6a10 Disable parallel e2e-local runs by default.
+03f574cac bump olm version to 0.16.0
+7ebea2fd6 Add operatorhub validation
+98a747d0b fix(installplan): don't store the manifest contents on the installplan
+01366b6dd (fix) Actually validate csv fields
+c2351f888 fix(crd): Fix CRD validation falsely error on unused CRD versions
+fb747a938 Bug 1822396: Delete subscription metric when an operator is uninstalled
+d1f76ebd6 Bug 1847540: resolve only default channels
+e08860c65 Add BugZilla component to OWNERS file
+41c23a17b test(server): wait for connection to go healthy before running tests
+389929591 Fix broken link to CONTRIBUTING.md
+4947764eb pkg/lib/bundle/generate.go: ValidateAnnotations does not compare number of annotations in existing vs expected so arbitrary annotations can be added to annotations.yaml
+53873646e beta.kubernetes.io/os deprecated since v1.14, removed in v1.19
+799b23560 fix(package-server): get icons from default channel
+59bfb459d doc: add CONTRIBUTING.md
+5c4db409d chore(modules): bump api dep to v0.3.7
+112d8a6f3 fix(copy): make tmpdir relative to current directory
+300881afb fix(images): use docker/podman create and cp for exec unpacking
+bb6d23e0b chore(crds): regenerate manifests to drop status
+318728664 chore(make): drop generated crd manifest status
+d551f752c chore(make): rename yq var
+0ed21428d Update OWNERS
+368b298a9 The api repo is now pinned to the latest commit which contains bugfix https://github.com/operator-framework/api/pull/39. This update also removes the bou.ke/monkey dependency that has a very restrictive license.
+7bf9f1d5d Modify prow ci logging for e2e tests
+ed140c71a feat: add uninstall
+bb33e2451 Changelog for 0.15.1
+4914787af Update grpc-health-probe version
+f304d2ab6 [e2e] Fix opm test
+cb54b5ba4 validation: bundle CRDs are compared by definition key instead of name
+bb93d81f8 Add test for release installation instructions.
+0dfd78134 Remove CRD manifests from 0.15.1 quickstart's olm.yaml.
+186d25e1f Preserve .crd.yaml suffix for manifests copied from api.
+87034d380 Don't put CRD manifests into olm.yaml.
+e098dd067 Catch failed Ginkgo assertion in test goroutine.
+7441b9ce3 Reduce install.sh flakiness.
+84189d5ab Convert metrics_e2e_test to ginkgo
+55e76d51a cleanup: delete duplicated import in olm
+d6234be9b feat(resolver): don't build new clauses for weights
+be95e235f add info over where the bundle files are or will be written
+69b2ebe65 fix: add err check before defer
+8b53b9833 chore: fixed a typo in bundle manifest format
+1481b4d94 docs: remove typo from dependencies example
+d9fdb9d99 feat: add OPM_VERSION notes to release docs
+cf9e51091 Doc: Remove legacy webhook proposal
+6f433623d fix: add check for storage version changes when installing CRDs. This prevents data loss when a CRD is upgraded and no longer supports existing stored versions of CRs on the cluster.
+438fcd1bb fix(unpack): support unpacking readonly folders
+b107cf050 pkg/manifests: return error if a bundle manifests dir has a subdir or hidden file
+ac74d6004 fix(catalog): no operatorgroups in a namespace should be an error when resolving
+0d0e77a06 Update PkgManifest upon catsrc update
+cdaed1d40 pkg/manifests: use yaml decoder instead of unstructured to avoid conversion issues, and close all files
+50cef154c Configure "podman build" to produce images with Docker manifests.
+3a9f54f27 Fix delay when OLM applies label to Namespaces
+ae23a0e48 opm bundle extract shouldn't validate annotations
+597eba274 Add more comments on e2e test case to clarify test flow
+01ce79c53 fix(server): make a copy of the db before migrating it
+296568bed Address feedbacks on registry client interface
+a47ce37ec Compose registry client & interface under a new interface
+b531ac38f Add e2e test case to test multiple dependencies with same package
+5b1aaa72f Update unit test cases to adapt to new changes in NamespaceSourceQuerier
+291bd4c98 Edit test cases to work with new changes on NamespaceSourceQuerier
+6d0b88590 Mockgen for registry client
+b910d5e18 fix(resolver): don't pick operator from same package when resolve requiredAPI
+ac1f2e5c0 fix(webhook): Wire ContainerPort to Webhook
+925b4d514 Remove registry dependency
+3e77564e6 fix(validation): Fix CRD v1beta int-float conversion error
+07c7d7560 WebhookDesc should use containerPort field
+5694cbbab fix: add ownerrefs to bundle objects; add e2e tests for bundle object gc
+815da1c84 Manifests for OLM 0.15.1
+ce80022d5 Bump OLM to 0.15.1
+96e55d50b Deleting a CSV removes related CSV metrics
+83510c270 Changelog for 0.15.0
+27b597d66 Pod Config Deployment Hash Error
+5c2bdcfd7 Manifests for OLM 0.15.0
+2912b3932 Update scripts to include crds during release
+dccdd506b Converted packagemanifest_e2e to ginkgo test
+e0771b9d9 upstream-opm-builder.Dockerfile: don't install bash; sh is sufficient
+3012ff6ef PackageManifests should include CSV Metadata
+28e173ea2 fix(queues): requeue events against all-namespace queue if present
+7ded3a39a Modify dynamic_resource_e2e_test to ginkgo
+62d656e9f Update Webhook E2E Namespace Labels
+d85d5ea3e upstream-opm-builder.Dockerfile: add bash and ca-certificates to runtime index image
+ce0084039 feat: add build flags to opm to show version information
+43b923e91 Adding error message for more than one CSV in bundle dir
+5e262241d Convert gc_e2e to use ginkgo
+ccb44f523 Detect WebhookDescription changes in CSVs
+f4f1061fb feat(opm): add version command
+496e6820c Make default channel optional
+f5155ff43 Make default channel optional
+48bbe2d08 Bump OLM version to 0.15.0
+be5bab281 (fix) Admission Webhook names must be unique
+6a6c3e9d2 Fix upstream.Dockerfile
+bc0cc96bb Update OLM to use UID for OG Labels
+ba44be8c4 Update CSV Validation
+fede0f0e6 Update Webhook Installation Failure to be generic
+a48013449 Update WebhookDescription struct
+66c5f2ed2 fix(auth): use fixed containerd authorizer
+d3c22d214 Move bundle validator back to registry under validation package
+5276ae623 fix: use runtime.Object instead of interface for CRD return type
+768e7d2b9 Remove Bundle validator from the validator list
+a8c2049af validation: bundle CRDs are compared by definition key instead of name
+46ae2d03f feat: add test for v1 CRDs in registry bundle
+02a152557 feat: Enable v1 CRD validation in bundle library
+8d507d50f feat: support loading v1 CRDs into index from a bundle
+0e58e0d40 Split build and push command runners
+e4f0814a4 (bug) Always overwrite local db when copying
+03c562cfa Update OLM to use UID for OG Labels
+2f95c9b37 Clarify log message to indicate that dependencies.yaml is optional.
+7dce17776 *: bump to k8s v1.18
+610df2273 refactor(crds): decode to v1 directly w/o conversions
+eb7e00cf5 fix(types): Fix GetDependencies func that returns duplicate items
+59bc8f83b fix: address sttts feedback
+5b96c24c1 fix: support creating v1beta CRDs to avoid data loss during conversion to v1. Due to data loss during client side conversions OLM will support two different paths for v1 and v1beta1 CRDs.
+7871e6486 feature: opm (index|registry) prune command
+69e95d8c3 (fix) Use opm builder image for opm indexes
+2b401d2c5 fix(resolver): Transferring API Ownership
+69945af22 Fix Operator Generation code
+622564c5e Bug 1820438: Slim down upstream builder
+7b2ffe887 test(e2e): correct tls detection in metrics spec
+6cb639fcd test(e2e): make operator resource creation eventual
+2fb9d9aab test(e2e): simplify csv requirement event spec
+97901a1f7 chore(modules): pin controller-runtime to master
+53c28b19d chore(manifests): include double-hyphen olm deployment options
+3960780e2 fix(client): supply missing params
+3af4abf06 test(operator): gracefully stop test controller manager
+2aeb3505a fix(operator): swap top-level update for status update
+4c8e489ad feat(operator): enable configmaps to be operator components
+eefb21697 test(lib): add unit test for metav1 time conversion hook
+98a6871d0 chore(make): use existing kubebuilder installation
+db1af5dd0 chore(logs): set manager setup log level to 4
+9440e420e test(operators): add e2e test for the v2alpha1 operator resource
+2fd8cedb2 feat(operators): add v2alpha1 operator controller
+faf929150 feat(opm): add unprivileged index extract
+caa685961 fix(indexcmd): use a separate directory for unpacking a previous index
+ffb2bf284 Address the metadata read files loop to work regardless files order
+18bd22456 Add an operator cache for use by the resolver.
+8f55d0ab5 Add unit test cases
+8e445b144 Add Validate() for each dependency type
+338cba6a7 Add dependencies validation
+fc2490b71 Add dependencies.yaml validation to opm
+994d99697 chore(api): switch to operator-framework/api
+36401b385 fix(secret): use a synthetic kind instead of an api field to determine bundle secrets from pull secrets
+9919c4dc4 chore(make): copy crd manifests from apis repo
+c0c6a63ea chore(deps): bump to kube 1.18
+d68232e1a Fix failing E2E bundle unpacking test.
+b7aea1e95 Add initial SAT solver package.
+11b26af18 (feat): Bundle commutativity
+452c04c2a feat: support secrets from bundle
+8d30b2913 fix(schemas): remove installplan generation field requirement
+00b5fac1e fix: add empty go file to packge to fix make verify
+3008b35ce Fix panic in AddToRegistry when using podman.
+f29b17b0a feat: support v1 CRDS in OLM. Simplify InstallPlan Execution via new Stepper interface. All CRDs will be converted and handled at the v1 APIVersion.
+2624d1f97 Regenerate the chart embedded in the test installer as needed.
+e891fac25 fix(index-add): docker index add failing
+3511cbb9b chore(gh-actions): install conntrack before minikube
+47f57a912 fix(docker): include util dir in upstream image build
+a56d8a0ff test(gh-actions): add upstream image build test
+195fd70cc Add ListBundles to the client interface.
+00938978e fix(query): ListBundles returns all bundles even without dependencies
+4b8be0343 fix(registry) Update the addDependencies to add requiredAPIs
+a75d99c1e OLM Support for Admission Webhooks
+79b39c1b0 Move APIService to installer
+e2d6e343a Added Github workflow for running e2e tests
+fa1f8a40f fix(add): allow containertool to be specified for registry add
+0211a173d chore(docker): add kubebuilder to base image
+6ed6cd70d fix(crds): add missing status subresource to schema
+022c73e09 bug(opm): use db dir when modifying existing index
+9644be3cf Address feedbacks (second round)
+3d24b440e Add BugZilla component to OWNERS file
+22092a80c feat: support configmap creation from the bundle
+1a2969719 fix: use busybox csv for polling e2e test
+e5d708779 Address feedbacks and fix test cases
+32c04f650 Update OG and CSV for Webhooks
+fb3addd35 fix(operators): add missing v1alpha2 types and update crds
+a610ef24d Codegen for registry API changes
+d6987d37f Add bundle dependencies specification documentation
+9026431f1 feat(registry): Add operator version dependency metadata
+f40eff62b fix(load): shouldn't clear bundle/csv field from non-default heads
+31c0743e6 fix(operators): sync v1alpha1 types with olm repo
+45e9423c9 feat(crds): add unmarshaled convenience getters
+7c64f8b89 test(e2e): login w/ docker first to prevent failures
+c52863016 feat: add support for configmap and secret objects when generating a bundle
+c7eefdc83 bug(opm): packages flag on registry rm required
+e25ff74c4 fix(imageloader): image loader should consider existing channels when adding to an index
+51b00418e (feat) Add semver insert mode
+bfb349d84 chore(deps): bump to kube 1.18
+20e115c73 chore(crds): add crds and manifests make rule to generate them
+885a59229 chore(travis): add conntrack package
+40b0dd25c fix(populator): set bundle name
+dbbacff0b fix(populator): put correct argument in decode call
+33b090c64 Create APIService after API server deployment
+5e7dcb8b1 test commit please ignore
+91fe5d2f5 refactor(populator): ensure file descriptors are closed
+8a8f2f068 refactor(image): add image reference interface
+902074d2d feat(deamonless): add buildah-based deamonless image puller
+6b71f6573 docs(opm): add self-contained container-tools section
+ccb818dcb feat(opm): add unprivileged registry add
+9a5c3c0f0 chore(codegen): update to drop license year
+cf1eae75d chore(codegen): use controller-gen for deepcopy
+283f5aa4c chore(codegen): update deepcopy types
+422133acb chore(make): add generate and vendor rules
+19aa8d24a refactor(csv): don't use pointers for rawmessage fields
+931b4dea5 feat(operators): add v2alpha1 operator types
+53e97f670 fix the `validate` command in the docs
+7d3f5ea0f test(migrations): add tests for api provider and requires migrations
+8fae3ba1a fix(load): add synthetic nodes in every channel that a replacement is in
+01ab07dd1 feat(bundle): extract replaces/skips data on load
+6043ce87d refactor(db): remove denormalization that associated provided and required apis with channel entries, rather than bundles.
+5c6d88f2f [feature] Understanding packages from directory
+af6ff5d9b chore(codegen): remove license year from boilerplate
+473863b3d Rewrite
+754662662 PackageManifest isn't actually a CRD
+e448e6b89 Remove specific client tool names
+1499093a4 Clarify roles and adds info about Package Server
+5ac2ad1f3 feat(catalogs): add spec validation for sourcetypes
+ea7dfddc2 fix(dns): fix slow dns resolution of localhost for grpc health probe
+4faaecbf1 pkg/lib/bundle: fix copyManifestDir so it actually copies file contents
+fab72d5ca [travis] pinning minikube version
+45b0c29c9 [dockerfile] removing dev directory permission change
+a1eef3a29 Revert "[feature] Understanding packages from directory"
+84152693a fix(sub): prevent nil pointer access
+55cb829b1 [feature] Understanding packages from directory
+c5d6a7b46 Update the code and test case
+6a79699b4 Update related images func and test case
+f4897ca6b make codegen for packagemanifest changes
+2d798e9e8 Add more CSV information to the PackageManifest
+a44caddce Reconcile Namespace OG Labels in Namespace Syncer
+746ccf47b Update graphFromEntries to be a private function
+31fa297a2 use query interface in sql graph loader
+90541c7b2 address pr feedback
+9ef3f960c Update graph format for runtime concerns
+a8ea1bfb2 Graph Loader initial implementation
+575d92a92 Add tests for GC assumptions.
+03b2db1d7 chore(apis): Regenerate API types for openapi3 specification
+e55a4431c chore(deps): bump to kube 1.17.3
+75ec17ee3 Change to using a hash instead of ordering
+c044cd401 Add alm-examples-metadata
+6f4c9f3d5 chore(deploy): update manifests
+e10945113 fix(bundles): include csv name in installplan for bundle images
+e303dcbef Add OG label to namespaces in OperatorGroup
+44a5741f8 Update chart to use the new "crds" directory.
+f75829b27 Convert e2e go tests to ginkgo
+72a396937 Add e2e test for multiple APIServices on a pod
+d0fecef3b fix(catsrc): remove limits on catalogsource pods
+9115b31e2 Fix typo in subscription.crd template file
+8a79a98b1 Ignore differences in CSV .status.conditions in unit tests.
+6e597918c Support multiple At PIServices on a single Deployment
+6e67f2c44 Add updated manifests from make release
+1b9ebf463 Optionally lock down package server runtime environment
+2a57de06b manifests(prometheus): failing operators should be a warning
+7181da8cb Add opm E2E test.
+e6dd01dab chore(deps): Bump to kube 1.17
+7b7940cc0 chore(deps): Bump to kube 1.17
+b05891a8c update examples for Subscription config features
+9145ef1e7 (test) update e2e test
+d022ede6f (feat) inject 'Tolerations' & 'Resources' from config
+9d031339d add link to olm-book definition of subscription
+76aa9fbcf Make provided API ClusterRoles be owned by the corresponding API.
+6531eea45 Generalize manifest copy
+ffd62133e update go.mod to remove unneeded license dependency
+80ec4d5e0 Update operator-registry OWNERS file
+9a92f73a5 Match bundle image directory structure
+60cbefcc1 feat(jitter): add jitter to controllers to smooth out our spiky resource usage.
+e24a30431 Add test target
+3d289ad65 Have a Makefile to install operator-verify
+f08f7ee8a GitHub action
+6df3786ab fix(installplan): crs are ownerreferenced to their resolving csv
+ece76cb27 test(installplan): add cr ownerref unit testcase
+60d9c9b7e Bug 1809294: Update subscription_sync_count to include the package name
+b8e519622 add stalebot
+1cff59d94 fix(make): build cpb as prereq of e2e-local
+65fe08e51 Use k8s version instead of replace in go.mod
+662f4591a Unbreak the minikube mode of build_local.sh.
+a4a430838 style(logs): mention generations instead of manifests for subs
+11a583d57 fix(subs): retry status update on conflict
+b06240fff Removing olm dependency
+8068c205b depend on registry v1.5.3
+7dfadbce1 test(installplan): ensure single installplan per resolution
+9b8dd25f5 Removing olm dependency
+0b39510ad fix(index): gen index dockerfiles from opm image
+fafb016e0 fix(resolution): add generation to installplan
+b5c72e2eb fix(deployment): remove separate operatorgroup annotation updater
+93eb7f183 fix(deployment): use deployment spec hash for determining if change  is needed on cluster
+82d43867b Fix TestUpdateCSVInPlace e2e test case
+ed94e0f23 Remove run-level 1 from olm and openshift-operators namespaces
+2b3d40150 fix: use label selectors in package server List response for all namespaces if label selectors are provided
+75162c2e6 Don't block on ctx.Done() if startup fails.
+0bb00ee1c Fix kind detection for local builds.
+689e64e93 Add stale bot
+0c173c69f test(meta-pruning): ensure pathless nodes keep data
+0fb8e2d7e Add stale bot
+fb0489b70 Produce binaries without target platform prefixes by default.
+537d03995 Update README to include OLM-Book
+e1c406909 chore(deps): remove helm as a dependency
+f04515c78 Update subscription-config.md
+d7a93457b Add some examples for Subscription config feature
+f6ef85d61 fix(docker): add entrypoint
+53bde4b33 Bug 1798051: Reinstate v1alpha2 operatorgroup
+bf5010ce9 fix(packagemanifests): Fix index key func to avoid key collision
+74c1cbe22 feat(util): add cpb command
+d3437399a fix(bundles): execute opm from tooling container
+aa753bfca Bump version to 0.14.2
+f76ea21db fix: update e2e test to use internal docker registry and openshift registry. removes quay credentials.
+9d780ed68 mention OLMs features in the introduction
+d5053fdb4 Fix cases where an operator's ready channel may never close.
+38955c133 fix(index): copy correct opm bin builder path
+df43ac7d5 Update operator-bundle to clarify the bundle format directories
+d2f6e6086 BUG 1238: Fix configmap registry server readiness probe timeouts
+2ae275102 fix: update existing robot credentials
+3ebc7c33a refactor rh-operator test directory
+52db6fd8b Delete junk SQLite journal files.
+bea99c650 feat(appr): exit build early if no manifests were downloaded
+f913c128b chore(ci): update owners
+48f8d6cb9 Generate manifests for version 0.14.1.
+5d3650ff6 Generate changelog for 0.14.0 and 0.14.1.
+24d607545 fix(gc): clean up copied csvs that have incorrect operatorgroups
+230ed91fc test(e2e): add test to reproduce bug where copied csvs with annotations
+6a857172d fix(operatorgroup): don't overwrite operatorgroup annotations on copied
+1eab138b7 test(ci): add failing test assertion showing that operatorgroup annotations on copied csvs will get overwritten to the wrong thing
+1cc4c0b98 Addresses the bug where updating the packageserver fails with a unable to adopt APIService status message. This is a result of ownership mismatches between the packageserver (owner) and the APIService (the owned object). This can be resolved by setting the actual k8s owner references or the label-based references that OLM uses. This commit ensures that ownership references for the APIService are cleaned up on OLM restart and that the olm.owner:packageserver label is set on the corresponding APIService object.
+6dd781751 Bump version to 0.14.1.
+3bc3a3a07 Update operator-registry dependency to v1.5.8.
+29263b0a4 Add bundle validation test cases
+61f7aca09 Add validate bundle test cases
+64f5acb45 Remove dependency on sqlite from pkg/configmap.
+078a6f8c9 Fixing wrong database loaded in memory for export cmd
+52bf1dcd3 Fix overly broad .gitignore pattern that was excluding a vendored package.
+b797473b0 Revert "fix(ci): build opm statically in CI"
+0cab8a53d Add support for Prometheus Custom Resources
+3a0309a28 Adding ability to export package from index
+7cdf29dae fix(ci): build opm statically in CI
+fd5b5456e Bump version to 0.14.0.
+6de6829fa Vendor helm, since it is used for templating manifests.
+4a113bfa9 adding e2e test framework for rh-operator metrics
+01c22044e Update README.md
+2399fc36d Update docs to reflect index/bundle image changes
+1bad1e5c9 Bug 1784028: Updating summary for 'Operator Registry ' containers
+d0ce30eb5 Add support for choosing the package's release
+9abf38906 chore(release): use robot for deploys
+33a3a875d Fix issue with empty docker error output
+9e393e615 chore(release): add a travis.yml to build and release opm
+bba572390 Address feedbacks from comments/reviews
+12dff198f Add unit test case for CRD validation
+bb4139601 Refactor validate CRD to fix conversion error
+17f67d0ab Refactor bundle validation code to seperate format and contend validation
+e58102dbc Add validate bundle contents
+dfef906ed Fix IPv6 incompatibility in TestGrpcAddressCatalogSource.
+084cc4650 Update release script to require version 3 of helm.
+f3f78e48f update internal objects proposal
+4f926286d chore(build): only enable cgo for ci/prod builds
+617a1da83 Remove pyjq and yq from the release documentation prereqs.
+da188bd21 fix: typo in catalog polling doc
+977079d7f feat(packagemanifest): add default os/arch labels if not present
+921414bd5 feat(packageserver): support label queries and copy CSV labels onto the packagemanifest
+f54690791 fix: refactor catalog polling spec to use more general update strategy field
+ec92318a7 Delete file that was renamed
+9df9d528b Swap annotation namespace
+b2ca9020d Use the correct title
+6d8cfdce1 Ammend proposal to include data CRDs and new annotation names.
+97879df57 doc: add internal image proposal
+44c2a9513 Reconcile manifests with templates.
+1fb8497e4 test(e2e): fix subscription update flake by retrying
+579ad84ce docs(design): add bundle image unpack design
+a29885434 refactor(resolve): simplify bundle lookups
+629c26fb1 fix(catalog): add ownerreferences for bundle image resources
+d30eec482 fix(e2e): remove local dev test registry image
+0ac5d7834 fix(e2e): remove local dev test image
+824b575a5 test(e2e): add test for bundle image
+261d22ef9 chore(fakes): make mockgen
+d2f6a1692 chore(codegen): make codegen
+8d0620093 feat(bundleimage): resolve bundle images
+7a4130a65 feat(catalog): make install possible from bundle image
+7b0c870a1 chore(vendor): get latest operator-registry
+cfccb8bce feat: add polling doc
+28bd26930 fix: update Poll to be pointer
+ef660b62d feat: implementation of catalog polling feature with e2e test
+26a08dcf5 Revert "feat(packageserver): support label queries and copy CSV labels onto the packagemanifest"
+af3dab3c4 feat(packageserver): support label queries and copy CSV labels onto the packagemanifest
+81919f512 Make downloader.go testable
+7510a1793 fix(build): grpc-health-probe was not building properly in 1.13
+91f4eeee4 Use vendored transitive dependencies for "go run" of vendored yq.
+f4927441c Enable CGO and CGO_DEBUG
+98a9e79d1 fix(bundle): set csv name field on configmap loading
+7d7d73046 chore(codegen): update generated code for 2020
+351f482b3 Vendor helm library to enable helm chart validation
+8ed495541 Fix a few minor issues
+b0a5cdf77 Update bundle validation lib for sdk consumption
+ca90fd1b4 add tests
+158d8771e Add bundle image validation feature to bundle library and bundle cli
+1b0352188 chore(ci): add dockerfile as a base for building in CI
+a87892fd7 Detect replacement cycles while adding package channels
+08e7975e4 Fix tiny typo
+3e8b6904d fix(configmap): remove packagemanifest parsing
+c8a374612 chore(makefile): add selective unit test execution
+9ee71a10d add cp to configmap-registry image
+a2d3a67d5 Add opm to configmap-registry image
+3cc8d20b0 fix: add err check before further operation
+434e736e4 feat: make run_console_local.sh sh compatible
+3c9c4e40e fix: make run_console_local.sh working on WSLv1
+5a2c09762 test(e2e): testing CRD upgrades shouldn't create a new subscription
+f9dc11c9f feat(resolver): rely on info from catalog to determine updates
+e674ac7df Add note for version field
+e17efd934 fix(deploy): remove resource limits
+3cc2aede2 chore(modules): update vendor
+923200984 refactor(opm): add examples to index add subcommand
+33e472eb6 chore(codgen): regenerate code, mocks, and openapi
+56c53d2bc refactor(pkgsvr): remove apps group
+b3c31e88e chore(codegen): clean up codegen make rules and scripts
+24208ed04 chore(ci): remove old gitlab ci config
+d7ff63fca docs(design): add general design goals
+14b60c426 feat(resolver): fallback to csv parsing if grcp api does not contain the information required
+d18bbe4b3 Update manifest CRDs
+b821e5a5e Implement controller-gen
+531f3162b Update CRD go types
+66bd02946 Corrected etcd CRD URL.
+18a528e3d Added `keywords` in operator metadata.
+6672ec680 add a mention of bundles to the README to help users find bundle information
+a89f54259 Dep is not required.
+a59d446ba chore(git): remove and ignore packageserver test key pair
+ccda3c5dc fix(packageserver): cache packagemanifests
+076003433 Fix CI unit tests
+b98f2d15d Change index func to return list of ns instead
+d9845a62a Fix updateInternalCatalog namespace bug
+95a0619fc Add e2e test case for syncSourceState
+ccd54c5db Enable multiple namespaces sync if catsrc is updated in global ns
+aad455fb0 bug(metrics): serve metrics using new certs when replaced
+062584436 feat(filemonitor): add new filemonitor package
+82e72d337 chore(modules): add fsnotify
+13057a042 Bug 1769030 Replacing (updating) operator creates duplicate secrets for the operator's ServiceAccount
+87618fc45 go.mod,go.sum: bump k8s deps to kubernetes-1.16.2
+84585c6fd Fix minor namespace bug with NewFakeOperator
+55974007a Update k8s version for local cluster (1.16.2)
+ed1935b21 chore(mocks): use new counterfeiter directives
+b019db1d4 fix(appr): use given cache dir for image builds
+c95aa6a25 fix: double limits
+66ab840f9 fix: double packge server limits for CI
+5b12e385e Bug 1774630: relocate test data
+5f481ce3c Bug 1774630: Fix panic caused by incorrect bundle data
+6ab2895f1 feat: add resource limits to all OLM pods for OLM releases on OCP above 0.13.0
+9cc5fac0f Bug 1771850: Error logging for opm alpha bundle extract command
+4f8dd8c4d vendor in github.com/pkg/errors
+903eab048 fix: defer RUnlock in AsClients
+940c3fb3b fix: use defer cancel to cancel context waiting for state changes
+0fa8201ed [docs] update changelog command
+3e469c477 fix: simplify test by removing additional map
+0d9b81a23 feat: add test to confirm node selector behavior
+c34e80a38 fix: add NodeSelector to catalogsource pod spec
+1957d0cb4 Clarify the directory requirement in docs and help menu
+17e1fac98 [release] updating changelog
+da3fc2e34 pkg/validation/interfaces: Validator's implement WithValidators to append non-default Validators to the Validator; ValidatorFunc implements Validator
+1324a97e0 [release] - making new release
+548d017b0 Ensure provided directory has at least one yaml manifest file
+475a9fda7 Add directory check to ensure the directory exists
+6ec0bba73 Fix bundle build command with Docker and update documentation
+e9ae4be82 fix(e2e): update ginkgo configmap test
+92acda8bf fix(olm): defer provided api update in operator groups
+f20ad06da [release] - version bump
+f0c2b06bd [docs] - update release docs
+9a4e3b3cb [bug] - add version and skiprange to operatorbundle table
+31d85cfd9 pkg/validation/interfaces: Validator's implement Validate() to return errors.ManifestResult.
+645f73f7c Make imagereader work for all layer paths
+a26089a5a Fixing doc typo
+f7bdf8284 fix: t.Fatal should be used in main goroutine
+a8ff97b42 Fix flaky subscription e2e test case
+80f25361e Fix several flaky e2e test cases
+b27d28666 fix(configmap): bump base image for configmap registry image
+3775f1d9a Add `opm index` commands
+9fc13ce3e fix(mirror): canonicalize names before swapping domain
+e5a4c8dbe feat(api): return version and skiprange in bundle
+bc3c953c5 Alerts for failing OLM operators
+43b7d8462 [opm] - Add registry add and rm bundle commands
+b270b73ea fix(builder): Add AppRegistry org to `ToOption`
+f89f7e09e feat(metrics) Report subscription channel
+088c142d5 fix(configmap): make launch bundle work
+a28729347 feat(resolver): use provided and required apis from grpc instead of calculating from the csv
+48128f96d feat(metrics) Limit Cardinality of CSV metrics
+8586d5946 feat(client): return api bundles in client
+95f956aee feat(sql): extract required apis when loading
+9dd281b4f feat(imagebuild): add opm binary to registry image build
+ff9ac78b8 docs: Corrected CSV upgrade version.
+c04b9eda0 Add unit test for minKubeVersionStatus
+0065ffd46 fix(bundle): Fix the build paramater order mix-up
+5a9e2085e test(mirror): add tests for mirroring
+924bdfeba feat(opm): add registry mirror command to mirror the contents of a catalog
+f09d1f48a feat(opm): add registry build command to build a catalog from an appregistry namespace
+396d51306 chore(configmap): load packagemanifest data from annotations
+9c9fcb834 test(unit): add test case from generated configmap
+f49d8d513 (feat) Load operator registry bundle from ConfigMap
+80ec02aa6 Update registry gitignore to be consistent with OLM
+9c2b5bea1 fix(bundle): Fix manifest directory issue in generated Dockerfile
+317dd2aab fix(olm): No longer report status if minKubeVersion not specified
+e7e204be9 test(e2e): add bundle data image extraction test
+127b4c8f2 test(e2e): add initial test bootstrap
+3a29503b7 feat(cli): add bundle extractor binary
+59a75cd86 feat(configmap): add configmap writer
+c0f8325ad chore(client): move k8s clientset generation
+461d6985f Change const to upper case so it can be used
+aa26d805e Updated values.yaml location.
+602fabf72 fix: refresh architecture and philosophy
+ce488d190 Clean up minor issues with command-line code and documentation
+c625b267c Fix bundle library doc to reflect new changes/features
+f7dee84cf Fix bundle library unit tests to cover new code
+df3d617ac Fix bundle library to add package and channels info to annotations
+c5c42cfad Clean up library code, unit tests and documentation details
+e87847714 Add CLI tool to build Operator Bundle image
+062cfa9c2 Image digests for referencing bundles
+38e90e00f Update resolver.go
+a3259165f Fix log message in resolver
+df6ef4d11 fix: fix particular typo in clusterserviceversion_types.go
+cf24622fd feat(migrate): migrate from current version up to the latest
+46088dfb0 feat(images): add support for storing and querying related images
+b3f5273ac feat(migrations): switch to go-based migrator
+58b7f3d33 URL with modified manifest directory structure
+b2afe6a00 Update OWNERS
+7678f6edc bug(dependencies) Prioritize APIs from same CatSrc
+906690334 Adding opm cli
+d7081859f Update PackageManfiest table handler
+4688a9dcc bugfix: assignment to nil map will cause panic
+d0e22e9b2 (proposal): add bundle image deployment text
+6779f0b26 (proposal) Make bundle accessible to a cluster
+313d15f7b update OWNERS
+6aa2b7499 Bundle migrations in binary
+82f97db28 Database migration initialization
+fc99a2ba3 fix(sqlite): enable foreign keys for sqlite
+7344cbf0e proposal(relatedimages): combine the two previous proposals
+bf587f26d proposal(relatedImages): update related images proposal to use kustomize
+775fbf92a proposal(relatedImages): add a proposal for specifying related images in CSVs
+f31c876b5 Fix InstallPlan stale variable issue
+e70eb17fc Add e2e test case
+542d8d2d9 Bug 1758008: Manual approval strategy ignored for subsequent releases
+22477b866 Add document for SubscriptionConfig
+bd975dcb9 feat(subscription) Config Volume and VolumeMounts
+5f25627b7 Rename envVar package to overrides
+23ac744d2 Add `apk upgrade` to upstream builder
+c26ac3099 Fix links to console repo for moved packages
+e54770d4f bug(install) Fix packageserver name in install.sh
+183c6a860 feat(metrics) record CSV sync events
+f0f7f9d23 Bug: Fix olm chart
+fde8c0553 chore(modules): bump openshift/client-go pseudoversion
+6d8449d89 (release) Update changelog
+46406f126 pkg/registry/bundle.go: use v1beta1.CustomResourceDefinition, as the apiextensions type is internal
+b96fcdd54 Add migration proposal
+f8d3c4824 chore(deps): bump to kube 1.16
+9aa8674c3 feat(scripts): add shell lib with some common helper funcs
+0a48b1c72 fix(subscriptionconfig): add missing merge struct tags
+bcf781ec6 refactor(operatorstatus): make monitor constructor variadic
+122de9ae0 (release) Generate manifests for 0.12.0
+865609081 chore(deps): refactor load_test so that OLM is no longer imported at all
+9394c1452 chore(schema): remove schema
+7d0279468 feat(csv): support extracting version from bundle's csv
+227c5f994 (release) cut a release for 0.12.0
+08eab6477 (docs) Update release.md documentation
+afe956695 chore(deps): bump to kube 1.16
+a31af892c Create PULL_REQUEST_TEMPLATE.md
+7ecae3cc9 Update PULL_REQUEST_TEMPLATE.md
+a887ff0fa Update PULL_REQUEST_TEMPLATE.md
+db19d9fee Update PULL_REQUEST_TEMPLATE.md
+823ca8fbc (doc) How to update operators documentation
+e45258d22 test(e2e): add operator group SA permission tests
+25cbc86a4 fix(olm): requeue as needed upon permission changes
+e954cf8f9 fix(olm): handle CSV install failure gracefully
+9ec40d12b Enable vendoring on Go 1.1x
+7a8c5589f feat(olm): don't calculate a patch when updating via a replacement chain
+973e9c395 Add unit and e2e test cases for deprecating a CRD version
+cec93f8b4 Remove deprecated CRD's stored versions to allow CRD update
+55f068e4a (doc) Add deprecated CRD version procedure and note
+a256f5f88 chore(docs): consolidate doc directories
+b7819af96 Fix broken doc links
+998809eec fix(registry): return all valid packages
+3dc775536 chore(mocks): generate mock list packages client
+42969ebc0 fix name of dir - replace Documentation for doc
+bc02e9d6e feat(github) : Add github files in order to follow org standard
+16494cd03 feat(readme) : Ajustments
+cf8c2bfdc Drop the hard-coded DNS suffix
+bede912c8 add default for packagemanifests/icon subresource
+ea78704b6 fix(clusteroperator): update status after initial creation
+e9501878e fix(clusteroperator): fix naming of related objects
+1fca6a1f3 feat(clusteroperator): plumb additional clients
+8ff1a2abd Bugzilla 1744245: Subscription should not point to deleted ip
+4ce17d2f0 fix(init): cleanup leftover cross-namespace  ownerreferences
+09e846ad0 Stop relying on pgrep -q
+31898fd5b [CatalogSource] Set Global Catalog NS with EnvVar
+8b9d8b18c Remove InstallPlan Source, SourceNamespace from UX
+d354b682f fix(olm): report name and group for related objects
+f16ca4ad2 [lib] add two methods to validator interface
+072bc751f [lib] add bundle validator
+5496e4e09 [lib] add package validator
+a31c68463 [lib] add crd validator
+6b0b69706 [lib] parse operator manifest directory
+b9207a2fe [lib] csv validator for example annotations
+a1dafde35 [lib] add support for handling manifest
+254ff6d88 [cli] change from verify to manifest command
+13e77238f [lib] refactor logic for csv validation
+28ef243a6 [lib] refactoring the library
+f6b32131c go.mod,go.sum: add modfiles
+db8ca031a fix comment
+c23e76ac6 refactor Validator and error/result types into pkg/validate/validator
+10cd8b511 pkg/validate: add Validator interface to add k8s objects and run validation logic, refactoring around interface
+36f17aa27 [lib] Handling mandatory/optional fields and reporting custom errors
+bc4a45f97 [cli] Handling error reporting through cli
+ff518e877 [cli] Adding verify command
+de5eab427 [lib] Adding serialization for CSV type
+c63198ac9 fix(sqlite): defer rollbacks to prevent db lock
+dafa3719c chore(deps): update grpc to latest
+6952403d0 feat(operatorstatus): report packageserver as upgradeable
+9e7039fc5 Bugzilla 1737057: Sub CRD does not validate config
+e9e115eee feat(sources): syncronize access to lastupdatetime for sources
+e209a4e08 chore(deps): update grpc dependency
+d7d1ff1b8 Bug 1740332: OLM should resume operator install
+5fb22c2c3 add packagemanifests/icon to aggregated OLM RBAC roles
+2172020fd filter icon fields from PackageManifest object (use packagemanifests/icon subresource instead)
+65c4666d8 test(e2e): add test verifying permissions are updated during an operator upgrade
+6877b58e0 Bug 1702552: Two "NAME" fields by command "oc get catalogsource"
+6525b53f4 Bug 1732914: Operator upgrades fail when versions field is not set
+734cd61f4 fix(spelling): just a comment correction
+1c631bf63 fix(olm): clean up resources on CSV deletion
+43904bac0 test(e2e): ensure resources are deleted after CSV delete
+a4020e3a3 (proposal) improved csv status reporting
+88885ba20 [doc] Add fake README to the project proposal
+d9ad0f893 Operator validation library project proposal
+e89735b13 Bug 1744245: recreate of sub should not fail install
+d82e763f2 packagemanifests/icon subresource
+9147efeb1 add proposal for 'packagemanifests/logo' subresource
+1d70f3048 Bug 1737081: catsrc status should show error
+33d39768c test(grpc): add basic connection event tests for source manager
+fc5b01acc feat(grpc): adds grpc source manager which notifies main controller when grpc events occur.
+fa442cb0c fix(deploy): change local deploy to use olm namespace
+0b44cdec2 fix(registry) Fix incorrect error return and handle
+f5e8bf6d2 refactor(cmd): change command scope to make testing easier
+10f4bfb8e feat(configmap-server): tolerate load errors
+4bf956652 feat(registry-server): tolerate load errors
+38c956b56 feat(appregistry-server): add strict load option
+7da728f31 feat(configmap-server): add permissive load option
+af591e9df feat(initializer): add permissive load option
+e08f0e390 feat(log): make termination-log setup failure non-fatal
+2eb8e4f30 test(load): add test of unpacked appregistry format
+ae4493d4f fix(sqlite): correct directory load error collection
+ad310d64e feat(appregistry-server): use empty querier on fatal load error
+82722d27c feat(sqlite): make configmap loading best-effort
+242baf625 feat(sqlite): make directory loading best-effort
+ef61b9e60 feat(sqlite): make package loading best-effort
+efd0c3fd6 feat(appregistry): avoid panics in flattened processor
+05d4d864b chore(git): keep testdata/download
+f7f47a0f0 Initial commit
+c22cea8eb bug(1717636): Add relatedObjects to cluster operator status
+ab835aa69 chore(deps): add glide.yaml for importing to oc
+58f3ccb93 feat(appregistry): have appregistry transform configmap bundles into directories
+6bb21c271 chore(deps): remove dependency on marketplace
+eccfa7060 chore(deps): remove dependency on openapi and go-appr
+105d723dd (doc) add doc for scoped operator install
+9ea876e78 (doc) update make new release doc
+106f9e507 Report `Upgradeable` in ClusterOperator status
+e2b2b7470 fix(unit): allow logrus log level to be adjusted
+8c5cfd708 fix(catalog): re-install resources in existing installplan
+e6fea4bb0 (release) update changelog
+59305c77e (release) generate manifests for 0.11.0
+5471a5b80 bz-1662263: include git sha in ART builds
+55cf20a68 (e2e) fix e2e test flakes
+57d5167bf (feat) requeue the csv when subscription changes
+50d8af9b8 Rename and remove commented code
+900846502 (feat) empty proxy env var should result in unset
+8f044c03e (release) cut a release for 0.11.0
+b74b184e1 Fix panic when binding already exists
+89076d623 fix(dockerfile): missing image alias
+9012b067c fix(unit): refactor to use shared pod resource
+82b89d2cc feat(deploy): add resource requests to all pods
+cba79661f fix(manifest): fix env var projection in command
+df9418c85 (test) add e2e test
+2045208a9 (feat) inject 'Env' from config to deployment spec
+38decf71d (feat) incorporate proxy configuration support
+e9b8e3c75 add operator configuration to subscription spec
+391012587 Add e2e test case for existing CR validation
+39d9fa5ca Validate existing Custom Resources against new schema prior updating
+70701ea86 add dockerfile that just contains the registry server
+979c4fa39 refactor(load, query): don't rely on json extensions to sqlite, and don't rely on types imported from OLM
+4db7fc736 feat(load): allow multiple csvs in the same directory
+bcbd5e9f1 chore(modules): re-vendor
+6ac6e1ef2 chore(generated): run code/mockgen
+86276ae2c chore(modules): pin k8s 1.14
+de66a717b feat(metrics): record sync count for subscriptions, labeled with name and most recently installed CSV version
+aa599f91d feat(metrics): record sync count for CSVs, labeled with name and phase
+232ab6a9d fix(init): move cleanup to olm startup
+98cc0a6ba feat(init): add init container to olm operator that can clean previous deployments
+4711b0aca chore(deploy): remove packageserver subscription and catalog from chart
+d3c232d3d fix(build): don't build static in downstream images
+128449632 chore(image): change base image to go 1.12
+0164effea feat(olm): allow CRD updates with multiple owners
+fa7fcf9d1 chore(logging): logging fixes / small enhancements
+a655bbaf2 test(catalog): add sync resolving namespace benchmark
+2060152e1 fix(olm): List does not return NotFound error
+7e7a20d7d fix(e2e): fix baremetal e2e
+9aa00c871 chore(dockerfile): switch to go 1.11
+19a892236 proposal(operator-config): initial proposal for persisting configuration of operators
+be55365d0 feat(csv): detect changes to a deployment and persist them
+6cb475990 fix(query): return all channels when querying
+423ecf606 docs(profiling): add basic usage doc
+2be069c49 feat(cmd): add profiling option to olm and catalog commands
+40a34b5c8 feat(profiling): add pprof handler registration function for mux servers
+62ba254c4 test(e2e): remove extra resource comparison
+7a8a21df2 Add webhook proposal
+6df186031 1723818: package server 4.1 to 4.2 upgrade should not fail
+4d07ecab8 feat(makefile): add target for compiling e2e
+24e3bdda3 (bug) CSV name change causes upgrade to fail
+89f4d288f (e2e) add e2e test for user defined service account
+cfff29c30 (feat) validate that secret is valid api token
+6d56a74d0 (feat) use scoped client for plan execution
+5a378a491 (feat) create scoped client from bearer token
+5943b2223 (codegen) generate operator group type changes
+1d1406292 manifests: move ServiceMonitor manifest to runlevel 90 so it will be applied after ServiceMonitor CRD is created
+6ba46b3e1 [bug] Remove duplicate packages from list
+c7831f5e7 chore(modules): add hashstructure and revendor
+55c4a61e4 test(sub): add subscription installplan condition e2e test
+4b976ae87 feat(sub): add installplan reconciler to syncer
+dd58ec73d feat(sub): add installplan status reconciler
+c6e0f24c1 feat(state): add subscription installplan states
+3b56f8ade feat(sub): add subscription installplan status conditions
+666942c4e feat(equalitor): add equalitor interface and hash implementation
+fe942aa77 (feat) monitor package API server CSV progress
+65566179d Receive notification of CSV(s) being watched
+0549c5f52 (deploy) add cluster operator for package server
+9153703c5 fix(test): fixup bare test imports and vars
+5a48ba8bd Add a new test case to cover preexisting CRD case
+befedc7cc Add e2e test case for single owner CRD update
+7a2263d9f Add IndexFunc using ProvidedAPIs as key to look up CSVs
+b17a0f946 Enable OLM to update CRD when there is only one owner of that CRD
+1a01baa0a Update CHANGELOG to include changelogs from 0.10.0 and 0.10.1
+98a9a20e6 docs(release): add additional clarifying details
+f39e000df fix(build): set GO111MODULE=on
+7ec84feb2 Switch to go 1.12 in the root Dockerfile
+73d86fde9 make release 0.10.1
+56a83e9fb fix(unit): fix unit test flake
+16d1d8318 fix(build): don't use helm in src image
+2434f1b77 fix(catalog): do not add owner references to clusterroles or crbs
+ac617f597 fix(chart): add missing descriptions to operator group
+112248d93 feat(queueinformer): add config options
+300403724 test(subscription): add e2e tests for catalog health
+547910899 test(bare): use new operator constructors
+951bbaa8b chore(codegen): generate conversions/deepcopy
+5a7ae300d feat(subscriptions): add catalog health conditions
+14d1f34bd refactor(packageserver): plumb context throughout
+30d315892 refactor(main): use signal context and new operator contructors
+c0231ed15 refactor(olm-operator): replace factory method parameters with options
+e162d49b3 refactor(catalog-operator): use new queueinformers
+2c1adf0a0 feat(subscriptions): add subscription catalog health syncer
+a9272bf5a feat(registryreconciler): add now function
+3bc29f8b2 refactor(operatorstatus): make sync channel receive-only
+884ecd94d refactor(queueinformer): use kubestate resource events
+97abc9440 feat(kubestate): add generic typestates and interfaces
+16b5ad074 refactor(signals): replace stop channel with signal context
+314e02ce7 feat(e2e): allow KUBECONFIG to be set from env
+5e019f32d add -l option to $POD_MANAGER attach
+e8bde0245 clone labels from CatalogSource to PackageManifest to prevent concurrent map writes
+25caff25e (proposal) Add user defined service account
+948ae2d98 change packageserver global namespace to openshift-marketplace
+951fb43fd add --rm, remove cleanup func, and attach to block
+b8114b3ac repair run_console_run.sh script
+8c76fa321 Bump release version to 0.10.1
+fae07921d change global catalog namespace to openshift-marketplace
+3445c4b50 chore(deps): bump kube deps to 1.14
+b5dadcdd6 feat(install): Add new install scripts for releases, update release instructions.
+77461fcea Documentation: Fix a few typos
+fe51b8578 chore(types): codegen internal convs, clients, listers, and informers
+d53e34e64 refactor(codegen): add conversion to make rule
+bc2fecc42 refactor(types): add internal types for olm resources
+36fe1227f Remove pragma lines that reference the files that can’t be found
+dd4c1d6f2 fix(registry): Validate alm-examples in operator registry
+18e9d9228 Documentation: Small typo fixes to README.md
+32c1e6607 fix(operatorgroup): Remove namespaces requirement for opgroup status
+ca98f467c docs(release): add basic steps for making release
+e46653c90 fix(catalog): close grpc connections before deleting them
+d26e3af03 update manifests to 0.10.0
+d313ede32 bump version to 0.10.0
+d192632e5 add provided APIs to PackageManifest
+8f867e81a (refactor) Move csv set and replace to a package
+f79fcb60d feat(client): add health check to high-level client interface
+9d6999b55 test(e2e): add test for orphaned api services
+530a8a6ed end-to-end test for cleaning up apiservices after CSV delete
+7ec8864bd fix(olm): add deletion monitoring for api services
+6a31c507c fix(unit): fix flake in TestUpdate
+6b540dcca fix(unit): operator group test flakes
+19e9ed6c9 fix(olm): unit test flakes
+fbd218514 feat(unit): allow specific unit test execution
+2e6f3c5b3 test(olm): test role aggregation for aggregate apiservices
+f96abcf34 added e2e test for garbage collecting ClusterRoles
+8a7af925c fix(unit): Remove leftover println causing excessive log in unit test
+cc6ff6f65 fix(operatorgroup): No targetNamespaces matched namespace selector
+c63e7678f chore(deploy): install helm in `src` image so that verify manifests job can run
+73715797c chore(deploy): re-sync manifests with the chart
+b06422292 chore(deploy): add `verify-manifests` command to ensure chart and manifests are synced
+6ca9f429f chore(deploy): fix release scripts
+0b59c5adf fix(catalog): Fix subscriptions without a sourceNamespace hang forever
+668e596dd fix(run_console_loca): Fix command and improve output message
+2cc6173c4 Add validation details for `spec.maturity` field
+da1622e49 fix(unit): TestUpdate no longer flakes
+bf7364e1f One more doco typo fix
+703262267 documentation:  Fix a few typos.
+330e9cab2 Fix small typo.
+4d3470876 Add support for Windows WSL in run_console_local.sh
+0932515cd Fixing indentation for spec field
+84bb8a405 fix(deploy): add missing descriptions to manifests
+6f43ee44d Fix tolerations
+667805d5e fix olm-operators tolerations
+51f14be2f fix(catalog): fix issue where subscriptions sometimes get "stuck"
+352f82693 add terminationMessagePolicy: FallbackToLogsOnError to OLM deployments
+e16b2bccb fix(deploy): add missing descriptions
+7e7410caa Fix tolerations
+1efa117fd fix(e2e): fix installplan test cleanup
+31e906c90 fix(operatorgroups): fixes rbac checking for multinamespace groups
+f41a55265 feat(olm): speed up csv updates
+39adb606e test(catalog): add tests for catalog reconciliation
+033c4119a feat(catalog): check catalog health and recreate if bad
+c74e3ad5e fix(roles): use correct group for package permissions
+65007eb54 fix(e2e): test changes
+dc2de2d6a feat(resolver): treat the registry as the source of truth for replaces fields
+f506fba6d fix(olm): race when a subscription updates many versions
+30354384b fix(resolver): resolved dependent subscriptions don't detect updates
+fb6cca459 Set limit on length of Status.Conditions of a csv
+6067ef7c9 feat(load): validate that packages have a default channel when loading
+6c4d21f76 feat(resolver): allow skipping a set of updates if the channel head explicitly states that a range of existing operators can update directly
+2c8d2be4f chore(deps): switch to blang/semver from coreos/semver
+69204952d fix labels.provider issue
+da68073dd fix(catalogs): make grpc registry check for < 1 pods
+e5a7d5c5f test(reconciler): refactor reconciler tests with k8s decorator
+94c99d71e test(clientfakes): add k8s client decorator and shared options
+68611698a Add e2e test case to verify the events flow
+f02824374 fix(olm): Fix the issue with missing events due to rate limit
+a6e5ba291 fix(permissions): the aggregated edit role should grant view access to operatorgroups
+e548c63b8 fix(olm): don't requeue operatorgroups for deleted copied csvs
+499802def test(e2e): wait for deployment to exist in csv replacement test
+c9c674c06 Always set LastTransitionTime in OperatorStatusCondition
+1c04f1302 Revert "chore(cvo): remove ClusterOperator from manifests"
+5ed875b87 Add node-selector annotation to namespace
+bf6e905d1 chore(cvo): remove ClusterOperator from manifests
+8e8499219 chore(deploy): update manifests
+f646c0d1a add priorityClassName attribute
+a9393b30d chore(cvo): update openshift/api so that OperatorFailing is changed to OperatorDegraded
+f71593ea5 refactor(queueinformer): prevent > 1 run calls for duplicate informers
+6c94c8d90 refactor(subs): add objectreference installplan refs
+1b7b64903 feat(types): add reference for olm types
+0b7509aa6 feat(loader): don't require file suffixes
+aba81c5ca feat(rbac): restrict permissions for namespace admins
+ba14de1f9 chore(cvo): report progressing=true if the version has updated
+fa5da9eb7 Modify and improve unit test on deployment
+fff1c6912 Rework cleanupOrphanedDeployments
+d3bdadbcf fix(deployment): Clean up orphaned deployments
+379187617 feat(packageserver): add additional info to package server output
+8b084675e fix(e2e): metrics are now served 8081
+f67a44ef7 fix(metrics): remove optional from secret parameters
+8b7cf67da fix(metrics): add logging and separate muxer in catalog
+f6738b2f9 fix(metrics): add logging and separate muxer in OLM
+037fd1170 fix(catsrc): force registry update on dep resource deletion
+e9078df6d feat(registry): add registrychecker
+01763d417 feat(lister): add catalogsources to operatorlister
+a69e8aea6 chore(mocks): regenerate mocks/fakes
+0f6920873 chore(mockgen): use modules for mockgen
+75b365b44 test(catalog): add registry pod delete e2e test
+d7e8e144f Add unit test(s)
+a00d721ab Support nested operator bundle format
+d9a964ffd fix(e2e): remove ip count check
+31805c44b fix(olm): generate rbac roles for ownnamespace operators correctly
+0d59b4760 test(aggregation): Add test for operatorgroup role aggregation
+7a0a48446 test(e2e): add sanity check for project admin permissions
+f5e868766 test(subscription): add additional testing around installplan generation during manual approval subscriptions
+6478efadc docs(changelog): regenerate changelog for 0.9.0
+a8195a728 docs(release): add release doc with changelog generation section
+68bd541cc cut release 0.9.0
+96a5e2e86 fix(git): remove nuget ignore rules
+2e4c2eb57 chore(modules): revendor
+ca07037f6 fix(modules): update replaces fields
+091a80097 bump version to 0.9.0
+2a69d8d0a docs(subscriptions): add improved sub status proposal
+098024d87 chore(deploy): set priorityclass on olm pods
+ec943c50a chore(package-server): adjust to new API
+3dbf29e63 chore(vendor): add jsonpatch
+87b9d09b3 chore(codegen): regenerated due to vendor updates
+629d46aee chore(vendor): update vendor directory
+44f118f0d chore(vendor): prep for update to 1.12.7
+ce738c402 fix(annotation): don't annotate deployments that aren't owned by a CSV
+9e244e665 fix(packageserver): add struct tags to PackageManifestList
+b0c3752e4 chore(codegen): run codegen and mockgen
+0d74e0458 feat(packageserver): support apps.redhat.com and operators.coreos.com
+1b570285a chore(deploy): regen /manifests
+6eb30ae64 refactor(charts): normalize packageserver templates
+de5fcdb95 Support v1 OperatorGroup and v1alpha2 OperatorGroup
+ac22aed7d chore(api): bump operatorgroup and packagemanifest to v1 and group operators.coreos.com
+3af623ac3 feat(load): use a new "skips" field to specify additional operators that
+abd818bcb chore(deploy): don't include openshift stuff in upstream
+bdf965108 fix(deploy): move service creation to new file
+f9270ad15 fix(metrics): add service monitor config
+3254744db feat(templates): make use of TLS options in deployments
+b9de856aa feat(olm,catalog): add TLS support for metrics
+6d333867e chore(deploy): renumber files from 02* onwards
+bca81d76f fix(olm): use hashes for provided api labels
+63c3d3a44 chore(deps): bump openshift/api to get new ClusterOperator types
+ae72383de chore(catalog): add ClusterOperator status for catalog operator
+c2b442a50 chore(build): build binaries locally and load them into containers
+d67704a56 Remove OperatorSource dependency
+4432c798f chore(manifests): recut 0.8.1
+6cfd1eb45 docs(git): add changelog
+f86f9bd31 fix(build): add some minor support for building locally with kind
+12342747c feat(operatorgroup): operators in operatorgroups that select all namespaces are now granted namespace view roles (get/list/watch)
+3e2c9012c test(e2e): add failing e2e test for operators in global operatorgroups
+00e6a85cd feat(csv): label CSVs with provided/required apis
+86139cc75 update upstream configmap-registry image to use the builder image
+7827f6775 fix(chart): persist operatorstatus reporting changes to chart
+2b6f52876 feat(upstream): add operatorhubio catalog to upstream release
+898752aa2 add instructions how to use grpc catalog
+c6a2e9a05 fix reference to Dockerfile
+6c3f537da Fix typo - k8s version format
+002e902bd fix(installer): include generated manifests
+b4c925fa5 fix(ocp): add csv and deployment for package server
+6dc8f6051 feat(e2e): generate a larger set of namespaces during testing
+1ad71dac5 fix(e2e): use ifnotpresent for all test images
+d1a92cf4b fix(olm): don't attempt to annotate deployments if the deployment hasn't yet been created
+99b065778 fix(catalog): kind was omitted from ownerlabels
+0061f4ffb fix(operatorgroups): gc copied csvs from a separate queue
+eed7b3ef4 fix(e2e): e2e test for pre-existing crd owner tested incorrect behavior
+28c092f45 fixes typos in README.md
+64ac4303a feat(builder): add builder dockerfile (contains tools for building a registry image)
+177e3166b fix(resolver): take a snapshot of the current generation before updates
+f3d7fc544 fix(catalog): fill the csv cache with informers
+cb82894d5 test(subscription): add an e2e test for validating that subscriptions step through multiple intermediate versions
+3694a941a refactor(images): use operator-framework namespace for all olm images
+00c7367c9 feat(make): add quickstart generation to release rule
+943c42c48 chore(docker): update upstream.Dockerfile base to go 1.12
+64750a89b refactor(scripts): use existing manifests in package_quickstart.sh
+c6b87a205 style(scripts): rename package-release.sh to package_release.sh
+7eeb33542 chore(modules): revendor
+b0be6e4c9 clusteroperator: Report when OLM reaches "level" and check syncs
+6d4af4ce1 fix(csv): properly detect owner conflicts for crds and apiservices
+4abff4adb fix(transitionCSV): reorder apiservice resource check
+78dd09e4a more event emitting for CSV phase transitions
+5526dde6c more event emitting for CSV phase transitions
+3700a5ecd fix(contraction): requeue any csv that may need it after operatorgroup expansion/contraction
+e707be584 feat(olm): update deployment annotations as soon as the csv annotations are available
+c986d6ab6 fix(e2e): fixing e2e test after rebase
+0f53418e8 chore(rebase): fix errors from rebasing
+58a8184ae fix(opgroup): incorrectly detecting CSVs as "copyable"
+f9d906484 fix(operatorgroup): set labels on copied resources correctly
+3c89f1439 fix(olm): move csv copying into its own workqueue to free up csv processing
+ae0737164 fix(e2e): fix e2e tests for operatorgroups
+bb16a4643 refactor(olm): refactor provided api pruning
+5434dec4c refactor(olm): simplify CSV copying/pruning
+c08c52e28 feat(namespaceSet): add Contains method to namespace set
+2259009e0 feat(olm): don't copy csv to operatorgroups if it's not in certain copyable states
+b136cf416 fix(olm): delete copied child csvs with no parent annotations
+85fe51df3 fix(operatorgroup): annotate all csvs and allow collisions
+a0f16e77a fix(olm): delete stale resources after op group change
+2024a6214 fix(opgroup): revert order of operatorgroup updates
+dad85617c fix(requeue): requeue owners that are referenced with labels
+973fb2418 fix(olm): change operator group / CSV requeuing
+680f06e07 chore(opgroup): allow selector to be nullable so that marshaller can output an allnamespace operatorgroup
+7060f104a remove minishift support
+99c2fc603 docs: update CSV link
+7622b74f4 feat(test): adds CSV phase reporting for package server
+7553d1019 fix(test): fix labelselector pointer
+b7d71876e fix(olm): delete api services upon CSV deletion
+2046ca519 chore(olm): add debugging logging and handle potential list failure
+4725ccdd6 fix(util): fill in GVK info from InferGroupVersionKind
+c5877b578 fix(olm): Fix CSVs api-servers battle for ownership of APIServices
+e7e7a2632 Make release
+6e27f0f3d Add minKubeVersion validation to templates
+57c9ef437 chore(manifests): regenerate manifests to include new validation
+4ba65f585 fix(operatorgroups): use pointer for labelselector
+31d873167 refactor(operatorgroups): bail out after successful namespace update
+307e13d6e fix(csv): fix unsupported operatorgroup status update
+916de307d test(operatorgroups): add installmode support e2e test
+c8aeee46a fix(installmodes): update support logic to match expected behavior
+bd5d352d5 fix(packageserver): set packageserver to IfNotPresent
+045977b06 fix(load): return an error if a CSV specifies a replacement that doesn't exist
+18cc7e4ef fix API validation for OperatorGroup spec
+b607311e3 chore(deploy): run release scripts to get view permissions on edit/admin
+cda5a387c remove rbac changes to 0.7.1 deploy maniftest
+6f062ab11 update aggregate clusterrole to chart template
+043151a92 add view rbac to 'admin' and 'edit' default roles
+b77478e4a docs(operatorgroups): add more extensive docs
+dd7fb76bf fix(packagesever): add missing name field to api definition
+0ea74cf6a fix(owners): remove cross-namespace and cluster->namespace ownerrefs
+9cef4dd35 add all-in-one yaml and helper script
+9a3740171 fix(csv): remove regex on base64 image data
+d7222352c fix(csv): icons in csv schema should be an array
+9dc027fd2 feat(csv): allow use verb in permissions
+cc9908053 Update README.md
+9a3902a45 Rename upstream.Dockerfile to upstream-example.Dockerfile
+053f32da5 Update docker commands in example to use upstream
+e417e1d2b Add authentication to apprclient
+9eb34b5fb fix(olm): properly detect cluster operator API
+f17f0dd5b feat(catalogsource): allow grpc source types that don't require an image
+ccd77162a fix(registry-pods): add everything toleration to registry pods
+1c4ddd2a7 Incorporate new binary into docker images
+d20b4936e Add appregistry-server binary
+c29a6e3cc Add apprclient package that talks to app registry
+b570441c7 graceful shutdown for PackageManifest server
+9203775f9 fix(manifests): start manifest file names with 0000_50_olm_*
+d91217121 Refactor configMap loader to work with appregistry
+f1940f847 fix(csv): only allow one CSV per provided API across intersecting operatorgroups
+50fbf6458 Add godoc for InstallModeTypes
+57a7afcb3 test(registry): add InstallModes to CSV
+d31025f10 fix(openapi): add InstallMode definition
+925655bcc revendor and run codegen
+25d72b41a fix(packagemanifest): Add InstallModes info from CSV to PackageManifest
+e8f8655cc fix(olm): Remove the "v" prefix in minKubeVersion if presents
+9f912b0e3 fix(e2e): fix instability in test runs
+8f14c334e fix(e2e): add MinKubeVersion to helper function
+67e3d1ef8 fix(build): remove dep usage
+8c9136482 chore(build): make vendor
+caf326347 fix(build): update grpc-health-probe for module support
+b97a84d42 fix(deploy): Add a component prefix to manifests
+2ae16e15f fix(build): make static build work
+c178f5d48 chore(modules): update operator-registry module to v1.0.6
+d82344597 fix(deploy): fix image references
+a65328f14 fix(deploy): set writeStatusName for ocp builds
+868528e3c Update README.md
+7b7ae8dcb fix(subscriptions): respect startingCSV
+ae5c508d3 fix(installplans): only create installplans if something new has been resolved.
+b5d0fa058 fix(reconciler): set command in pod spec of registry images
+78a126960 chore(olm): run make vendor
+975ad4c55 feat(olm): write operator status by default
+1d6b495c8 fix(subscriptions): add check for csv manifest dif before applying new installplans
+b1fa131ff fix(e2e): ensure all subscriptions are deleted in replacing test
+e027882a1 fix(subscriptions): fix race between subscription sync and cache
+d6fe1d4db fix(dockerfile): user needs enough access to read from the filesystem
+30e6fd6ba fix(permissions): Generate unique Names for permissions
+7e5d76415 chore(modules): update version of OLM module and revendor
+cbb8b85fb fix link for Package Server CSV
+3c8e6ad5a add ownerReference to backing ConfigMap for given CatalogSource
+83d7c58b0 fix(catalog): use installplan lister instead of api client
+6e29b7ea9 feat(lister): add installplan lister
+7dadd63f8 fix(e2e): only select installplans owned by subscriptions
+4fc1890f4 feat(catalog/olm): add tracking ids to logging
+cc707d518 fix(catalog): remove gate on operatorgroups for resolution
+b0d8941aa fix(dockerfile): move configmap-server into path
+32550468e test(subscription): update unit tests to use the namespace resolver for subscription tests
+7b07a12ca fix(catalog): move write of installplan state from installplan execution into namespace resolution - this prevents races where installplans are created twice.
+8f86ad348 fix(installplan): only resolve if there's a subscription in the ns that isn't up to date
+8a4121934 fix(installplan): fix bug where too many installplans can be created
+46794f8ec fix(cm-reconciler): query for pods to overwrite by CatalogSource label
+a8d9c7769 chore(deploy): change 30 prefix to 50
+1b9468098 chore(style): run goimports
+55438ab31 fix(installplans): add ability to apply Services
+047cd1971 fix(test): get kube version from client go for tests
+a524d1674 chore(deps): vendor
+39cdaad0d fix(catalogsources): omit unhealthy catalogs from resolution
+459d86b0a fix(installplan): fix race in installplan resolution
+5698be925 fix(e2e): make e2e-local-docker work again
+8c89b3464 feat(catalog): add grpc sourcetype to CatalogSources
+4a5183c74 fix(registry): service label selector doesn't include resourceversion
+eb1de5179 fix(catalog): use a different queue for each namespace
+4be186cf6 test(catalog): add e2e test to verify configmap changes are detected
+95ed12de6 feat(bundles): add GetBundle request
+c146f9abd fix(olm): Provide correct format of kube version in CSV
+5288a5ed5 fix(olm): always return a status on minKubeVersion checks
+be95cc5a8 Add minimum kube version to CSV & check it against server version
+e307808e5 WIP: add new minimum version field for kube
+f3b3f36c6 test(validation): add test to verify OLM can use bundles with CRDs with min/max fields
+b59f9bd7f fix(bundle): fix CRD conversion with minimum validation field
+b5a2b47ea fix(packageserver): don't error out when listing
+8ecc5da64 fix(operatorgroups): write out CSV status on OperatorGroup issues
+6a46d07b2 chore(deps): update vendor directory
+ef58599f5 fix(metrics): create another endpoint for prometheus
+92c857223 cut 0.8.1
+4c48fe3de fix(deploy): add linux nodeselector
+07e1cd7fd fix(operatorgroups): use copied csv for update status
+ba067f232 test(unit): fix TestAPIMultiOwnerSet_PopAPIKey tests
+a9bdff870 feat(packageserver): consume registry pods
+4d1502429 Update metering InstallModes to support SingleNamespace
+275186f2b Watch all namespaces in local setup by removing watchedNamespaces in local-values
+ede8ca0d9 chore(ci): remove ci checks for PRs
+a5c0963fd feat(registry): remove in-mem registry implementation
+ef5b2b669 feat(resolver): take all subscriptions into account when resolving
+c1c195036 Remove operatorsource installation
+506edc8a1 fix(dep): bump olm types so that registry can serve new CSVs
+5e6ec00e5 feat(client): expose underlying clients
+43b5c8c3e fix 1663113. Add component image ENV vars to cluster-logging-operator fix 1662397. Add permissions to create shared-config roles and bindings
+165b3440c update Service Catalog memory & cpu limits
+3f68bd4d2 adding csv, crds, package for metering operator
+00ee55020 feat(installmodes): add installmodes to templates
+406474b17 feat(installmode): add InstallModeSet
+7d6753bd3 refactor(operatorgroup): account for TargetNamespace field in updateNamespaceList(...)
+022a23a85 feat(csv): add installmodes to CSV spec
+574534883 update codegen for 2019
+b7174678a fix(configmap-server): switch dockerfile to go 1.10
+f276c7bab fix(configmap-server): gvk parsed for owned CRDs incorrectly, so bundles were omitting CRDs
+f2c19df89 Updated MongoDB Operator to 0.6
+37aaaab06 test(catalog): add an e2e test verifying that the rh-operators catalog starts up correctly
+e786106bb fix(crds): remove category all from CRDs
+936f30312 refactor(schema): split groupOrName into group and plural fields
+99af1d8a3 chore(codegen): run codegen
+8724cf751 chore(tools): add golang/protobuf as a tool dep
+24203a998 feat(codegen): add container-codegen make rule
+5f9b21f63 feat(olm): add message to requirement statuses
+03b6ff80d fix(unit): fix tests involving CRD status
+50227493c fix(unit): use global logrus logging instance
+36ca0f607 Verify CRD's condition to ensure it's registered with k8s API
+2213da1bd fix(packages): add sourceNamespace to packages apiserver
+780c7da9b requeue dependent subscriptions when a catalog syncs
+35cb43134 fix(sub): set subscription to failed if there's no catalogsource
+d3f7e2e68 fix(charts): add operator_namespace to run-local values
+5d637db1e chore(ci): add OWNERS file
+adecf7d47 Install operatorsource crd and default cr
+166bdcdc9 increase memory limits on all service catalog pods
+85754a591 chore(fake): add fake for registry client
+20b0487b0 refactor(Makefile): rename test rule to unit
+79a4b1b5e chore(Dockerfile): remove directory check
+474834c10 fix(build): enable cgo
+9040a39e4 chore(go.sum): regenerate go.sum
+324aa4786 feat(make): prevent test caching
+bf072023f fix(test): add missing fields to expected bundle
+aec9d5950 fix(client): correct package used for healthcheck client
+cd5b6d7fb feat(image): add CI compatible Dockerfile
+fd5f8758f chore(deps): vendor
+d1c52bff6 test(registry): add checks for registry pods
+e7fbda496 feat(catalog): use operatorlister in catalog operator
+e6a525627 feat(registry): when syncing catalogsources, generate pods that serve the operator registry api for configmaps
+d643abb1f feat(catalog): add configmap server image config flag
+a338c9d2e feat(api): add registryservice to catalogsource status
+3e0e45f64 chore(olm): make use of operator group constants
+67653a5c9 fix(olm): don't annotate target namespace on copied CSVs
+24e120898 feat(rbac): generate cluster role for viewing CRD for each provided api
+4614df31a add 'get' permission for the CRD itself to the created Role
+d0f57b81e fix(deploy): fix marketplace manifests
+c8d4d3879 fix(health): move health to its own package with the right package name
+f4f14e91b feat(health): add gRPC health probe tool to docker images
+263d1d506 Add Marketplace csv
+77292f514 Creating csv, crd, and packages for clusterlogging and elasticsearch operators
+77fc133c7 fix(deploy): add runlevel to openshift-operators
+84d2c53ef fix(schema-check): fix schema check error bug and update manifests
+93a7f370c feat(csv): make apiservicedefinition pluralname required
+0741fe54f refactor(logs): factor out default writer hook setup
+07a1114fc feat(configmap-server): write panic and fatal log levels to a termination log - adds `termination-log` flag to `configmap-server` binary to specify termination log path - writes panic and fatal log levels to a termination log
+25bfdcca0 feat(registry-server): write panic and fatal log levels to a termination log
+10670752d feat(logs): add WriterHook type for splitting log levels between writers
+f4e93cf64 fix(go-mod): fix checksum issue with client-go go module
+de7a6951c feat(olm): generate clusterroles for provided apis in csv loop and aggregate them to operatorgroup clusterroles
+9e88aac5f feat(operatorgroups): don't process CSVs that aren't in an operatorgroup
+5543d0032 chore(manifests): regenerate manifests
+d62e71aa0 test(packagemanifests): add wait for package-server to be ready
+655b10ba3 feat(subscriptions): requeue dependent Subscriptions on CatalogSource sync
+df410b47f feat(helm): create helm templates for package-server subscription
+5abc4daf3 Updating: adding description to package manifest object - solves ALM-819
+9055ba276 add rbac for servicebindings/finalizers
+377ec21d4 Make use a valid clusterPermissions rule verb
+772f1db38 chore(docs): fix markdown lint warnings
+86d4b4d62 docs(arch): add operator groups
+98970c61e increase limits for embedded etcd
+1a627c1d0 chore(release): switch image-reference tag to operator-lifecycle-manager
+e7d66c8f4 use quay.io vs registry.reg-aws.openshift.com
+76581508d regen manifests
+c5cc09aa0 fix(scripts): clean up all resources when done
+0be9286ae feat(deploy): add operator group to watch all namespaces
+1640fe921 chore(scripts): add quoting for safer bash
+00e70a34e chore(docs): fix up whitespacing
+846f1f95f Descheduler operator CRD, CSV
+285de2730 fix(e2e): make operator group test more robust
+f45a4f45a feat(ci): remove e2e tests from gitlab
+31766b91d chore(manifests): make release
+5815ef4a6 feat(package-server): self-host package-server with CSV
+7e0447ebb fix(e2e): create CSV first to use in CRD ownerref
+d1df2b6a2 fix(e2e): use testNamespace for ownedAPIService test
+db65feb62 Fix a typo in documentation
+4703e7c9a fix panics in package-server
+c43cf67b8 fix(e2e): set up variables for non-bare e2e runs
+d87b352b7 feat(e2e-bare): add utilities for running olm and e2e locally against a remote cluster
+820e9e5a6 feat(make): add e2e command for running from ci-operator
+6f3600144 test(csv): use mock-ext-server for owned apiservice e2e test
+d201e7396 fix(annotations): merge CSV and pod template annotations instead of replacing
+220616c44 fix client-go in gomodules
+61ceea9d1 fix(bundle): fix CRD <plural>.<group> parsing
+05f4f3cff add packagemanifest:aggregated-apiserver-clusterrole
+360ce2fde Add packagemanifest:aggregated-apiserver-clusterrole
+c73307e23 feat(operatorgroups): move annotation projection to csv loop
+2730daf40 test(operatorgroups): more comprehensive tests of operator group copying and rbac generation behavior
+27b195273 fix(e2e): add operator namespace to target ns list
+4ad704dd6 fix(unit): account for correct rbac resource parsing
+e02bca22b fix(e2e): account for operator group type change
+a4fd04eec feat(operatorgroup): create role bindings for operator service accounts in target namespaces
+55e67a96a propagate labels from 'CatalogSource' to each 'PackageManifest'
+61480a0e3 fix(csv-requeue): requeue on namespace all if all namespaces are watched
+ab3883aff fix(olm): create cleanup function for olm deploy mod
+5578e8a4e fix(olm): fix RBAC cluster role creation
+4e4f50087 chore(olm): add additional debug in requirements
+a7ec12e50 fix(olm): add additional validation for operator groups
+b0ed43694 feat(olm): use cache listers in olm-operator
+097341675 cut 0.8.0
+20e6155ee chore(build): remove vendor commands from base dockerfile
+1a90ec0c6 chore(release): bump version to 0.8.0
+410eae4f9 feat(mocks): generate fakes and mocks in a container
+26f089585 fix(rbac): use separate queues for each rbac resource
+b9c1b02c5 fix(queueInformers): use separate queue for each namespace
+1a4fa284b fix(logging): use structure logging in checkAPIServiceResources
+759d9005a chore(olm): remove cleanup func from operator
+5af8a7878 remove namespace annotator
+ab09d5ab4 fix gomodules (broken by client-go mutating their release tag)
+35191e341 chore(ci): remove verify step from gitlab
+a26ef5745 feat(container): make container builds faster
+5acebac83 chore(codegen): run all codegen in a container
+546ca8fc6 chore(deps): switch to go modules
+da014b133 feat(csv): detect deployment and requirement changes in Succeeded and Failed phases
+934a667b8 use OpenShift's ServiceCatalog build, fix rbac + more
+05248e810 Update AMQ logo to new brand standard
+fd6d9d41f Fix template values for 'olm' parameters
+3ad3d5250 feat(build): allow skipping minikube during local builds
+86eedf88c fix(olm): make operator group copy CSVs more efficiently
+f095b0cfa fix(olm): remove duplicated code
+3bb7e25d5 chore(olm): refactor updateNamespaceList
+e7bce974f fix(unit): create OperatorGroups with initial fakes
+777e33cd6 chore(docs): update readme with configmap-sever and pkg/client
+08ee59ca5 feat(health): add healthcheck endpoint
+2de662325 feat(schema): add validators to directory loader
+3bc77b9e9 feat(client): add grpc client interface
+bcb4ef9b7 feat(bundle): add package/channel name to bundle
+eb2ab43a4 chore(deps): switch to go modules
+59ca95847 fix(olm): do not check namespace if casting failed
+80c876ef8 fix(olm): operator group annotations and listers
+33f83dc49 fix(e2e): slightly improves execution time
+59d7698eb fix(olm): set event handler functions correctly
+c89aa9cbb fix(olm): refactor e2e and check annotations
+2e8cd467b WIP: cvs in operator namespace are being annotated, csvs in target namespaces should be annotated
+a4ccb4ea9 fix(olm): adds debug logging for operator groups
+7af0b4274 feat(olm): detect dangling child csvs in olm operator
+7a65c2b84 fix(olm): handle copied CSVs when deletion occurs
+48279b413 fix(e2e): update e2e for refactoring
+4b5070abf fix(unit): fix race condition
+bc96bb9ea fix(unit): set expected owner refs for deployments
+c969049c0 refactor(operatorgroup): split apart the larger sync functions
+43f64db30 fix(e2e): ensure created objects are deleted
+df5b760fc fix(olm): make RBAC creation resilient
+552699b61 test(e2e): add second e2e for operator groups
+efafe6cc8 fix(unit): call Run on operator directly
+24ceed696 test(e2e): add e2e test for operator groups
+c12dd0acb fix(olm): make status updates on deployments, not CSVs
+090e09169 test(unit): add unit tests for operator groups
+2e3b84bba fix(olm): change annotations to be allocation safe
+8f954fef8 feat(olm): copy "dummy" CSVs to target namespaces
+891f247bf feat(olm): handle required RBAC permissions
+c39e3bd0d feat(olm): make namespace updates trigger annotation updates
+65fc370a2 chore(olm): rename annotateNamespace to syncNamespace
+245092f00 feat(olm): add operator group control loop
+e88b05108 feat(olm): add CRD definition for OperatorGroup
+81c635217 chore(olm): generated files
+9c2e92f3d feat(olm): add OperatorGroup types
+6b80c5e4c Add test case for supporting multi-version CRD
+a086ddbfb fix(build): add cleanup for package release files
+c92d07ede Fix olm pod name so log to be written correctly to olm.log
+a686d26c2 fix(olm): set lister up for deployments
+927097c9c add 'spec.nativeAPIs' field to CSV and check that native APIs exist before install
+dd9d1effa add Service as owned resource for Prometheus/Alertmanager CRDs
+2057a5a8f feat(listers): add and use aggregate informer lister
+ee5b4ae1a feat(csv): add generated APIService resource check
+d35c0e44b fix(ci): cleanup packagemanifest APIService during deploy stop job
+63a08e6ff feat(csv): add succeeded to pending transition on cert refresh
+4aa3dc9c9 feat(csv): add configurable APIService cert expiration
+af7aaef7b feat(apiservices): add APIService adoption logic
+c357affb0 refactor(ownerutil): make HasOwnerConflicts generic
+4b65ea613 chore(test): bump minikube kube version to 1.12.0
+40b9aca47 fix ClusterServiceVersion CRD to allow any descriptor default value
+a5b2c7e06 added spec/status descriptors for Dynatrace Operator
+09d5d2c67 feat(grpc): enable reflection on grpc endpoints
+8e464096f feat(configmap-server): add dockerfile which builds and runs configmap-server
+b975d8cb5 feat(configmap-server): add configmap-server binary
+16d58cbcc chore(deps): update dependencies for version-config
+51bffd94f feat(registry-server): add server binary that speaks grpc
+7ccd900bf feat(grpc): adds basic gRPC interface to querier
+18e518dce emit events when setting CSV phase
+29fe5db4d Add `assign` verb to csv crd
+a3db7f955 chore(release): cut release 0.7.4
+9b2995211 add ConfigMap as an owned resource for Prometheus CR
+197e96843 [Doc] Add note about helm binary requirement
+4145a1806 chore(release): bump version number to 0.7.4
+7b8b4d965 feat(load/query): support provided APIs that are apiservices
+e3c57bf55 chore(deps): depend on latest OLM
+78cd6aef2 feat(configmap): add configmap loader
+2d79c5e74 fix(e2e): switch to port 5443 for owned apiservice test
+762b71f4c chore(e2e): change package port to 5443
+b404cbf8d fix(olm): don't annotate namespaces on operator creation
+082cc655d feat(deploy): add debug variable to all deployments
+c18a09fe6 fix(package-server): make secure port configurable and default to 5443
+68ea1a40c chore(package-server): enable auth by default
+c7f7d014f pass annotations from CSVs to associated PackageManifest
+6ce20c55d adding more spec/status descriptors for CouchbaseCluster
+993bfaf65 fix(metrics): use CRD client instead of k8s
+383ecd915 Update OKD install instructions
+05a785a87 fix(requirements): add CRD served version requirement check
+11fb00bf5 fix(requirements): add support for non resource url rules
+2134f0bc8 rewrite 'metadata.namespace' of global PackageManifests
+5ca5dff37 bump olm version to 0.7.3
+8d1dc0cdf chore(deploy): remove unneeded dockerfiles
+bec794bc3 fix(csv): make invalid install strategy transition from pending to failed
+3deda8696 fix(requirements): remove extra empty permission requirement statuses
+c7002dc28 Add missing nonResourceURL verbs to csv validation
+860d44536 cut 0.7.2
+78d575e32 chore(deploy): update release scripts to not use 3 different images
+fb851e585 chore(deploy): put all binaries in the same image
+c402e10fc add 'catalogSourceDisplayName' to PackageManifest status
+8105c238f fix(ci): use deployment namespace as catalog_namespace
+50272f783 Small log statement fix
+d62c141af chore(deps): remove unneeded dependencies
+33c3455fd chore(pkg): make more like a kube-style go package
+cee0231ed feat(query): open db as immutable for querying
+5c4df7f1d feat(query): add query interface and refactor tables
+57c11c154 feat(load): add package and channel loading
+f1543cde6 refactor(store): add storage abstraction
+853ef172f feat(loader): create basic loader that puts csvs and bundles into a sqllite db
+812dfaceb Initial commit
+42db65951 chore(deploy): use runlevel label on namespace
+01ad7f88e docs(apiservices): add some detail on APIServices in CSVs
+ffc9f1ffa feat(svcat): add service-catalog manifests
+ccc90f8c1 feat(csv): install owned APIServices
+80d5d4d72 chore(deploy): Add runlevels to release
+576bd7f97 chore(ci): Use a single Dockerfile for ci
+a4e548c1e Make use a valid clusterPermissions rule verb
+ba4c536a2 Remove explain 'annotations' and 'replaces'
+79f74adf3 add example and additional info about optional CSV metadata  (replaces, annotations, labels, selectors)
+b6eb190be return PackageManifests from 'global' namespace
+10e333f6f fix 30_14-imagestream.yaml formatting
+5f4124db2 add 'spec.provider' to Federation CSV
+0720b00da Update registry unit test for FederationV2
+0c5f96f9d Split out FederationV2 CRD file into many files
+2f423feeb Update FederationV2 CSV to add spec fields
+d9d694c89 rh-operators: add FederationV2 v0.0.2
+577a4fc82 Add missing binary to fix run-local-shift
+a6a89d1a7 fix(deploy): add base images for ci-operator
+90ea442dc Dropping label for origin releasepayload
+372ccfda7 implement watch for PackageManifest resource
+228bcfd4b feat(package-server): add minimal watch
+f6d7f7bc4 fix(build): don't vendor
+32849e132 change go build to use 1.10
+bf4a190a1 fix(submodules): remove submodules
+84df81088 fix(deploy): only use replace on configmaps
+442b1efcb Revert "fix(deploy): remove package-server until ci-operator is outputting the package-server tag"
+86dfcb241 fix(deploy): remove package-server until ci-operator is outputting the package-server tag
+7a6397510 fix(deploy): yaml error in imagereferences
+9810bc424 fix(deploy) rename image stream to `image_references`
+9c2407f17 Add manifests to dockerfile
+d8d886adf re-cut 0.7.1
+ad49bfffb docs(rule_checker): update hasOwnerConflicts comment wording
+c4c1daa7d test(rule_checker): wait for informers to sync before continuing tests
+db157196f refactor(olm): use SharedIndexInformer listers for RBAC resources
+8ec2872c7 docs(rule_checker): add reasoning note to hasOwnerConflicts method
+f786d5ad0 chore(dep): constrain k8s.io/kubernetes to the release-1.11 branch
+4bee692f0 chore(comments): correct comment mistakes
+d93643dc7 test(deployment): remove/refactor tests expecting RBAC installation
+5de6abb67 chore(code_gen): regen mocks and openapi
+9f786750a refactor(olm): add DependentStatus message field
+96c41c543 test(csv_e2e): add e2e tests for permission requirements
+4bb2ddf53 feat(olm): add ClusterRole/Binding requirement checking
+4db66160f refactor(rule_checker): move rule_checker to install package
+015b67ee4 feat(permissions): add RBAC permissions as CSV requirement
+4282e8606 refine cluster-admin OLM workflow
+4687eae95 certified-operators: rectify form of business for Dynatrace
+19b060924 test(installplan): test clusterrole and clusterrolebinding resolution
+907830ea5 refactor(resolver): move step resolution to resolver package
+728b77743 feat(catalog): resolve ClusterPermissions on CSVs as part of an installplan resolution
+9895763b2 feat(deploy): add clusterPermissions to CSV
+3078c946f fix(deploy): update upstream release
+df5006c58 fix(ci): don't create namespace (it's in the chart now)
+cc7ba87e7 cut 0.7.1
+e04dec6bc feat(ci): push tags to quay
+438f78da0 re-cut 0.7.0
+201b9be82 chore(deploy): add package server to release scripts
+db0185040 Issue #469 update the service catalog instruction for minishift.
+4a10ee634 fix(olm): don't both checking for GVK in discovery for CRDs
+7febb04bd feat(e2e): use newNginxInstallStrategy helper to clean up csv e2e tests
+07ffd1cc0 test(olm): add e2e tests for depending on apiservices
+81230fd72 test(olm): add unit tests for depending on apiservices
+17b25b08a feat(olm): check for the existence of required APIServices before installing
+033abf478 chore(deps): add kube-aggregator to get APIService types
+2794c3a1b feat(apiservices): add support in CSV for apiservices
+725a0cc69 chore(catalog): remove TODO comment
+00d077b6c chore(mocks): regen client mocks
+57eca037a refactor(resolver): rename resolved RBAC resources
+4fd31ca37 feat(catalog): add OwnerRef patching for ServiceAccounts, Roles, and RoleBindings
+21585d6f0 feat(operatorclient): add Role and RoleBinding clients
+65d2c98f5 fix(catalog): update OwnerReferences with stored CSV UIDs
+b9d21d166 refactor(installplan): move scheme build to init
+7b685f654 feat(resolver): generate UIDs for freshly resolved CSVs
+8b87f1bf2 fix(catalog): handle creation of RBAC resources in plan execution
+b5a4713fa test(catalog): add e2e test for InstallPlan RBAC resolution/execution
+8094fc49e feat(installplan): resolve RBAC resources during InstallPlan resolution
+a2d5f4eac feat(installplan): enable creating step resources from runtime.Object
+32cfc26ec return all 'PackageManifests' for 'all-namespaces'
+d2eab9cf6 feat(olm): add metrics
+0e4167295 Documentation: Change to full path
+14b3482ef Create OWNERS
+b6e34b70b Improvements on the MongoDB Enterprise Operator CSV.
+113407d06 List out options for Descriptors
+e7cfbac65 test(e2e): add OwnerReference GC behavior test
+73a292419 style(e2e): re-order imports
+9245fe5e8 cut 0.7.0 release
+bb8f78305 feat(deploy): update makefile to generate deploy artifacts for okd
+e140db8ea cut 0.7.0 images
+07e3fb437 fix(vendor): revendor dependencies
+780ce7c75 feat(olm): attempt to cleanup namespace annotations on shutdown
+1ddf8b5ab fix(scripts): short-circuit up to length 1 running pipelines
+e6c8b7258 style(scripts): snake_case is_head function
+55786a805 fix(ci): move wait-in-queue job before deploy-preview
+427da0761 feat(ci): add wait in queue job to test_setup stage
+2f8a379d9 feat(scripts): add pipeline queue wait script
+fc5d4626f fix(e2e): update prometheus channel
+5764db8e2 rh-operators: use preview as channel for Prometheus
+5402a4c69 rh-operators: use preview as channel for AMQ
+621f218cf certified-operators: use preview as channel for Dynatrace
+efcfc1a6f certified-operators: use preview as channel for MongoDB
+92c39c7e1 certified-operators: use preview as channel for Couchbase
+542e4c5f8 certified-operators: add double spaces in Mongo markdown
+84c08e330 certified-operators: fix Mongo markdown lists
+67402a8e5 certified-operators: add required parameters for MongoDB
+d09dde676 certified-operators: add required parameters for Dynatrace
+4f8eb35d8 certified-operators: add required parameters for Couchbase
+793e813b0 Fix certified operators packages csv refs
+4423d7afc include certified-operators catalog in deploy on CI
+8420ccf4d Update directory loader test for amq-streams
+ed31d09f2 certified-operators: update Dynatrace version
+1f68e32f4 certified-operators: add Dynatrace CSV + CRD
+c7126206b certified-operators: add Couchbase CSV + CRD
+3f440bfc6 certified-operators: add MongoDB CSV + CRDs
+7797a6643 rh-operators: add AMQ Streams CSV + CRDs
+051f57e7d feat(catalog): add aggregated roles for each crd we resolve
+0a608ad7e fix(reststorage): start with empty slice when filtering
+db3942765 feat(inmem): collect CSV data in PackageManifestStatus
+77cee5d03 chore(server): remove commented packages
+94935273b test(e2e): use CSVDescription in expected PackageManifestStatus
+66bd1bd4a chore(openapi): regenerate openapi spec
+b7cacfab5 feat(packagemanifest): add CSVDescription to PackageManifest
+2267c5ac0 fix(build): add OLM_VERSION file and .git directory to e2e.Dockerfile
+1eeb7b32d test(packagemanifest): add fetch function for packagemanifests
+9eb5b27c9 test(e2e): add logging to TestPackageManifestLoading
+a66cb8fb4 fix(charts): change cert secret mount path
+b4fd5c712 fix(charts): change default package-server internal port value to 443
+c57cd7365 fix(charts): update expected package-server chart value name
+49fdd3f24 refactor(charts): use olm-operator-serviceaccount for package-server
+4d97b9bac fix(charts): correct indentation
+39f009bb7 fix(charts): add missing coreos pull secret
+3c5621d13 fix(scripts): uncomment cleanup
+0cc75e2fd feat(ci): add package-server to ci
+d01ba48da feat(scripts): add package-server to build scripts
+698832f56 feat(docker): add package-server to Dockerfiles
+2e527c6d4 feat(reststorage): return NotFoundError if manifest not found
+b74429868 fix(provider): don't use pointer in manifest selection loop
+e7f4f99c1 feat(package-server): add debug flag
+7c29094cb fix(package-server): surface cobra flags to package level
+8555e6cb8 feat(package-server): add run-local package-server helm values
+c677e3b99 test(package-server): add basic e2e test
+7dcd3763a feat(deploy): update package-server templates
+3d9744815 fix(inmem): change struct tags
+978e9fed1 refactor(packagemanifest): move all package data to status
+b37b5821d chore(package-server): remove and ignore local config
+5ee54cd3c feat(package-server): enable openapi
+dd56ae77a feat(package-server): adds skeleton of package server
+bd3d54fd7 fix(prometheus): add securityContext to alertmanager example
+85108765a Recommend installing OLM with `kubectl create` instead of `kubectl apply`
+8b1abe1a2 docs: update broken link
+81d09f937 docs: text -> label
+36ea39607 docs: move desc to bottom
+530bc0518 docs: add CSV guide
+56ff27a19 fix(build): remove GOOS and GOARCH settings
+52b5296e9 feat(build): add version injection to go test build
+acc784adf style(flags): change version output format
+0f90e0009 fix(build): point version build ldflag to correct package path
+5b503d2a6 feat(cmd): add version flags
+7c93f7155 chore(osbs): remove unused Dockerfile.single
+78b9b0a7b feat(run_console_local): add docker pull for console image
+c19ac11a0 fix console script to work with both Linux and MacOS
+ee48d103e chore(broker): remove servicebroker from CI
+8dcd2a8c7 chore(rbac): add olm-specific ClusterRole
+94b3b30f7 Remove outdated install instructions
+9e7956d19 remove non-go references to broker
+62dadcee2 prune dependencies via dep ensure
+dde0a7e48 fix(servicebroker): remove broker from repository
+c108aea18 chore(deploy): remove ansible scripts for install
+d4741172a feat(osbs): add non-multistage docker build
+76dd0dbd0 fix(scripts): allow use of existing KUBECONFIG env var
+ad56ecc22 chore(catalog): rename ocs -> rh-operators
+68f1a9e91 chore(rbac): remove view verbs from edit role
+59ad7e3cf chore(prometheus): remove namespaceSelector from ServiceMonitor
+2c211124a fix(scripts): make cp cross-platform
+6acd8a48c chore(api): move non-generated apiclients out of the api dir
+07b5110ac add script and instructions for running OpenShift console
+97b27fab3 fix(Dockerfile): fix catalog copy typo
+ab70f7dba fix(Dockerfile): add catalog bin to final docker image
+2256df73c chore(ci): update gitlab-ci.jsonnet to reflect Dockerfile name change
+bb59bfdb5 refactor(Dockerfile): make Dockerfile.rhel7 OSBS compliant
+31e3eba25 chore(dep): vendor dependencies
+4125547c2 updated prometheus csv according to the integration into openshift
+6b80809d5 test(e2e): add catalog loading between operator restart test
+5d9e452eb add actionDescriptors block
+b23c8efe6 feat(subscription): add dedicated currentCSV field to subscription status
+2203111f4 fix(catalog): add check for loaded catalogs
+439256825 fix(operatorclient): remove wait for deployment rollout
+374290c40 set 'status' on Subscription when 'spec.source' is invalid
+6a7518a31 fix(e2e): remove deployment cleanup
+3f4e27e07 refactor(operatorclient): remove error return in deployment poll
+4491d8403 fix(operatorclient): return error from infinite deployment poll
+6b4d2eba7 test(e2e): add wait for deletion during OLM cleanup
+bf4a14a1f fix(catalog): ensure pre-existing check does not interfere with upgrades
+c60ae953e refactor(resolver): incorporate custom error type
+cb588e9c5 feat(catalog): add namespace awareness to plan execution
+b8a269e99 feat(controllers): add custom error type for multiple existing CRD owners
+27edc7317 style(operator_test): reorder import statements
+7cb66c4ee refactor(catalog): return early from sync catalog
+1c4bcb219 test(e2e): add deferred global cleanup calls to subscription tests
+c14bc66c7 fix(e2e): move log after nil check
+ad7caa09f fix(ocs): reduce prometheus requested resources
+1d420641a fix(olm): restrict deployment watches to the watched namespaces of the operator
+b71a302ca feat(operators): log which queue items are coming from
+9efec1a28 test(e2e): remove cleanupOLM calls
+745e5f78a refactor(catalog): only load in-mem when a change is detected
+58feeb875 test(installplan): add helper functions for building test CSVs
+7c1b83953 fix(catalog): correct sync logic to accept catalog spec changes
+1187ed015 test(catalog): add wait for catalog sync to e2e tests
+0719e0326 refactor(catalog): enable status subresource
+0474469ac test(catalog): add catalog source sync unit tests
+380940256 refactor(types): remove Hash field from ConfigMapResourceReference
+1fb79a741 feat(catalog): add catalog status block updates
+387f164ba fix(e2e): re-enable prometheus test
+602285003 chore(rbac): update roles to include resources
+4cf17efb4 chore(rbac): list out verbs in edit role
+668805c04 update 0.6.0 release
+db9a9f07a fix(ocs): add securityContext to prometheus example
+cfdedb7b5 chore(deploy): update 0.6.0 for okd
+111a95643 fix(ocs): update prometheus operator
+c69496bb3 Fixes #416
+197bde49b Make key resources linkable in philosophy doc
+b317a5eb2 cut 0.6.0
+9de59fd19 style(resolver): remove nesting from owner CSV selection logic
+9f6c1d6e9 refactor(catalog): remove map-based subscription caching
+1743c95c5 chore(dep): re-vendor with dep stable
+cd85776a8 feat(resolver): add namespace and channel awareness
+cf617c20f chore(docs): update docs for newer types
+84868ef46 chore(ci): update catalognamespace for olm
+0f1bbb332 fix(e2e): don't use vault in e2e tests
+2d4b06951 chore(ci): disable teamui deploy
+039988967 chore(catalog): update prometheus deployment for 0.22.2
+391c5928b fix(catalog_versions_test): test all releases
+78547f8c3 chore(deploy): remove tectonic-alm-operator
+517f061d1 chore(deploy): remove old catalog entries
+8f5525034 chore(vendor): remove vendor directory
+662609500 fix(e2e): use fetchinstallplan in subscription tests
+08af520eb chore(e2e): delete duplicated test from merging
+295d802cd refactor(opclient): remove fake operatorclient
+38f4c25d1 fix(olm): re-enable a requeue
+de2752e7a chore(fmt): order imports correctly
+ea9bf4e92 fix(e2e): update fetchSubscription call to new use version
+ab97ddc1c feat(deploy): add OLM type access to aggregated cluster roles
+c8ec51dbf fix(csv): delete csvs immediately
+83d17c7b0 feat(subscriptions): pick up installplan changes more quickly
+2660204eb chore(logs): add debug logs if item can't be found in index
+3376c3cba fix(deploy): key the rolebinding to the namespace so that serviceaccount won't lose its access when a new binding is created
+0f8bfd5a5 fix(e2e): clear existing CSVs before running subscription tests
+4a6ed5c60 fix(installplan_e2e): add deferred cleanup calls to installplan e2e tests
+e4985b308 fix(subscription_e2e): ensure subscriptions are completely cleaned up
+607b52f9d fix(subscription_e2e): add check and wait for subscription status
+1e023d067 fix(cvs_e2e_test): move old serviceaccount existence check
+e39f55bbe wip(olm): fix leaks
+98d38f7ed chore(api): update apps/v1beta2 to apps/v1
+9c9e4533e fix(subscriptions): don't update subscription when there are no status changes
+d05219d5f feat(olm): set up watches on deployments so that csv status can be updated more frequently
+60010413e chore(tests): remove old mock-based tests in favor of fakes
+e31534859 chore(tests): rewrite TestIsBeingReplaced with fakes
+1d7360b12 chore(tests): rewrite TestIsReplacing with fakes
+95c72be4c fix(olm): add fixes for GC optimization
+06920b014 wip(olm): add failing upgrade csv test
+07a2812b1 minor: broken link
+c481d2225 chore(deploy): update deployment resources to use apps/v1
+5c2a51aef chore(api): bump deployments from apps/v1beta2 to apps/v1
+c606b220c update 'urn:alm:descriptor:com.tectonic.ui:selector' to use GroupVersionKind
+f2a205b0b chore(ocs): Update to prometheus 0.22.2 but disable e2e test
+6b8ff7cf0 feat(makefile): allow running a single e2e test from the make command
+6d88c5f00 chore(e2e): switch to using the versioned clients in e2e tests
+4abf88438 feat(api): migrate apis to common group and regen apis/clients
+27800d810 fix(csv): update CatalogSource for 1.11
+b5f088377 fix(catalog): update Subscription control loops for 1.11
+f72e9f948 fix(csv): update Subscription for 1.11
+4e4368cf9 fix(catalogs): remove outdated EtcdCluster validation
+a7d7dd653 fix(catalog): update InstallPlan control loops for 1.11
+95c2f5802 fix(catalogs): update catalog data to use ClusterServiceVersion
+28ab3c373 fix(ip): update InstallPlan for 1.11
+e7072f953 fix(olm): update ClusterServiceVersion control loops for 1.11
+a9e652fff fix(csv): update ClusterServiceVersion for 1.11
+bbd1255b3 fix(build_local): don't start minikube if already running
+608913485 fix(csv): k8sjson encoders don't properly omitempty on json.RawMessage serialization.
+097c4f2f2 fix(crds): update CRDs to validate in 1.11 (versions field now required)
+44a72746e chore(codegen): update codegen for 1.11
+0194241fe chore(deps): update k8s libs to 1.11 versions
+036ae5481 chore(catalog_versions): remove extra lines in import
+f9c8f2339 test(catalog_versions): add resolveCatalogs test for catlogs in each version
+ee0196f45 refactor(resolver): make resolved step logging more helpful
+0ff6cfd45 add 'spec.sourceNamespace' to the Subscription CRD validation block
+0105c944c docs: add access control workflow
+ca90d23aa fix(ci): deploy files to ci cluster in order
+32d8e90f6 fix(makefile): fix run-local and run-local-shift
+a1486e2cb fix(e2e): update prometheus serviceaccount
+f10bc0f90 fix(make): fix local e2e
+e211d3e23 fix(e2e): update e2e prometheus test for 0.22.0
+2edc560a6 fix(deploy): put prometheus in ocs catalog
+351cb3d88 fix(ci): update ci to use replace
+d2dda9d52 deploy/chart: bump prometheus to 0.22.1
+8cbffb90a feat(catalog_resources): add prometheus 0.22.0
+03124436a test(installplan_e2e): change main package name to avoid conflicts
+271600231 style(catalog): add missing semicolon to log
+bfe9ac670 fix(catalog): remove required CRD existence check for service additions
+b749aac27 test(installplan_e2e): add multi source install test
+4f27e0baa test(util): add internal catalog source creation helper function
+31dc52771 Fix invalid `minishift start` option in install_local_shift.sh
+3a66ebc5e chore(ci): update gitlab-ci.yml from jsonnet
+3cdcbf16a fix(installplan): type InstallPlan.Status.CatalogSources to []string for backwards compatibility
+bfd82e638 chore(ci): update gitlab-ci.yml from jsonnet
+8910b0f54 need to use 'operator-lifecycle-manager' namespace but ffctl is broked
+a17754f00 fix(subscriptions_test): replace single source resolver with multi source
+e21e79ec2 refactor(resolver): accept prioritized list of source refs as a parameter
+03f8b6a04 refactor(catalog): change parameters of getPrefferedSourceKey to take a source snapshot
+d93c54b8b fix(e2e-local): remove extra RBAC config on minikube start (default in newer kubeadm versions)
+c549f66c7 fix(e2e): apply charts from templates directory
+d01ac8c39 refactor(InstallPlan): add source name and namespace to install plan custom resource
+a92fe931e refactor(catalog): limit sources snapshot to global and install plan namespaces
+9e3df88a0 feat(catalog): add catalog and catalog namespace to install plan spec
+bb8078868 feat(catalog): add helper method to get preferred source key from plan owning subscription
+9545f2152 feat(registry): add subscription key type
+d5769bfb8 test(resolve): decouple expected results from test input
+bbcf01ca1 refactor(resolver): return used catalog sources slice from ResolveInstallPlan
+9e743b3f4 chore(registry): dedupe to in comment
+9354895a0 refactor(InstallPlan): use registry.SourceKey to keep track of used CatalogSources
+4d69b3cfa chore(.gitignore): remove vscode file exceptions
+f632f4010 fix(resolver): set resolved csv namespace to plan namespace in MultiSourceResolver
+eae597485 feat(catalog): use MultiSourceResolver in catalog operator
+c7b14e40f test(resolver): add tests for MultiSourceResolver
+3c7d33482 refactor(catalog): add helper method for getting a sources snapshot
+0d6bb9c47 refactor(resolver): remove extra functions from DependencyResolver interface
+1a45332bf feat(resolver): add CatalogSourceNamespace field to StepResource struct
+1165abfab vendor: re-run `dep ensure`
+25511b20b cut 0.5.0 release
+50c897e3a feat(release): build a release package from a tag
+91c38ab3d fix SingleSourceResolver to use plan namespace for resolved CSVs
+06b50db63 refactor catalogLabel to catalogLabelKey
+325261689 fix namespace used for CatalogSource lookup
+abe61f64f refactor resolver to be in separate package
+3b182f3bc refactor interface method parameters
+50490e0e3 fix remove .vscode/launch.json
+654e93e88 remove test for MultiDependencyResolver
+bddbf013c add test for step resource catalog source
+b3c455587 add DependencyResolver interface and SingleSourceResolver implementation
+d23e85a8f refactor interface method parameters
+6b40120fc fix remove .vscode/launch.json from .gitignore explicit include
+16589abea fix remove .vscode/launch.json
+543c64122 remove test for MultiDependencyResolver
+4d003a0e3 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling
+980db9111 add test for step resource catalog source
+6b8b5ff57 add DependencyResolver interface and SingleSourceResolver implementation
+cff0db1a3 add 'spec.catalogNamespace' field to Subscription-v1
+bd7b58c2f fix catalog_namespace for deploying to OpenShift
+e55a60890 deploy to TeamUI's OpenShift cluster
+b36fd16a0 fix(docs): correct spelling of philosopy.md
+17ffa434b fix(docs): typos in architecture.md
+250af4476 feat(olm-operator): prevent a CSV from installing if there is another CSV in the namespace that owns the same CRD, but isn't being replaced.
+a2108bf9a Fix a small typo
+a5c8eacfd add checks for runaway control loops in e2e tests
+3daf90d41 fix(servicebroker): add main_test.go to servicebroker cmd
+2348ddff2 fix(make): fixes run-local and run-local-shift
+da4468ecc fixed panic(err) calls
+dd623f1e1 check upgrade path per package directory
+075c815aa changed filepath for pragmas
+910b7f3f3 remove testing.T from manifest validation files
+54dd79093 moved schema validation
+9c6b98db0 chore(deps): remove tectonic-operators as a dependency
+2bba14a79 feat(operatorclient): add minimal operatorclient types
+194bd8c65 fix(make): set version var for run-local
+94418b29d make 'InstallPlanPhaseInstalling' come before 'InstallPlanPhaseRequiresApproval'
+caf34fd70 added docs for RequiresApproval phase
+868a28ecc readme: fix broken link to CSV example
+363c84034 fix(catalog): catalogsources should only read from their configured namespace, not all namespaces
+d5d05c0c0 fix(catalog): release memory after loading catalog
+b801bfc8d fix(ansible): make sure git submodules are checked out before ansible build
+79ca1dc62 feat(build): add rhel build
+d7d7a1177 chore(deploy): add openshift_ansible as a submodule in order to symlink lib_openshift and lib_utils
+ce3b229f4 chore(deploy): add ansible playbook for deploying OLM
+7d00b5e89 feat(ownerutil): update ownerutil to infer GVK for OLM types
+c879cc35d fix(subscriptions): directly include apiversion/kind of created resource
+c9dce1d7d fix(e2e): make e2e local scripts work again
+3fc0a8d3d Fix the deploy to kubernetes command in install.md
+fc6a7a7a5 do not update Subscription-v1 if nothing has changed
+d1b6e23d2 chore(deploy): add upstream release and deployment pipeline
+f9768c04c chore(build): use helm to template the catalog files in
+8b1f7ee9d chore(deploy): which catalogs get included in a release is configurable
+89fbf9a1d feat(servicebroker): list one serviceclass per package
+9ad912554 fix(ci): codegen needs apimachinary to not be pruned
+17f6121c2 chore(deps): update servicebroker for newer servicebroker libs
+1f3d81f5a chore(deps): commit vendored dependencies so that project can be built by people without access to tectonic-operators
+f6e8e3342 fix(e2e): fix local e2e scripts
+9783645f9 test(e2e): add e2e test for Subscription/installPlanApproval
+4ad6c1f0b feat(subscription): installPlanApproval field
+b9e80e193 implement manual approval of install plans
+e6810e636 strip Markdown from descriptions for OSB
+222d82960 fix(servicebroker): reverse map check bool order
+fade2fc00 test(servicebroker): check validatation of broker api version endpoint
+4e49b72ee fix(apiserver): fixes rebase problems also removes the apiserver tests, which are empty
+41f65aaff fix(apiserver): update imports
+d11988b8c fix(servicebroker/types): dedup description
+a97ea1654 fix(servicebroker/types): set bindable to false on serviceplans
+ad074103e fix(servicebroker/types): use link url for support url in serviceclasses
+a285b5402 fix(servicebroker): grab namespace from interface object
+f156b318e chore(servicebroker): update types from broker libs
+bcdc69033 feat(servicebroker): display icons and pretty names in catalog
+92af257ed fix(servicebroker/apiserver): use un-normalized CSV name
+7daa34551 temp(servicebroker/apiserver): log debug lines
+d21077bc5 wip(broker/sources): implement LastOperation handler logic
+5923fe185 fix(ci): fix e2e test runner
+7f8419538 fix(makefile): add build-coverage command back for e2e testing
+f93bfac38 feat(ci): multi-stage builds and verify codegen and catalog during build
+bb724dfbe chore(ci): simplify container builds
+54905993b fix(makefile): fix release scripts
+b9fe8395c fix(deploy): chart naming after rebase
+d1d8c984f fix(makefile): support ocs and ccomponent catalogs
+6adef178e fix(makefile): always build targets so that dockerfile builds work
+75314ee29 fix(broker): use updated imports for osb
+e3c90bcde fix(makefile): xargs working cross-platform
+dcfa5355e chore(deps): update lockfile
+0aededa15 chore(rename): fix path in catalog version tests
+e788c53cc fix(Makefile): update makefile recipes for rearrangement
+e4a207468 chore(servicebroker/apiserver): update broker interface types
+44e654018 chore(Makefile): add target to run e2e with minishift
+b51858ba6 fix(deploy/chart/templates/01-alm-operator.serviceaccount): specify pullsecret
+fcded45ae rearrange(deploy/chart/templates): create secret before clusterservicebroker obj
+9f32512ea fix(.): update scripts with e2e dir move
+792d366c1 fix(Makefile): codegen clients correctly
+11b0fd0f2 chore(*): update github repo org
+2f270b789 chore(makefile): clean up build
+faf8375dc fix(Makefile): add '-' back to flag (rebase fix)
+3a2416e86 feat(deploy): add servicebroker templates
+5746da11f feat(broker): add service broker service for alm
+499afff02 fixup(api/client/util): return err instead of panicking
+84498f5fd use environment variable for TEAMUI_HOST
+19f0b8263 use InstallCheckFailed instead of DependenciesConflict
+d6e77454b s/ALM/OLM for Slack webhook
+93eaddc6d Update manifests for 0.4.0 release
+0ed1cf517 fix(catalog): pull secrets are no longer needed for vault and chargeback
+a7f943afe Update README.md
+bd6b73565 Update README.md
+9f4b4027c Update architecture.md
+24bc4f7d4 chore(rename): ALM -> OLM in design docs
+19adb6066 Add simple install instructions for using a released OLM
+72d4974f5 chore(rename): rename ALM -> OLM in install docs
+19e95d9cf Remove unneeded install steps (minikube fix and pull secret)
+45cc1d27d chore(rename): rename quay.io/coreos/alm -> quay.io/coreos/olm
+3f8dc2891 readme: restrict SVG height
+5721eed44 added intro for framework
+edc68169a fix(ci): update paths in dockerfiles
+a0e81f0b3 chore(codegen): run codegen on renamed codebase
+4d7d550e7 chore(rename): rename alm -> operator-lifecycle-manager
+0ba0253dd chore(ci): update ci to use new operator-lifecycle-manager repo
+8a40137cf Add pipeline status to readme
+2a2ddebaa Update readme
+7c5b7c638 *: add code of conduct 🎉
+0133f3c7e re-cut 0.4.0
+1176500c9 fix(e2e): same deployment install strategy shouldn't change label selectors, which are immutable
+2a4ea0533 fix(ci): better names for e2e test objects
+0200909b7 fix(e2e): generate different label selectors for test deployments
+73f48f7cb fix(e2e): use different csv names for each test case
+63fee6903 fix(ci): don't error if serviceaccount is already patched
+f6d3ec674 fix(subscriptions): startingCSV is not required
+13eedc74a fix(rename): coreos-inc -> coreos
+3b6dfcb15 fix(ci): vendor in sanity check to remove codegen error
+64b49f0f3 fix(e2e): use name of catalogsource instead of name of configmap
+9ab4a6e66 fix(deploy): update x-operator version to one that supports CRs
+408c98dad fix(deploy): use DeleteAndRecreate strategy for CatalogSource updates
+3b5db85c8 fix(deploy): catalogsources should have different names
+6f9c8c7f5 fix(deploy): put catalogsources in catalog namespace, not hardcoded to tectonic system
+41f95a011 remove generation of catalogsources from catalog/main
+a0b72c722 write out both ocs and component catalogsources
+f2ce7b1c1 update catalog version test to handle multiple catalogs
+3b9f54ecc split catalogs into OCS and cluster components, package 0.4.0
+6843afc77 chore(Gopkg.lock): update dependencies
+230b40367 chore(*): update github repo org
+594320503 Review docs for outdated information
+4a46dd1cf move Slack webhook URL to environment variable
+e29a3f463 catalog: update etcd-operator to 0.9.2
+f77ed56e5 fix(ci): switch to short sha for naming
+2ddf08d73 fix(ci): update failfast namespace for new ci cluster
+c2396d176 do not update Subscription-v1 if unmodified
+1b3b603e3 add bill of materials
+fd26e1adf add Apache 2.0 License
+f39bb583f fix(ci): change $SHA8 gitlab var to new $CI_COMMIT_SHA
+fa8d8e1d7 fix(ci): update docker host path
+43288c869 removed UICatalogEntry-v1
+1a00232a1 added docs for Subscription control loop
+1d3949357 fix(e2e/subscription): update import paths
+ccdb1e7d9 chore(Makefile): clean up all test files
+2609e6b36 refactor(e2e/subscriptions): add cleanup fns
+f1fcf6db9 test(e2e): test subscriptions control loops
+dfd51c10e chore(.gitlab): use commit sha in ns
+81b35edce refactor Subscription control loop to only call Update() once
+51278d5f7 fix Slack notification
+5190d338d fix Slack notification webhook in CI
+84e87486c send Slack update when deploying to Team UI cluster
+49546168a GitLab CI deploys to Team UI cluster watching all namespaces
+3e204955b modify GitLab CI to deploy master branch to Team UI cluster
+8a9ad12a0 fix example YAML
+29c97d309 fix subscriptions being stuck in UpgradePending state
+f65c33a94 chore(.gitignore): ignore all generated resources
+34127a659 set Subscription 'status.state'
+2814325a6 refactor(tests): split source and calculate coverage over non-generated code.
+686eecd4e docs(development.md): encourage test running after dependency update
+56eeea37a fix(ci): pull common variable out into vars.libsonnet
+42044973e test(e2e): add coverage generation to e2e tests
+94f02c00f fix(tests): update tests to use the new client fakes
+2c9bc4052 refactor(clients): switch to using generated apiclients
+bb1f39afa feat(ci): add sanity check step which does basic verification before building the images
+9a980093a fix(ci): update fmt-ci to handle multiple files
+879f8ae61 feat(ci): run verify-codegen and verify-catalog before building
+ab3b4a853 remove gocoverutil, go 1.10 coverage tools can aggregate coverage now
+0e55de464 switch to go 1.10
+db6b96d25 fix(e2e): fix invalid CSV in e2e test
+e6fde0804 fix(catalog_resources): update deployment specs for 1.9
+a628f9ce7 fix(makefile): separate vet and docs testing
+ee0851e39 fix(e2e): use newer apiversions
+82470a72f Add $(DEP) as prereq to vendor make commands
+59e34092e Switch references from glide to dep
+a9104b930 Generate clients with code-generator
+9cf4b9e71 Update api usage to 1.9 apis
+92704e89b Update api usage for 1.9
+529d0db00 switch to k8s.io/code-generator
+4bbb40f27 Switch to dep and update dependencies
+df945292c update ALM templates with correct JSON schema
+5ff5cb62e fix subscription status
+0a6f63510 Cut 0.3.1
+dba789582 add annotations for example custom resources to CSV
+abd4db71d Update install instructions and add a `make run-local-shift` command to run locally in minishift.
+54caa1e24 update csv requirements
+f806d1cb4 fix(crds): nest csv, uice, sub, and installplan validation under "spec"
+cb2f61710 fix(crds): nest catalogsource validation under "spec"
+47dd92950 cut 0.3.0-5
+e33db7287 cut 0.3.0-4
+a401495eb cut 0.3.0-3
+a06451b82 clean up during e2e tests
+ff0c05956 Remove vault podstatus descriptor
+961c4d3f6 Add prometheus 0.14.0 and update 0.3.0 release of alm
+e4d985385 feat(operators/catalog): label resolved CSVs and CRDs with the catalog source they come from
+fdf467182 fix(operators/catalog): set phase to failed when resolution fails and enable the e2e test for it
+90ea9b8a7 catalog: update etcd-operator to 0.9.0
+2649b50e7 hack(ownerutil): hardcode groupkindversion for ownerreferences to CSV
+508d7de9f fix(install/deployment): use ownerreferences when checking for SAs
+8d86ec12b refactor(uicatalogentry): minor renaming / refactoring
+93a225841 e2e test for uicatalogentry updates and pruning
+a437bce4d Prune old UICatalogEntries from the cluster on catalog sync
+dc789396f When a watched object is deleted, purge it from the queue
+2c43f0070 fix(client/installplan): use correct resource name
+18dc0affa catalog operator ensures labels on Subscriptions
+ca9789ae0 fix(alm/operator): don't update the status timestamp if we aren't transitioning
+2a20b2c5e catalog: update vault-operator to 0.1.9
+ed5cdae7d Fix chargeback e2e test
+e96dc5816 Fix e2e test reporting in gitlab
+befb6dfff Update images for 0.3.0
+6d8f959ab fix imports
+92230e644 fix(catalog): add tests for compatibility between versions of the catalog configmap and fix the errors that the tests revealed
+4df53d390 cut 0.3.0
+eb43a1383 add alm-catalog label to Vault CSV
+f59cd0f12 Revert changes to labels/match labels on the deployments
+ac872b1fb fix(pkg/client/installplan): only set name if provided
+58c4f231f fix(operators/catalog): don't update catalogsource status when processed
+fd6948338 fix(operators/catalog): don't share informers between installplan and subscriptions
+12bd02664 pkg/registry: Update tests for Chargeback
+3f1249351 catalog_resources: Add Chargeback resources to catalog
+a5e86df9b fix(operators/catalog/subscription): specify csv in installplan (duh)
+682f736eb fix(apis/uicatalogentry,subscription): set list items to correct type
+d055915f8 fix logs in e2e tests
+6a3753b75 Add package loading to catalog directory loader (only used for tests)
+78b1b279c Add additional logging to catalog loading
+b9e83e77b Fix makefile build directive
+4c5f5b751 Remove `replaces` from prometheus operator since we don't have an older version
+217bf7dd4 fix(apis/subscription): correct meta in List obj
+750cf4ed0 fix(operators/catalog): use the right plural name to list subscriptions
+08884b64d Switch from gomock to counterfeiter and update tests
+b430e12ec feat(operators/catalog): standardize to UTC time
+97b42de74 fixup(apis/subscription): use the sane json tag
+cc3f2b29d chore(zz_generated.mock*): regenerate code for k8s types
+833e86ef9 chore(.gitlab-ci): ignore not found errors on delete
+436502185 feat(operators/catalog/subscription): use startcsv if specified
+f94f23981 fixup(subscriptions): use CurrentCSV in status block
+e22af3da0 test(operators/catalog/subscriptions): test lastupdate times
+5abb528b4 fix(operator/catalog/operator): ensure safe concurrent map access
+2bb164e4a fix(operator/catalog/operator): update queueinformer fun signature
+c9132b48b fixup(operators/catalog/subscription): store apiversion/kind info
+1509eee14 test(operators/catalog/subscriptions): ensure installplan existence checked
+0d399fb31 fixup(subscriptions): check for installplan existance
+2e5700adb fixup(operators/catalog/subscriptions): regen mocks and such
+8f07e3510 chore(operators/catalog): generate mock catalog
+45725cbb5 test(operators/catalog/subscriptions): add unit tests
+7fa8321f9 fix(operators/catalog/subscriptions): save subscription
+aecdd376e chore(operators/catalog): generate mock clients for subscription tests
+2ebf1e111 chore(**/zz_generated.mock_*): update mocks
+c7c45203c feat(operators/catalog/subscriptions): add subscription ctrl loop
+0888ca77a feat(subscription): save install reference
+9922e4ef9 feat(pkg/client/installplan): add create method
+956217442 feat(pkg/client/subscription): wrap subscription ops in client
+226ddce54 feat(apis/subscription): add subscription crd back in
+c5dd8c29b Add package metadata to UICatalogEntries
+4e8d25920 Update philosopy.md
+22eb68587 catalog: update etcd-operator to 0.8.3
+2c511b072 e2e: Load catalog entries from the in-cluster catalog and verify they  install
+03aa72130 Requeue more often when we know we can shortcut a resync
+bbfd7cf11 Add a doc on tracing errors through from ALM resources
+fead9d149 Minor renaming / refactoring
+624401d39 Refactor e2e test utils
+f89f6711f Port drive design docs to the repo
+ae7a328a6 Add docs on GCing and the new packaging format
+35463b1c9 Fix e2e tests
+904ebf401 Only query for csvsInNamespace once per loop
+634aae599 Add requeuing logic to simplify state handling
+1365bb1f2 e2e tests for CSV upgrades
+2c04a95e3 Clean up old CSVs if they're successfully replaced.
+280269bd6 Don't queue up delete events (we take no actions for any of them)
+05242e5dc catalog: update etcd-operator 0.8.2 and vault-operator 0.1.8
+588d3f895 Update packaging for vault and etcd to use the new package format
+101505cd1 catalog_resources: add etcd backup/restore operator and bump up etcd/vault operator version
+c6f78ed31 Implement ListLatestCSVsForCRD, which finds the latest CSV holding a CRD, per channel
+d08554284 Add concept of packages to catalog, for tracking of services at a grouped level
+87bb06ff9 better description for EtcdCluster in Vault CSV to drive UI
+785a2da51 add spec descriptor for ResourceRequirements for etcd
+cff77eb40 modify spec descriptors for Prometheus OCS
+66a511262 Use generate unique name for e2e job
+cb003b061 Rename and export FindReplacementCSVForName method
+2c1778093 Remove references to Service Name in catalog
+a82badb22 Don't use helm upgrade
+32137bc9e Move all scripts to /scripts
+bc5e7154a Seperate update-catalog into its own script
+f9d34fdbf Update e2e tests to run in separate cluster
+f6ac082f0 CD to separate cluster
+1016b59af Cleanup Catalog interface in prep for fixing how we handle service names
+f39c27046 add labels to OCS catalog ClusterServiceVersion templates
+265c661f4 add visibility annotation to catalog resources
+5abc89166 move build catalog script to hack/
+3f64f6bca fix whitespace stripping from configmap generation
+efb7fab9b deploy/TAO: use stable release of x-operator
+2d8e689b3 update EtcdCluster s/service/serviceName
+472e92f8f chore(.gitignore): ignore test artifacts
+fce062f24 chore(Makefile): remove vendor update from e2e-local
+2ebe712b8 style(buiild_catalog_configmap.sh): trim trailing whitespace
+68ba7ea6a test(e2e): test catalog entries visibility set correctly
+790d1dfb0 style(catalog_resources): add newline at end of file
+9b7dbd571 feat(catalog/uicatalogentries): add label via csv annotation for visiblity
+a022f0ae9 Consolidate vault operator version references
+507014eca Add errors package to vendored dependencies
+4ea3d4af3 Add readme for tests
+c24afe788 Add note for running single test
+81c9205ec Add test ensuring Vault cluster is created with etcd pods
+f8b23f4c1 Cleanup
+182e3fbaa Add failed InstallPlan phase and skip test for it
+3f302d165 Refactor InstallPlan fetching and allow passing an anonymous checker function
+801931dee Add test for creating InstallPlans with invalid CSV names
+23382b230 Add test for creating InstallPlans with invalid CSV names without a Failed plan state
+bab2e24ae Add test for creating InstallPlans from UICatalogEntry list
+f5128701d Adds test for expected UICatalogEntries
+546a48ec2 Add the ability to run a single test
+5799be2a8 fix(package-release): use gnu compatible cp options
+ddb3356a7 Tag e2e test container with latest when master builds
+3a8c21629 Take $NAMESPACE as an argument for updating the catalog
+b9f63ffe6 Put jq script for convert to tap format into a separate file
+312798ec9 Containerize e2e testing and output TAP format
+076c69558 catalog: fix inconsistent header size
+df5651396 catalog: fix markdown formatting/rendering
+fe9eecc43 [e2e] Add a test for InstallPlans with  manual approval
+3c8e22d78 Release alm 0.2.1
+608fb47e2 Fix parameter count comparisons
+f58c9bb3f Bump vault OCS version
+0ed9cf51b remove alpha files
+5349127f8 Add docs for packaging
+21fa5c5ed Fix catalog resource tests and remove samples
+281e3e75f Add packaging script to generate x-operator manifests
+61bb093a6 rename chart directory to "chart"
+b904f44e5 operators/catalog: only add catalogsources once
+4a4798bb9 Update 0.2.0 manifests
+6167b5c7c Update etcd-operator
+f576758b9 Update alm versions in 0.2.0 release
+a39745b80 operators/catalog: add Type field to copied Secret
+a690fa00e Update etcd and prometheus to latest operator versions
+b0c91cf94 update Vault OCS SHA w/ make update-catalog
+b81582bbd run 'make update-catalog' for ALM-316
+4e7f05062 reorder CRD resources to correctly match ownerrefs
+e694cfe6d run codegen for ALM-316
+fa204a9e7 add resources to Operator CSVs to complete the ownerref chain
+8b8d4b40b add 'resources' block to ClusterServiceVersion types
+9848a321b Remove catalogsource cr from helm chart (catalog creates it on start)
+3b6f9afc6 tectonic-alm-operator: bump operator SHAs
+7a0dde528 operators/catalog: only copy secret data
+cefb160e5 Update the OCS to pick up the latest changes
+5b5f4a2e5 Fix the defective CSV schema
+1383b475a Fix up the alm_resources install directory
+c4251a38d Update manifests for v0.2.0.
+9e78175bb Copy over the resource for the 0.1.2 release and renumber
+a0fbef077 Don't use full apiversion as resource name in CSV client
+99aabd7f5 Remove incomplete e2e test
+df705b24f Fix nil pointer error in CatalogSourceClient
+f4e13b325 Add catalog source to helm chart
+c4163044a helm: add configmap
+ae6921d48 glide: bump lock file
+f03292c37 install: add CatalogSource CRD
+06ae38ff4 cmd/catalog: bootstrap OCS catalog
+9b14c85c1 operators/catalog: rename aceClient uiceClient
+3036dc2e6 operators/catalog: fix grammar in comments
+1954e0631 operators/catalog: support secrets in InstallPlans
+a68258310 Update OCS configmap
+65f7bf3e4 update Vault ClusterServiceVersion
+3d0e32ef7 for posterity
+675ef4936 Refactor install strategy deployment check
+de1ba79d8 CSV upgrades: look for deployments by name, upgrade any with the same name in the new CSV, delete any that are in the old but not the new, create any that are in the new but not the old.
+d35a90cc4 feat(*): specify objectmeta for CSV to replace
+255877f7c test(pkg/client/deployment): add serviceaccount tests
+0b6aa0bc4 refactor(pkg/client/deployment): use operator-client service account fns directly
+77282a019 Add resources blocks for the CRDs defined in the OCS
+f66cf399c Fix typo in CSV schema
+eea242edb Properly label all resources that will be managed by x-operator
+1f1b680ae Prepare test cluster with CatalogSource CRD
+3afc0f031 Rename AlphaCatalogEntry to UICatalogEntry
+36279ae9a Fixes for the Catalog configmap generator
+defc572ed Add the OCS catalog as a ConfigMap
+d31260a5b operators/catalog: return error instead of fatal
+826ea5136 operators/catalog: init CatalogSource control loop
+b812e70f0 fix Prometheus specDescriptors
+5a75f4203 Add a config map loader for catalog sources
+3f66ad2ea catalog: link to OCS user docs
+5c892b826 catalog: beta -> alpha
+b0560a994 catalog: update OCS descriptions
+6cf87e688 add more spec descriptors for Prometheus CRDs
+24e2dbb12 Update prometheusoperator.clusterserviceversion.yaml
+cbc39d4b1 Add prometheus role
+7dff085ab Add a catalogsource client with create and update function
+0380fecd2 Tiny fix to use a const to set the CSV CRD name
+6ed4e9706 Remove URL from catalogsource CRD until we have a remote catalog type
+13c1d7f85 Set catalog namespace when deploying for preview
+989a30bf6 Fix runtime panic due to client-go changes in new operator-client version
+105fe43c3 Support both kube-1.7 and kube-1.8 in deploy charts
+fdd0f03cc Update to tectonic-operators
+0ae6887e5 Throw error when validating resources if asked to validate a kind we don't handle
+b071dd1fb Add local e2e testing scripts and an example e2e test
+864647d96 chart: Remove unused ClusterRole and make catalog namespace configurable
+76a7ba8f9 Refactor installplan name into constant
+e42e7fd83 Update all catalog resources with the new CSV format
+2efc9ca19 fix(pkg/install/deployment): compare deps by name/ownerref only
+126028e00 fix(pkg/operators/alm/operator): put correct error in status on install failure
+2b687dfc5 Add cluster size status descriptor to prometheus
+c8a2704bf test(pkg/install/deployment): create suite of table tests
+531d6bd28 test(pkg/install/deployment): make more explicit tests
+705110b18 refactor(pkg/install/deployment): break up install function
+43d4803e1 fix(pkg/install): use Create*OrUpdate*Deployment
+17eeee9f8 style(pkg/install/deployment_test): remove unnecessary struct init
+ecf714e56 refactor(pkg/install/deployment): use semantic comparision
+413c0deff fix(pkg/client/deployment): use cascading delete for deployments
+efffa7d92 style(pkg/client/deployment): add newline b/w functions
+077e973c5 hack(install/deployment): make current tests for dep updates pass
+bd1744651 fix(install/deployment_test): use correct type in array
+a9b227ae1 feat(install/deployment): create or update or delete deployments
+7b3eb97ad feat(install/deployment): check deployments installed by name/spec
+ed593bc8d feat(client/deployment_install): create OR update deployment by name
+a34819087 feat(install/deployment): create consistent dep names
+3cdd68632 catalogsource: add metadata fields
+1ca09c108 catalogsource: add omitempty tags
+ae24fbb09 installplan: add catalogSources to status
+b0757e8c7 catalog: init ocs catalog source resource
+0b61b810f catalogsource: add k8s interface codegen
+1f42090f7 init catalogsource type
+b354c75a6 remove placeholder statusDescriptors
+5258e579f Update appversion.yaml
+c1e38eade TAO: README w/ tectonic-operators build instructions
+e3a22ea4d tectonic-alm-operator: bump operator image SHAs
+a1c5c315b tectonic-alm-operator: copy v0.1.1 to v0.1.2
+e1d164e76 Swap namespace/name in annotation so that they match the env vars
+459680e23 add version to deployment ownerReference
+dec2fc26c alpha: explicitly pass manifests directory
+e6fb23c7c x-operator: build image based on alpine x-operator
+d534db1f2 x-operator: fix CSV CRD schema in v0.1.1 manifests
+b71c1e7ca alpha: bump v0.1.1
+8f8908909 alpha: init
+2f924f289 deploy: cut v0.1.1 tectonic-alm-operator
+344fcb925 deploy: copy v0.1.0 manifests to v0.1.1
+d3d38c941 Fix generate-mock-client to generate from/into the pkg directory
+9046613b0 Add missing dependency tools to the DEVELOPMENT file
+8039a3888 pkg/catalog/directory_loader.go: skip hidden nodes
+a03db1ed8 style(cmd/alm): format usage string on flag better
+adf2cf45d refactor(alm/operator): clarify watched namespaces
+7a0a9f89e fix(alm/operator): use non-wrapped client
+a79dd39e3 fix(Makefile): make 'all' the default target
+9d0cc0425 refactor(alm): pass in annotations from main
+aa7bd3a96 style(alm/operator): simplify variable name
+49c4f136c style(alm/operator): rename function args
+b297c38f9 fix(alm/operator): watch all namespaces if none provided
+6ca4bfe0c fix+refactor(pkg/operators/alm): watch specific namespaces only
+0bbd6734e feat(pkg/annotator,pkg/operators/alm): add control loop for annotating namespaces
+7eb7997a6 rearrange(pkg/annotater->pkg/annotator): spell annotator correctly
+3c421922e allow icon to be empty in CSV
+6096d77f6 chore(apis/csv): regenerate api objects
+89359b89e Fixes clusterserviceversion schema
+c15dc45bf docs/architecture: add control loop details
+f8900df14 docs/design: add manual install stub
+e0f5fc74d docs/design: add architecture doc and fix readme
+214e1a1af docs/design: delete stale design docs
+0d286d41a docs/design: delete old mocks
+c64bb7716 docs/install: remove coreos-pull-secret
+c32dd09b4 Update install docs for the cut branch of Console
+359ce53c9 add SpecDescriptors to ClusterServiceVersion
+40d3139dc Add the required resources to let x-operator install ALM in minikube
+4da37ff6a Add a specialization of the x-operator for ALM
+d51f448e2 README: add quay badge
+05b9a3637 style(*): alias core/v1 import everywhere as corev1
+59fc735d3 refactor(installplan): abstract away conditions array in status
+3c8e268cf style(catalog): use consistent import names
+64a973aec test(pkg/apis/installplan/v1alpha1/types): test setting conditions in status
+ad89d6392 refactor(pkg/operators/catalog): explicitly switch on err to set conditions
+c51fe6311 chore(apis/installplan/v1alpha1/types): use conditions instead of phase in status
+a45cfd4b8 README: fix install link and JIRA link
+5c550caa5 Test our catalog resources for consistency
+3f2651a05 Adjust CSV status descriptors for Vault to reflect new status block
+e7664d5cc Update alm/catalog images in install resources
+56449cc44 Remove commented code
+620f7b53f Fix namespace labelling bug
+da0a83367 Move code into /pkg and create coverage report
+2a0ae297c Add more unit tests
+d41cee464 Add "coverage" (html) and "cover" (cli) commands, update to exclude mocks
+390466790 Add various shortNames to the various CRDs
+3be03c819 Change maintainers and add useful links to our CSVs
+8e336c313 Update etcd Cluster CSV to have it display real status information
+e2bcc7862 spellcheck
+8bf4159a4 Fix catalog resources
+a81f24207 Refactor deployment strategy client + naming fixes
+2c01e155b Deploy install strategy: Add tests for error cases
+3008cf157 Add tests for deployment install strategy with role generation
+a0719aa9f Refactor install strategies
+bebc30076 Switch to patch for updating namespace
+7c4bc0512 Annotate namespaces on ALM operator start
+1398a2429 apis/installplan: test JSON manifest on StepRes
+5cc41d6cf operators/catalog: test creation of dependent CRDs
+a3f97f43e operators/catalog: s/CreatePlan/ResolvePlan
+747bc9e5a apis/csv: fix nondeterminism in GetAllCRDDescs
+cdb61ea81 operators/catalog: refactor and table-testify
+67566c234 apis/installplan: add StepResource constructors
+45fa62f89 apis/csv: rename GetAllCrds and table test
+b559bea5a csv/customresourcedefinitions: add version and kind
+a904d2f6f test(client/alphacatalogentry): refactor tests into table fmt
+b1d59a84b fix(apis/clusterserviceversion): correct json tag
+0999e77e3 wip
+ac4c2d8ca test(client/alphacatalogclient): more thoroughly test update cases
+08c692918 test(client/alphacatalogentry): test error case
+9810213ad test(client/alphacatalogentry): test upsert behavior
+0adb952fb test(client/alphacatalogentry): add test machinery
+8107f25c7 Update alm and catalog images to latest
+1d46d2f45 catalog: resources should use correct sha256 image names
+63c25443b alm/operator: Add a test for transitioning to pending if component goes unhealthy
+45ff9b877 alm/operator: check if resource has gone missing and replace it if so
+bb3b9aa7a remove pull secret from install
+c5f9bb6c2 fix(catalog/alphacatalogentries): set sync status correctly
+cbec3997d test(catalog): test store sync
+a2eb3f62f Update etcd and vault to latest releases
+b651f109e Update install.md
+3af0e65db Set ownerreferences on all objects created from install strategy
+5619f85ef Add omittempty to fields on CSV
+f61bb87f3 fix(client/alphacatalogentry): use put not patch
+e262f54da doc(catalog): add debug lines
+ee7bd4146 style(client/alphaservicecatalog): remove nested ifs
+701c00a1c feat(client/alphacatalogentry): patch existing catalogentries
+6ae1fc13f WIP
+f8f27fdfe refactor(cmd/catalog/main): clean up file
+16824272a Install instructions for ALM + Bridge locally with minikube
+8d362fa0d Add serviceaccount for vault
+58bba6153 (temporarily) use dev versions of vault and etcd operator
+3e420d0f4 Update catalog resource labelling
+bdb10b70f apis/csv: make OwnsCRD a CSV method
+a654189aa operators/catalog: decouple phases from logic
+10f39d462 queueinformer: move MockListWatcher
+ab2f2c6a8 operators/catalog: table-driven csvOwnsCRD test
+2099aacee Add command for generating coverage report
+2d71dba20 Update install instructions
+ee3420c56 Update rendered yamls for installation
+ed9f3fbd1 Update prometheus defintions
+9f24cf1b9 doc(control-loops): update CRD name to InstallPlan
+b106dce31 Update prometheus
+4e0806c23 Better naming and log levels
+4d00d9fc9 Update prometheus CSV to 0.14.0
+c66895406 InstallPlanList should be a list of InstallPlans, not InstallPlanSpecs
+940a0c528 wait for caches to sync before processing queue
+9ac472ac6 Prometheus CSV should use the same serviceaccount in permissions and deployment
+e0abb4dbd Better log messages on catalog operator
+66f32b798 Add entry matcher for alphacatalogentry client tests
+a99fb05bb Restore alphacatalogentry test
+e79f3769f Switch to log.Fatalf
+dca4ee0a5 Update vault CSV to point to latest version, and use coreos-pull-secret
+1840452d3 Fix operator tests
+d7e703eb9 Ignore if alphacatalogentry exists
+c88e66a04 If AlphaCatalogEntry exists, update with a put
+93b5a4c43 re-enable alphacatalogentry generation
+e8dcb9de9 Installplan should resolve to objects in the same namespace
+4631ca47c Serialize resolved resources as json
+0a5cff653 Fix operator loop
+fb2917cbf Add logging to installplan resolution
+6e0fb8f20 Add more logging to queueinformer
+7d97811a8 Add more logging to catalog operator
+2c337cf01 Update installplan types
+a034a8434 don't generate alphacatalogentries for now
+f4b7a9477 Ignore if catalog entries exist
+c9cefa7b9 Delete/recreate alphacatalog entries
+1df9ac708 Update even if there's a transition error
+2c39416da Patch don't put
+7e799d6d2 Set initial phase to planning on installplan
+58e9a72cc Fix alphacatalogentry api calls
+1a5693c3d Install alphacatalogentries into configured namespace
+1bf0a87b5 Add logging to alphacatalogclient
+6facb06d1 Return early if no error creating resources
+0b52863f2 create AlphaCatalogEntry if it doesn't exist
+bda30d238 Update catalog resources for self-consistancy
+bbebdce26 Add more descriptive errors
+2653dfbc4 add catalog files to container
+9ee3656d3 catalog: more logging
+711248cc9 Load catalog resources into cluster as AlphaCatalogEntries
+f59759b77 Create alphacatalogentry on deploy
+0dcf06218 Fix vet error
+bb64463d2 test(operators/catalog): add ListServices method to test impl of interface
+fea5f52f3 test(catalog/alphacatalogentries): fix test mocks
+e79b47be7 fix(catalog/alphacatalogentries): correct pt/receiver types'
+c74fcba99 test(alphacatalogentries): test catalog sync
+c85632ced chore(mock_alphacatalogentry_client): generate mock
+6a8896f85 feat(catalog,client/alphacatalogentry): sync catalog to CRs functionality
+8e20f82b4 feat(catalog/types,mem): add method on interface for listing all services
+8ca885420 operators/catalog: add multi-source TODO
+061ca277e operators/catalog: transition to install phase
+061d28a78 makefile: generate installplan mocks
+4a873601c makefile: add gen-all command and run
+c803ac260 operators/catalog: init installing a plan
+5bb648ab9 Load in memory catalog from a directory
+a9bb74a2b Add CSV to install plan resolution
+c47878196 Fix tests
+2d3a4ddc0 feat(operators/catalog/install_plan.go): adding resources to install plan
+15aed12b0 apis/csv: add missing provider field
+c710a88ac Add prometheus and vault catalog resources
+05db140ed Add catalog resources directory and test catalog resources
+49770e000 test(catalog/mem): sort CSVs returned by version
+59f555dab chore(catalog/mem): update data types
+2f5c2cac1 test(catalog): simplify tests
+1308bb5f8 doc(catalog/mem): update comments
+ed4418e49 feat(catalog/manifest): add loading manifests from file
+d70c252ac test(catalog/mem): test basic catalog fns
+3b2415ab8 Update regex for resolved etcd cluster
+15eabb81c Fix tests
+c005f8902 Update etcd resource permissions
+88ebc7ae0 Fix sync
+d1db0d1e6 Remove unused config mount
+38446bce4 Fix rebase
+e2b17ea35 Dob't create serviceaccount if it already exists
+a704f37bb Fix role creation
+bd53114a3 Log error when install fails
+4c77cb46a Validate that example CSVs can be parsed into CSV type
+1db49526d Rename capability -> descriptor
+f154e458d Add implementation of permissions generation for CSVs
+0c1237352 Add permissions block to install strategy on CSV
+6c62f169d Update CSV types and parsing to match new CRD description design
+c0c199f58 Move labels -> template/labels for CRDs
+0c1cb783a Rename x-alm-capabilities -> x-descriptors
+3d664e2d0 Move output definitions to CSV and move output values to status block
+6dbcd1c3d operators/alm: replace config map with flags
+e7dcc1689 ci: add missing pre-step for catalog
+778a6a9e0 helm/gitlab: add new deployment for catalog
+bf2fde6d3 operators: init installplan operator
+a37d12678 installplan: fix inconsistent samples
+886fa6435 Update etcd installplan to match schema
+080361953 chore(catalog/mem): update fns for mem catalog
+6f75a2c0f refactor(catalog/types): shorten interface fn names
+4b742e819 temp
+8e74e359f refactor(catalog): embed ClusterServiceVersion spec in AlphaCatalogEntrySpec
+dd3f07b90 feat(catalog): map CSVs to the versions they replace
+68071da7b style(catalog/mem): use variadic fn arg variable names
+f261fccda refactor(catalog): rename in-memory golang maps catalog implementation
+0debb3a0a refactor(catalog): rename fn to remove ambiguity
+7d8b19e5f style(catalog/mem): order import blocks
+0288a79ba style(catalog/mem): use explicit key/vals for struct
+099d721c3 refactor(catalog/mem): remove sources subpackage, enforce interface
+5aa5f294d feat(catalog/sources/mem): add simple catalog implementation
+3265de347 installplan: add types for Install Plan Status
+1144aabfe Fix rebase
+5d751fcad Fix rebase issues
+1b20c558a use return instead of break in switch
+b257b7f0a Fix icon parsing
+87706f290 Add full state transition tests for clusterserviceversion status
+595593b10 Refactor phase transitions for clarity and testability
+b36cc7ec7 Update codegen
+95f6fd6db Fix typos
+a6c96bd86 Fix CSV type (deprecated fields)
+3e3a65b32 Add missing return from phase transition caused double install
+052910bb2 Use switch for phases
+3fba6d318 Check if deployment is installed before attempting install
+b47c5af16 Update etcd cluster crd to be versioned
+c3e42f555 Adds a state transition test
+14ceef52a Add mock alm operator for testing
+f1a980d87 towards a mock alm operator
+23e510c90 Write conditions to status during state transitions
+bcf7ad8dc Add conditions as a history of state transitions to csv status
+a9b5df197 Resolve rebase conflicts
+e1e23bf4d Write requirement status back to status block
+43344c92f Cleanup phase transitions
+128b9726b Only check for CRD existance
+74805fb08 Update gitlab pipeline
+8920a0828 sketch out phase transitions
+ee5c9bb50 Check for phase before attempting to install
+ddd75b83e Add ClusterServiceVersionStatus
+6948be17b Add schema for ClusterServiceVersion status
+c333b65c2 Look for requirements in same namespace as ClusterServiceVersion is defined
+84e2cadea Move config handling to its own package
+1961aa00b doc(vault.alphacatalogentry): fix sample name
+3b41d59cf fix(alphacatalogentry): regen code for alphacatalogentry types
+ef1dc178a fix(alphacatalogentry.crd.yaml): add names
+7a8580f66 doc(catalogsource.yaml): remove example catalogsource resource defs
+672a1efe0 doc(vault.alphacatalogentry): add vault catalog entry example
+bdb8d0262 doc(alphacatalogentry.yaml): create CRD yaml
+a3b1fa2c2 feat(alphacatalogentry): add provider field
+f3dfa01b1 refactor(apis/catalogsource): remove for now
+5e45d1ddb doc(catalogsource): remove extraneous comment
+94454bfac refactor(apptype->alphacatalogentry): rename crd for catalog
+452439011 feat(apis/apptype): add back in apptype crds
+7c2500b22 chore(catalogsource): only have one url per src
+13c2fc89f feat(catalogsource): update spec for console to consume
+409a9aec5 feat(apis/catalogsource): add new CRD for catalog
+cfd483677 style(catalog/mem): use variadic fn arg variable names
+fd6a29639 refactor(catalog): rename in-memory golang maps catalog implementation
+b76868e00 refactor(catalog): rename fn to remove ambiguity
+bfc0ed0ac style(catalog/mem): order import blocks
+623569bbc style(catalog/mem): use explicit key/vals for struct
+e80807a54 refactor(catalog/mem): remove sources subpackage, enforce interface
+915bd0e1e feat(catalog/sources/mem): add simple catalog implementation
+be31fa525 gitlab: run glide install in test stage
+137aa0d4c Revert "Merge pull request #86 from jzelinskie/ci-uniq-base"
+c9c63b6fd feat(alm,install): adding in owner reference to deployment
+9a58d6bbd gitlab: base image now unique per git ref
+a4bd736e6 Add tests to validate object metadata
+8c39859d9 csv: add json tags to CRDs
+6236f0e0f init Required/Owned CRDs for CSVs
+dd1fc7224 fix(cmd): fixed config parsing
+2ab07117f fix samples to reflect new updates
+7f5e83fd6 Rename InstallDeclaration -> InstallPlan
+ef30e8282 fix validation of approval types
+fd12b8680 remove apptype from codegen
+96d8df57c add initial ownedCRDs field to CSV
+657431f7d fix apiVersion for etcd installplan
+ac3d76d32 move Approval type into installplan
+c73543aba add dashes back to apigroups
+bfac2fbef add install plan validation
+44205bd66 subscription: fix apptype references
+95757422b fix inconsistencies
+59908332b capitalize approval types
+22aee6531 s/update only/update-only/
+448bfb4a7 s/desired// && s/cloud/cluster
+53450305e installplan: add approvals
+21b885bb5 installplan: add RequiresReview status
+55c455202 samples/installplan: remove inconsistencies
+b25b67b67 installplan: refactor status
+1f612577f installplan/v1alpha1: add spec
+284b2855e installplan: add status.status field
+35fe128ba samples: add status for installplan
+f7c4bef81 init installplan
+5616422e2 Remove AppType and merge its fields with ClusterServiceVersion
+e3a0a62fa Merge apptype into clusterserviceversion (examples only)
+d3b58016b Remove namespaces from requirements
+09216cec7 refactor(catalog/mock->catalog/sources/mem)): organize catalog types
+bf6b79575 feat(deploy): add in config map
+1c92f598c fix merge of namespacing PR
+84ba58a64 feat(alm): adding in namespace list support
+5a0de06f9 refactor(client/{opver->clusterserviceversion}_client): rename file
+7a7946d3d refactor(catalog->planner): rename component
+b5d4834bf refactor(appcache): use new crd name ClusterServiceVersion
+1b1e687db refactor(subscriptions): change pkg name and remove unused mock
+d160ebab9 feat(appcache/mock): add simple implementation of appcache interface
+02ecf1055 refactor(appcache/types): use simpler name for interface method
+104b78717 wip(subscriptions): remove logic for now
+78be96063 refactor(subscriptions): rename to installplan
+9d9b80e0d feat(apis/catalogsource): remove for now
+ae62b493a rearrange(subscriptions): move out of catalog pkg
+2b632f60b feat(catalog/types): simplify interface
+52e30a2e5 feat(appcache): add interface for app catalog cache
+e8f97bd4f rearrange(apis): rename installdeclaration as installplan
+4c68167f5 feat(catalog): use k8s typed objects
+48d445803 feat(hack|apis): codegen new types
+9bbf19ceb feat(apis/installdeclaration): add installdeclaration crd types
+0d1cb901d feat(apis): add catalogsource crd type
+64b3e75bc feat(apis/subscription): add cdr structs
+d6b347f4a fix(catalog): fix type inconsistencies
+b474582d9 test(catalog): finish memCatalog mock implementation
+1e1237cf6 fix(catalog): change fn arg to ptr type
+77508acac doc(catalog): comment on functions
+57701228f doc(catalog): add comment on temporary type decl
+7bbebc1d9 refactor(catalog): move resolve dependencies to catalog interface
+6907f970a test(catalog/subscribe): add empty test file
+43cef7d4e WIP(v2 catalog): update for new control loops pt 1
+93889211d WIP(catalog): sketch out loop ops
+01bbf53a7 Fix tests
+2306e06bd Fix apiversions and naming
+a14e729ad Add prometheus example (has multiple resources)
+d1909e888 Add a newline
+e435bf229 Namespaced examples
+87ddda3ff WIP namespace samples
+ae2a89c1c Don't install self-hosted in install instructions
+88679b971 Namespace alm
+57050f3ea Fix api versions
+edd50d350 Inline instructions
+42564ac66 Update etcd examples
+3b9087d1e Fix etcd operatorversion sample so that pod starts
+601c01cfc update samples for UI testing
+00f73ba96 Add sourceType and secretName to CatalogSource
+9c46f2eec Add example resources for Subscription and CatalogSource
+b9fa8a7c9 feat(alm): added in check for requirements
+7634b012c Fix deployment test
+e4cefe9fd Rename operator -> queueinformer Add queueinformer registration function
+4d4cfcd71 Rename ControlLoop -> QueueInformer
+27dee133c Formatting fixes
+34bc9b9c1 Add codegen for runtime.Object deepcopy methods
+d8b31dc44 Factor out common operator functionality into a parent Operator and ControlLoop object
+e5f426c05 Move opver client to its own package
+d4a120632 Refactor install strategies
+f4c675e25 Move opver api registration to apis package, rename alm.go to operator.go remove unused interfaces move apptype type declarations to their own api package
+351b067f7 init v1alpha package for OperatorVersion
+616171c79 doc(control-loops): fix typo
+af7d58c96 attempt to fix dependencies
+420b8cd61 Update control-loops.md
+bfc715d42 Update control-loops.md
+d3f2256d5 Update control-loops.md
+41728518d makefile: add -i flag to `go build`
+782baa0ab Add testing framework for testing sample resources
+a1ae656f0 glide: update operator-client
+8d4624350 rename operator -> installstrategies
+3ad865fa9 Check for existing managed deployment before installing new one
+69d550261 Remove vendor from `make build`
+f4a007d8f Update gitlab
+1aeb4ca32 Add hack for GKE plus some formatting fixes
+bdf97f20b Fix imports
+9d736e7ff Add logs on successful install
+df9d353f0 WIP: can't use unstructured for subtypes
+c325aa295 WIP: can't use unstructured for subtypes
+1d7f07269 Register ListKind properly
+38d739125 Add api registration for operatorversion
+865a592b2 Create a new client for watching OperatorVersions
+beb27a9c2 Fix watching operatorversions
+c6e95ead5 Fix operatorversion reference
+3315b7a93 Install OperatorVersion and AppType before ALM
+9de7b0b09 Fix serviceaccount
+d71bf92ea Fix merge conflict in operatorversion
+c058bdb08 Add CRDs and serviceaccount to helm chart
+5cc44ed72 Control loop runs install strategy Also `cmd` will run operator
+99f55c397 Gitlab-ci with jsonnet lib
+9836a8d72 Update helm-chart
+34f52bfd0 Add deepcopy methods to `OperatorVersionResource`
+af9689681 Fix glide.yaml
+caa783ffe Add WIP glide
+cbb514e94 Add coreosbot credentials
+6f1e38f34 Vendor before test
+5f4d2a5ba Fix dependencies
+b8eef3d5e doc(scheme/loader): comment on function not for prod
+0b1d069a2 style(installers): format imports by type
+0ec025daa rearrange(installers): organize pkgs better
+935080fcb feat(schema/loader): add util to load CRD from file
+855531003 feat(operatorinstaller): add initial deployment strategy
+593e79bd7 rearrange(alm/types): remove unnecessary interfaces files
+7104b537b Add install strategies
+3860743bf Update example.vaultservice.yaml
+0e81b93f1 docs: update walkthrough with validated resources
+df7cc0969 Change replaces to a direct resource reference instead of a version
+b1cc63cf8 Better formatting for outputs
+9a879da4b Add displayName to outputs
+acd595d98 Move outputs to an annotation and add displayName and description
+6c13d7fb8 Add install instructions and make samples kubectlable again
+efaf40012 feat(alm): adding in basic operator version watch
+c78b1965e Change to `alm-owner-`
+49cd41cf8 Add labels to propagate in addition to labels to match
+c5a11eb2d Add labels for AppType
+f1a592e30 Add labels and selectors
+b4fc772d8 add  field to examples
+9de811b72 fix apiVersion in samples
+8e6304655 Update loops
+835248845 Remove ALM-managed upgrade option
+29dee2f52 Fix typo
+73df421db Split loops by piece of software, and add upgrade and GC loop descriptions
+c6887f77d Add explicit creation note to `AppType` loop
+c28ea2367 Update control loops to match newest design
+32a8b2e87 Add reconciliation loop docs
+3bd81fd43 Fix invalid CRDs and CRs
+b86a6b0e8 docs/design: init walkthrough
+2314078fd Remove blocksInstall from examples
+5c90effc8 Depend on `CRD` not instances of CRD
+91ad56094 Fix etcdoperator operatorversion
+996790f43 fix almoperatorversion formatting
+fe5b5d8b6 Fix formatting on etcdoperatorversion
+067405b53 Update vault example to use new requirements format
+f3cc3d2ba Update etcd operatorversion to match spec
+e6dc168a3 Update operatorversion spec and alm.operatorversion.yaml
+9b14af09e Add UIDs and update apiVersions
+0c2820412 Add status and ownership to etcd sample
+5a1594026 Move the examples back under their directories
+890a12a24 doc(DEVELOPMENT.md): outline glide and make usages
+85bacad09 fix(vendor): go back to glide for golang dep mgmt
+7b2a2bde3 style(alm/types): use golang conventional func naming
+8d4769d71 fix(.gitlab-ci.yml): pull correct image
+2a5e74818 fix(values.yaml): moved from quay to coreos
+65bff4625 fix(.gitlab-ci): put in sha at wrong place
+2ecd4effd fix(.gitlab-ci.yml): remove except branches
+21ba3b24f chore(.gitlab-ci.yml): add in deploy staging
+72075931d Put `example.` prefix on example CRDs
+1c1eabd36 Add vault sample
+f4c111e8f Move etcd samples into their own directory
+8b5e23e76 cmd/alm: init
+ab40c950f Fix merge and add important.link capability
+cafd7feb7 Add sample etcd cluster instance
+b7ee33a2c Add sample outputs
+86a24dad4 Add sample proposal for metrics and links as outputs
+d129b2c3f Fix rebase issues
+cd49d2338 Update requirements version
+b88ee5766 Model RBAC requirements as requirements
+4ba6e2cbf Add example for including cluster features as requirements
+071dc0c94 fix(alm): consolidate apptype cr creation
+5675cf344 chore(Gopkg.lock): update dependencies for interface tests
+fd818310f test(alm/interfaces): add basic unit tests
+ca804421f feat(alm/interfaces): define alm functionalities in interface
+a165ea80c chore(godep): update dependencies
+c4e8db891 feat(alm/types): add type schemas
+3ed37b792 README: init
+a0f5b96c0 docs: move design work into Documentation directory
+f8582bc39 chore(Makefile): set up Makefile for test, builds
+64dac2e4c fix(.gitlab-ci.yml): stop ci build on master
+f0713bda1 dep: init
+1e05a0449 chorse(.gitlab-ci.yml): add in manual deploy of branch
+859e15347 Add schema examples
+0cddacb97 Switch to the proper JSON field name for the schema https://github.com/kubernetes/kubernetes/commit/6133d84835c59f157a8fb4596f98d2d3cf828bef#diff-3029a18192feb70af52de676209da9b6R149
+62734f345 Make the icon information embedded and more strict
+9d4ec1969 Add schemas for the initial resource types that ALM will manage.
+62ab83d68 chore(deploy): add in health check for k8s
+15c381352 feat(deploy): added in basic helm chart
+2e086d0ba fix(misnamed from): adding in golang
+129c0426d chore(.gitlab-ci.yml): Adding in basics for ci
+7b20d7108 chore(.gitignore): Added in a basic gitignore
+0ea751807 Add ALM mocks
+eca4f1566 Check in the original propsal README as a straw man.
+ddfdf72e3 initial
+5503a2a58 scripts: Update the scripts/generate_crds_manifests.sh
+f1dbd0d07 Makefile: Add additional verification checks to the verify target
+fb555af8c scripts: Introduce a script that ensures nested modules are up-to-date
+65ceea044 Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-registry.yml
+f92115001 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-lifecycle-manager.yml
+199f2b6a6 .gitignore: Ignore the sqlite journal binary files
+34318f9a0 Add verify target to Makefile.
+da3e496c6 Add IBM managed cloud profile annotations to manifests
+1a571a501 correct top level files and vendoring
+5a5d31a22 Remove overrides for GOOS and GOARCH in cpb Makefile recipe.
+773c28855 Makefile: Use the full git commit hash when building binaries
+96b6cc3da base.Dockerfile: Bump the Go base image to use a 1.16 tag
+24c413998 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-lifecycle-manager.yml
+a0c9ca7f4 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-registry.yml
+2543e6035 Dockerfile,Makefile: Add opm binary and cross compilation target(s)
+08daeb0ab remove top level deploy, crds directories
+17bd9976e add crd and manifest generation
+aa5df6359 Makefile,Dockerfile: Add additional registry and OLM build targets
+73d36e080 scripts: Address markdown violations in the README.md
+a6cc02add cmds.go,vendor: Introduce the non-opm registry binary packages
+a5c25b3de scripts: Check if the vendor directory needs to be populated first before running e2e packages
+e05ed8f90 scripts: Avoid hardcoding the test e2e function called
+785ec7b2f Makefile: Update the e2e-related targets
+2d2b03f39 README.md
+39717cadc Use staged tests
+aa1b622be Update scripts to track specific commit
+633072a36 scripts: Update the unit.sh helper script and populate the nested staging directory
+495385b84 Makefile: Introduce additional test targets
+e99ac9167 scripts: Introduce an e2e helper script
+3c4fb81ca Dockerfile: Copy the entire repository while building binaries
+75238ed4d Update the base image for the operator-registry image
+ba7683370 WIP: Update root Dockerfile(s)/Makefile to build downstream images
+3c6897fe6 .gitignore: Ignore nested staging vendor directories
+69ef1b59d Add the package-server to the list of local command packages
+13d97c031 Makefile: Add build and basic test targets
+f4cc0f1ef Introduce cmds package that tracks the staging operator-framework directories
+9269b835c Makefile: Reduce the number of targets
+5f5016efa scripts: Add unit test helper scripts
+1ac24811e Dockerfile: Avoid hardcoding the kubebuilder version in multiple places
+e4e7f4fb5 Dockerfile: Avoid using the registry.svc.ci container registry
+d4cf305d3 *.Dockerfile: Manually bump the image tags to 4.8
+1c272ee39 Add root .gitignore
+fa34d3f53 Initial commit
+84f6a5c15 Revert everything back to the initial commit
+7de770d3f Merge pull request #109 from timflannagan/remove-doc-dir
+087ba82f6 Remove the doc/install directory
+121f35e9d Merge pull request #106 from anik120/registry-liveness-probe
+b165a4cd7 Bug 1976326: fix configmap registry server liveness probe timeouts
+2a45f5230 Merge pull request #95 from timflannagan/update-verify-check
+e6894b43f scripts: Update the scripts/generate_crds_manifests.sh
+f0b75da18 manifests: Update PackageServer CSV YAML manifest with re-generated keys
+3fa2fc48e Merge pull request #103 from benluddy/bz-1975824
+76d53422c Resolve InstallPlanStepAppliedWithWarnings alert after some time.
+c6208b0b0 Merge pull request #100 from timflannagan/update-owners
+3dec0fb30 Makefile: Add additional verification checks to the verify target
+db4bb2c0e scripts: Introduce a script that ensures nested modules are up-to-date
+ccd5a62e7 OWNERS: Add additional reviewers
+e7f18ff88 Merge pull request #97 from openshift-bot/art-consistency-openshift-4.9-operator-registry
+48534ab06 Merge pull request #98 from openshift-bot/art-consistency-openshift-4.9-operator-lifecycle-manager
+a4f1f3b83 Updating operator-lifecycle-manager images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-lifecycle-manager.yml
+4c14d475c Updating operator-registry images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/691e628254f318ce56efda5edc7448ec743c37b8/images/operator-registry.yml
+f25f670c0 Merge pull request #92 from dinhxuanvu/opcon-gen
+659bac3c6 Merge pull request #90 from awgreene/bz-1950047
+4327486a3 Update OperatorCondition CRD in manifests
+8a3545331 Address various issues with OperatorCondition codebase
+56d5faa1d Update OperatorCondition Role and e2e test case
+06fb38628 Add OperatorCondition status sync and update operator upgradeable check
+6156d25a1 Regen go-bindata for crd changes for OperatorCondition (#125)
+952306bbf Add ConditionType to v2 api (#123)
+927e6bba2 Add conditions array to OperatorCondition's spec (#119)
+59934e50e Merge pull request #85 from benluddy/bz-1958296
+d19ffb361 Fix Template Annotations on Webhooks/API Service CSVs
+41991c626 Merge pull request #88 from benluddy/bz-1968700
+44c25e24c Merge pull request #86 from njhale/fix/xattrs
+4b4a76318 Fix nil pointer dereference while reporting bundle unpack status.
+da96f3dcd fix(containerd): drop xattrs during unpack
+1adb4495a Merge pull request #84 from vrutkovs/cvo-hotlooping
+220c152f8 Surface API server warnings when applying plan steps.
+78d224c4e Bump kind dependency to v0.11.1.
+afcaa062b packageserver CSV: add missing properties
+ca1f0b69c Merge pull request #83 from hasbro17/fix-ssa-error
+0e9f3bffa Merge pull request #82 from joelanford/bz-1961472
+365495eae Filter secret names for registry pod's sa
+9557387ca Explicitly set `readOnlyRootFilesystem: false` on created registry pods.
+4a318fee1 Merge pull request #81 from benluddy/bz-1959158
+d3b5c5bc4 Merge pull request #80 from anik120/catsrc-metrics
+8b1eb28aa Make ClusterOperator Available condition sticky.
+b133dce55 Merge pull request #79 from joelanford/bz-1961314
+030b4afe5 Merge pull request #67 from gallettilance/sync
+2281ea529 (bug) add after deprecation
+630cc8e04 vendor changes to metrics(catsrc) from of/olm
+625b70006 use snake case for catalogsource_ready metric
+406828629 Call cleanup sync.Once.Do
+82dc386c4 feat(metrics): Emit metrics for CatalogSource state
+c1e3716e0 fix race in test with mockRepo/mockBlobStore
+ac7c85de0 Merge pull request #75 from benluddy/bz-1947946
+5b9124dfa Merge pull request #76 from benluddy/bz-1958285
+0b7700ee0 Merge pull request #78 from hasbro17/bundle-unpack-timeout-bz
+a5f4f3bf6 Merge pull request #77 from timflannagan/fix-packageserver-delegated-auth
+fdbcd8e1f Annotate CRDs that are installed alongside CSVs.
+b1923328c Bump ginkgo to v1.16.1 and gomega to v1.11.0.
+b7a83ec5e Add eventually to e2e test crud operations
+79616b38d Add unit test for varying job timeout
+ce892120d Add unit tests for UnpackBundle
+cc3e38e0f Parse timeout annotation before UnpackBundle()
+86976b0bb installplan e2e test fixes
+51d65b188 Add annotation to override default timeout
+805d22917 Check for bundle unpack failure via status conditions
+0f2dff6d2 Cleanup e2e tests and add case for invalid bundle image
+782238935 Fail InstallPlan on bundle unpack timeout
+b0798d0aa fix(packageserver): add tolerant delegating auth config
+f82e4e14b Merge pull request #74 from ankitathomas/bump-apiserver
+44c8bea85 pinning apiserver for delegated authentication watch request bug fix
+d29099fba Simplify deployment status check to reduce flapping.
+9498948b6 Merge pull request #72 from anik120/packageserver-co-message/reason
+9ec5651af Bug 1955761: Set reason/message for Available condition in packageserver co
+69fbfdf2d Merge pull request #70 from ecordell/cr-valbug
+24d012397 Merge pull request #71 from dinhxuanvu/config-alpha
+6eacf7ffa Move config serve and validate to opm alpha
+fa23e819c bump kube-openapi to get validation fix
+d9201a5c2 add unit test showing cr validation bug
+cabb2c9bb Merge pull request #68 from benluddy/bz-1945443
+d44d9fd80 Use DeploymentAvailable instead of custom test for CSV status.
+1751d4a12 Merge pull request #61 from lack/management-workload-annotation-rename
+531b8b6a0 Merge pull request #56 from timflannagan/bump-k8s-to-v1.20.6
+9fa1f1249 Merge pull request #65 from anik120/termination-policy
+7cf3faad6 go.*,vendor: Update the Go module version and re-generate root vendor tree
+e50564af0 .gitignore: Ignore the sqlite journal binary files
+15cadfada staging/operator-registry: Bump the k8s dependencies to v1.20.6
+b3227bd0c staging/operator-lifecycle-manager: Bump the k8s dependencies to v1.20.6
+35090f520 Merge pull request #62 from dinhxuanvu/olm-resolver-events
+d552bf9cb Bug 1952238: Report catalog pod termination logs to catalog operator on exit
+3440fa2c1 Merge pull request #64 from benluddy/verify-makefile-target
+1a4a2176a Merge pull request #63 from joelanford/bz-1937097
+701e2a0b3 Add verify target to Makefile.
+49bcc3eb1 Add unit test to verify resolver error handling for sync namespace
+0083d6a7f fix(catalog): Reduce namespace resync in resolution failure
+c227a5117 Add retries when pulling images
+21fbc6ac4 Merge pull request #60 from benluddy/bz-1942522
+8281e2926 Rename workload annotations
+85f8278d5 Fix resolution error if inner entry doesn't provide a required API.
+ec8be6157 Merge pull request #42 from lack/management-workload-annotations
+2df1ac175 Merge pull request #55 from kevinrizza/bundle-unpacker-resource-requests
+b35304d6b Add management workload annotations
+9d2fc1f57 vendor staging updates
+8831a0457 Add resource requests for bundle unpacker
+8c384e081 Merge pull request #53 from joelanford/fix/subscription-env-merge
+e0b47b0f4 Merge pull request #50 from csrwng/roks_profile_patch
+03e31a8ab Merge pull request #41 from timflannagan/bug-preserver-existing-sa-owner-refs-install
+e3a385f7a vendor staging updates
+f0c181d0e fix merging envvars from subscription.config
+e6b5fdf7c add failing test for merging envvars from subscription.config
+873f908ed Merge pull request #51 from timflannagan/revert-sno-packageserver-bug
+f08b0a629 Revert "set packageserver replicas to 1 for single node"
+fcc049e3b Add IBM managed cloud profile annotations to manifests
+b5814a0b1 Merge pull request #47 from timflannagan/registry-sync-declconfig-updates
+840f00345 staging/operator-lifecycle-manager: Update go.sum after running 'make vendor'
+a66dfa929 Preserve existing ServiceAccount owner references during installs.
+bdc74e956 Merge pull request #49 from benluddy/ip-retry-sync
+f9f580dfb Resync manifests with latest sync of staged OLM.
+8240f5c3e Update upstream tracking commits.
+bb9c47fdc Revendor for staging/api v0.8.0 sync.
+8a474173c Add .status.message and .status.startTime to InstallPlan. (#108)
+b7a62ba82 add checks for operatorhub validator (#103)
+ee94e8d34 Update OWNERS (#107)
+454234f12 Add skips & relatedImages to CSV Spec
+8ebe01432 Add optional go-apidiff test to CI
+673453383 Revendor after latest staging sync.
+25a783253 Always validate CR upgrade compatibility.
+a56ab3a97 Add time-limited retries to InstallPlan execution.
+def4a723b Bump github.com/operator-framework/api to v0.8.0.
+56d0f84f7 Re-generate vendor after cherrypicking commit(s)
+5c8db0aec Improve the declcfg and model validation
+deed5877e feat(validate): Add opm validate cmd to validate config files
+647c5a164 Delete the symbolically linked operator-registry.Dockerfile
+b0f60a570 Add tests and fix bugs for declcfg server
+385b96773 Merge pull request #45 from timflannagan/registry-sync
+91d03b25e Merge pull request #46 from timflannagan/olm-sync
+8c413c3f6 Update root vendor and staging/OLM go.sum
+e45356ed7 go.*,vendor: Bump to k8s v0.20.4
+d87c907d4 Remove more testify assertions
+38cc76f72 Fix e2e test with incorrect gomega matcher and remove testify usage
+ca3266e14 Copy all CatalogSource annotations to its Pod
+eabc62d9b Consider InstallPlan phase=Complete as terminal
+007621c06 Give more precise reasons for Subscriptions with no candidates.
+35fc7ef79 Clarify status condition error message, and update architecture docs
+67296298f Add e2e tests for installplan failed on invalid operatorgroups
+16e685b2c Indicate invalid OperatorGroup on InstallPlan status
+de697a364 Merge pull request #44 from ecordell/no-adopt-copies
+2e3a7fe5a Merge pull request #40 from timflannagan/bump-k8s-root-go-mod
+c97146c19 go.sum,vendor: Run 'make vendor'
+df6f50605 Purge staging/operator-registry/vendor
+263f2e708 add server for model.Model
+f981968b8 .github: Separate the jobs in the test workflow into their own workflows
+de1e8a3a2 use equalsDeclarativeConfig function in load_test.go
+adb078ecb move newly introduced packages to internal
+3d19f70e6 declcfg_to_model.go: ensure package field and property align
+185cd9e8b pkg/(declcfg|property): PR review feedback
+da9688ffe Avoid stuttering "mkdir <dir>" errors
+7c021e36c feat(declarative config): add base packages
+06868cb4a bump vendor
+11bb700a4 disown copied csvs
+3466dbbff remove component labels when copying CSVs
+312b92016 test that the operator api never adopts copied CSVs
+f9fbc30ab go.*,vendor: Bump the k8s dependencies to v0.20.4
+fc92cb718 Merge pull request #38 from ankitathomas/operator-lifecycle-manager-sync
+fad0f266a Merge remote-tracking branch 'main/master' into operator-lifecycle-manager-sync
+2cea7f3c5 Merge pull request #39 from timflannagan/fix-olm-unit-tests
+964b2a6df Merge pull request #39 from timflannagan/fix-olm-unit-tests
+c00da97d0 correct top level files and vendoring
+5f87deb2c Merge pull request #1653 from yeya24/add-CsvAbnormalReplacingOver30MinSRE-alert
+50ce93ede Merge pull request #2075 from benluddy/bump-kind-v0.10.0
+d251e7e0f Update 0000_90_olm_01-prometheus-rule.yaml
+28c2ab77c Bump test dependency on kind to v0.10.0.
+eca9859ae Merge pull request #2062 from ankitathomas/single-node-packageserver
+47d8851a8 Merge pull request #2061 from timflannagan/avoid-hardcoding-kubebuilder-version
+a04d7d223 Merge pull request #2068 from benluddy/inconsistent-candidate-order-with-csv-in-two-channels
+1b75db8ca set packageserver replicas to 1 for single node
+343325d7e Fix inconsistent dependency candidate order.
+78407c21f Merge branch 'master' into avoid-hardcoding-kubebuilder-version
+f3430d1f8 Merge pull request #2070 from sathieu/patch-1
+733cc390f Allow to override download url in install.sh
+b494ac1e1 Merge pull request #2047 from timflannagan/avoid-graceperiod-delete-zero
+83c0c5daf Merge pull request #1937 from horis233/update-pr-template
+8e798b6f4 Merge pull request #2060 from timflannagan/go-1.16-bump
+26387563c Merge pull request #2064 from timflannagan/add-ci-dockerfile
+caf72b787 Dockerfile: Add a symbolically linked release Dockerfile
+0d654f80a go.*,vendor: Bump module Go version to 1.16
+70642817a Dockerfile: Use Go 1.16 image tags
+bd5bfe089 Merge pull request #1817 from jeyaramashok/1774-csv-hotfix
+de317b4b4 Dockerfile: Avoid hardcoding the kubebuilder version in the build root image
+2d7e0292b Merge pull request #1936 from horis233/update-og-doc
+0daaa46f4 Merge pull request #2054 from dmvolod/issue-1522
+9c46d43fa Merge pull request #2058 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager
+417a1853c Merge pull request #2059 from timflannagan/remove-duplicate-apierrors-package
+a93f726a2 test: patch existing CSV for a hotfix
+d5b23bc06 test/e2e: Remove duplicate package imports
+f728dacf0 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-lifecycle-manager.yml
+552bbb54a Merge pull request #2055 from timflannagan/fix-trailing-slash-module-tools
+c5321a5f2 Merge pull request #2045 from camilamacedo86/remove-ch-name
+5443887a7 Set labels for the operator Deployment created via the ClusterServiceVersion
+c13365df1 Merge pull request #2048 from benluddy/operator-framework-api-0.7.0
+aa7fb08fe go.sum: Run 'make vendor' locally
+a083c072a tools.go,vendor: Remove trailing slash in github.com/go-bindata/go-bindata module
+7d3c1de4a pkg,test: Avoid setting metadata.GracePeriodSeconds to zero seconds
+98b8f42c1 Bump github.com/operator-framework/api dependency to v0.7.0.
+a8f961074 doc: moving channel naming doc to website
+5c6a9c6da Merge pull request #2044 from exdx/fix/exempt-labels
+af8265057 Merge pull request #1999 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager
+5cc05a212 fix: add lifecycle/frozen tag to exempt list to stalebot closing certain issues
+29573edff Merge pull request #2025 from benluddy/small-jitters
+743495e91 Merge pull request #2024 from joelanford/fix/upgrade-alert
+980537c37 Support jittering relatively small resync intervals.
+d225f6beb Merge pull request #2029 from benluddy/sa-present-when-owned-by-non-csv
+12ff8606a Allow non-CSV-owned ServiceAccounts to satisfy CSV requirements.
+4eabd3d28 Merge pull request #2010 from joelanford/fix/dep-resources
+36dcb5461 don't change CSV phase on service unavailable error
+9c9a0a0c0 Gracefully handle service unavailable errors from kube-apiserver
+23d4ea963 only override deployment resources when explicitly defined in subscription.spec.config
+ba3182516 Merge pull request #1993 from benluddy/package-name-inference
+b68402260 Merge pull request #1972 from jchunkins/modify_makefiles
+710b0dc04 Infer package name property for unannotated CSVs, if possible.
+d6133be3b Merge pull request #2016 from joelanford/fix/operator-controller-test-flake
+60906a102 pkg/controller/operators/operator_controller_test.go: fix flaky test
+0779756bb Merge pull request #1828 from zkyle95/master
+27f495475 Merge pull request #1834 from errordeveloper/enable-debug-messages-via-klog
+148100ca8 Merge pull request #1886 from cfergeau/single-node-developer
+d1fc78db8 Merge pull request #1863 from jeloba/dont-create-default-service-accounts
+5de59e426 Merge pull request #2012 from joelanford/go-1.15
+4bfb7b529 Merge branch 'master' into modify_makefiles
+b744a8106 bump to go 1.15
+1bb711dc9 Merge pull request #1846 from awgreene/release-md
+7e4f4b003 Merge pull request #1882 from horis233/update-developemnet-docs
+038151010 Merge pull request #2011 from njhale/fix/adoption-log
+195ce72f3 chore(adoption): use debug level to log missing components
+bcb80ada7 Merge pull request #1951 from dinhxuanvu/pinned-skips
+e7ae0eef4 Merge pull request #1965 from nikhil-thomas/fixes/doc
+00c73acff Merge pull request #2005 from ecordell/benluddy-nicer-invariants
+5c23b7c92 Merge pull request #1986 from awgreene/update-OWNERS-file
+09e406869 Correct timflannagan GH ID on ownerfile
+04c08702e fix(resolver): Allow skipped versions to be installed initially
+659a9e517 support multiple subscriptions resolving the same bundles
+710a3784e add package property to unit test cases
+e77fb17e6 collapse resolver tests
+3de932b82 Add meaningful string representations for resolution invariants.
+7b82f2192 Update OWNERS file
+7c710f373 Merge pull request #1995 from awgreene/operator-group-doc
+32d3d89de Merge pull request #1958 from ankitathomas/apiserver-version-bump
+50dfff447 bump k8s.io/apiserver for webhook auth panic fix
+0cc658399 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/5a1293dd0f380abf50c12d65c36655486d7745d0/images/operator-lifecycle-manager.yml
+c18f87a40 Fix OperatorGroup Documentation Example
+59e29f836 Merge pull request #1990 from benluddy/subscription-constraint-strings
+a63ae05d5 Merge pull request #1938 from joelanford/fix/zombie-operator
+0416116c5 Clarify subscription constraint strings in resolution failures.
+7b1731d86 Merge pull request #1974 from hasbro17/fix-csv-status-time-comparison
+2e989308f Merge pull request #1982 from benluddy/continuous-registry-resync
+785fb9829 Fix zero-delay resyncs for certain registry update policies.
+086c4ba07 Merge pull request #1983 from benluddy/test-minikube-driver
+3a7c42980 Use docker driver for minikube installation test.
+2a283a382 Merge pull request #1975 from exdx/fix/stalebot
+c51a83df7 fix: improve stalebot configuration for github issue tracking
+dc7829327 Additional changes based on feedback
+51dfe457b Changes based on PR feedback:
+c89e1c655 update makefile, workflow, and docs
+e8e768ecb Fix time comparison in CSV reconcile loop
+e212f002c Merge pull request #1966 from benluddy/replacement-chain-cycle
+af5cb8b6a Fix infinite loop when a CSV replacement chain contains a cycle.
+5bad05410 Fix typo in docs
+3a6bab227 Annotate manifests for single-node-developer cluster profile
+75309020f Update shields
+85ef01a85 Merge pull request #1941 from anik120/job-secrets
+a047501de Merge pull request #1942 from awgreene/operatorcondition-controller-watch-deps
+15436e9ca Merge pull request #1888 from exdx/fix/scoped-install
+cd3130cd4 fix: create installplan directly in e2e test
+0971e280e fix: use OLM client when installing CRDs
+a6506b568 fix e2e test order
+380872d59 Address comments from PR review: added e2e, improve unit
+04c8fd442 Update OperatorCondition controller to watch deps
+3e766cbe8 Merge pull request #1948 from joelanford/joelanford-reviewer
+4795635cb Add joelanford to OWNERS as reviewer
+6b8d6b799 operator_controller_test.go: use JustBeforeEach to ensure correct test setup order
+891a1ee64 Only re-create operator resource if it has existing components
+cac4593b9 Add unit tests for Operator controller deletion handling.
+f5925b55c Merge pull request #1943 from awgreene/initialize-deps-with-opcond-name
+16ae6c26b Create CSV Deployments with OpCond EnvVar
+fbc4c77cc Bug 1909992: Allow private bundle images within private indexes
+d06430e4f Merge pull request #1939 from awgreene/fix-operatorcondition-status-verbs
+f6c273e9c Fix operatorcondition role verbs
+8eb4b0f64 Merge pull request #1918 from exdx/fix/pin-sys
+a64448940 Merge pull request #1933 from zcahana/fix_webhook_cabundle
+113649e05 Merge pull request #1887 from guillaumerose/master
+7e3f40d38 Update the template of PRs
+493f70f60 Update editverbs and Make the instruction clearer
+0b956b6ac Use correct caBundle for 'olmcahash' annotation
+fa22f8002 fix: update moby/term dependency due to undefined: unix.SYS_IOCTL on macOS error when running locally
+df6353105 Merge pull request #1911 from dinhxuanvu/upgradeable-type
+d26451fb5 Change the "OperatorUpgradeable" condition to "Upgradeable"
+4e1a54142 Update /manifests with default cluster profile annotation
+bd76882dc Add the release annotation to all documents in all files
+feebee760 Merge pull request #1900 from awgreene/post-pending-operatorconditions
+d2042c24d Merge pull request #1913 from awgreene/fix-deployment-annotation-bug
+b3d8a7a17 Multiple operatorconditions should not update the same deployment
+fa18a49fd Merge pull request #1903 from awgreene/bump-deps-k8s-1.20
+ca9016c2b Reduce e2e test failure rate
+f55da6e71 Update manifests
+28a57c668 Fix manager start commands
+49c31f460 fix zap logger
+240a39081 Fix controllers and run codegen
+e72261981 Update semver import and update SSA
+983b63d05 bump k8s deps
+6e14b48a4 CSV Annotations override pod annotations
+a6e29ef53 Merge pull request #1905 from jmccormick2001/docs-channel-naming-design
+7f36227dd Merge pull request #1904 from dinhxuanvu/sa-csv-check
+a59b4e882 Merge pull request #1899 from awgreene/fix-operatorcondition-generation
+32edd682c fix(olm): Verify ServiceAccount ownership before installing deployment
+a3cd4afaa cleanup formatting
+a1f114b2a initial channel naming doc and related images
+8d9c02ee0 Merge pull request #1901 from awgreene/stop-printing-debug-noise
+bbe5a321f Don't create OperatorConditions for copied CSVs
+eaed5e11a Reduce log noise from OLM
+64bff0dd6 Merge pull request #1892 from benluddy/copied-csv-updatetime
+9c08a13de Merge pull request #1896 from dinhxuanvu/manual-approve-flake
+2f75d6a98 fix(e2e): Fix subscription manual approval flaky test
+eba4ff8c7 Preserve original .status.lastUpdateTime in copied CSVs.
+f1df66830 Merge pull request #1885 from dinhxuanvu/create-operatorconditions-for-operator
+8451f0847 Add OLM support for the Upgradeable OperatorCondition
+44e70e6b7 Merge pull request #1881 from horis233/check-sa-owner
+eed758a73 Merge pull request #1875 from awgreene/create-operatorconditions-for-operator
+5f3c090a4 Merge pull request #1878 from anik120/auth-catsrc
+f9cedec6b Merge pull request #1884 from benluddy/service-updates
+b438028a0 Support InstallPlan steps upgrading existing ClusterIP Services.
+4e7f8bf6a Add authentication for private index images
+798238998 Introduce OperatorConditions
+2e1a6d03d revert the change for e2e test
+b3940c21b format the import order
+4cef35525 Merge pull request #1832 from guillaumerose/master
+c52ab20b0 update manifests
+45543f4a4 update development document to add more informations for the e2e environments
+fe16404f4 Only check the owner of the service account if the service account has owner
+ecc7689b6 update e2e test
+d83855f0b check the service account owner in the requirement  check
+8a4330529 Merge pull request #1876 from njhale/fix-ioob
+fe468ab5f Add release annotation
+97c46f9e5 Bump yq from v2 to v3
+9cb137587 fix(catalog): be defensive about directly indexing catalog pods
+0c38f49d1 Merge pull request #1873 from exdx/feat/issue-labeler
+0ec97565b Merge pull request #1843 from dinhxuanvu/ip-recreate
+2a01d116e add default label to issues. add config file with upstream OLM contact information.
+60a4dc1cf Using subscription reconciliation to clean installplan status instead
+e0763e5a3 Merge pull request #1862 from awgreene/bump-k8s
+551a7fe40 fix(ip): Recreate pending installplan if deleted before approval
+84ac0895e Merge pull request #1616 from Jamstah/patch-1
+46087ef5e Generate code
+8439d2243 Bump k8s dependencies to v0.19.3
+dd03e5234 Don't create default ServiceAccounts
+070fbd3a3 Merge pull request #1855 from ecordell/service-duplicate-ownerrefs
+bf03bcda9 test(certs): add a test the ensures services do not get the same ownerref added twice
+03b34ce5a Update release.md with milestone step
+8d80d58d9 Merge pull request #1844 from dongwenjuan/master
+310b9107d test: scaffold a basic unit test for certresources
+f445b924b chore: generate fakes with inline go:generate directives
+9b496c696 Merge pull request #1850 from benluddy/changelog-0.17.0
+86f6e9cfc Merge pull request #1507 from harishsurf/csv-e2e
+82074324f Merge pull request #1848 from dinhxuanvu/svc-hash
+757c5aa7c Add unit test case to grpc and configmap reconciler test
+f18b5312c Generate changelog for v0.17.0.
+adfbdc34d Merge pull request #1849 from benluddy/manifests-0.17.0
+be6f02ffa Add spec hash to service's label to ensure service is correct
+6a7298bfa Generate manifests for v0.17.0.
+c0d4cff41 Merge pull request #1842 from benluddy/version-bump-0-17-0
+487a896ba fix the comment in package-server
+76d68d543 Bump version to 0.17.0.
+e3e4a37b8 Replace assertions with Gomega's matcher library
+10410a899 Merge pull request #1500 from harishsurf/scoped-e2e
+c4620406e Merge pull request #1502 from harishsurf/catalog-e2e
+28bda9e47 Convert scoped_client_test to ginkgo
+309954456 Merge pull request #1835 from awgreene/update-manifests
+5c4bd9521 Replace assertions to use Gomega's Matcher library
+0b242675f Set default, min, and max values on Webhook ports
+212cc45b8 Enable debug messgaes via klog
+5aa5fed0a Specify cluster name when there is only one cluster in kind
+2cbc79f3b Merge pull request #1823 from sjenning/bz1889838
+fb6c473ef fix race in Operator reconciliation
+fd261994f Merge pull request #1816 from sjenning/bz1888073-master
+bbc75c7e8 prevent no-op hotlooping on Operators
+799c353d3 Merge pull request #1807 from dongwenjuan/master
+0e063188e Merge pull request #1748 from jianzhangbjz/channel
+fd2a8f41c Merge pull request #1808 from awgreene/default-kubebuilder-ca-mount
+ca3b00e3e OLM mounts CA Certs where Kubebuilder expects
+a83ce2baa fix typo
+51cc83a5c Merge pull request #1803 from awgreene/improve-transistion-csv-logs
+4b47a3a6e Improve transitionCSVState error logs
+4171a2183 Merge pull request #1741 from horis233/fix-typo
+0ca7d6b54 Merge pull request #1799 from jupierce/art-consistency-openshift-4.7-operator-lifecycle-manager
+a3fff4b30 Merge pull request #1797 from awgreene/retrieve-ca-from-cw
+e12a78547 Merge pull request #1798 from exdx/fix/inflate-ip
+3f34aabde Retrieve CA from conversion webhooks for CA Hash
+34c4f2fc6 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/ac81dd4ff0bd57c4e75058d25b40615b92948259/images/operator-lifecycle-manager.yml
+ebf370e20 fix: remove extraenous manifest assignment and update CRD stepper. Add e2e test to verify configmap-based manifests.
+6e803bb8a Merge pull request #1480 from camilamacedo86/add-bug-report
+092e0d41a Merge pull request #1791 from benluddy/downstream-installplan-properties
+bdd163f70 Regenerate downstream InstallPlan CRD manifest.
+aef200abd Merge pull request #1781 from benluddy/property-projection
+5928c67c9 Annotate CSVs with the properties used during dependency resolution.
+101989643 Bump operator-framework/api dependency to v0.3.16.
+8a5004267 Merge pull request #1775 from njhale/bump-k
+4e686be46 Merge pull request #1773 from exdx/fix/polling-cycle
+488004863 fix(mockgen): use "go run" in all go:generate comments
+00c20978b chore(modules): update vendored deps
+64bf0c4c4 chore(modules): bump k8s deps to v0.18.9
+3231653c8 fix: update check from previous polling implementation
+be036c9de Merge pull request #1766 from benluddy/unresolvable-sub-error
+99b811f72 Merge pull request #1767 from awgreene/fix-conversion-webhooks
+dccb4d570 Allow ConversionWebhooks to define targetPort
+b162272a1 Bump operator-framework/api dependency
+8104bc4c2 Merge pull request #1763 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config
+95f6796fd Update pkg/controller/registry/resolver/resolver.go
+004f4ef52 Make a subscription without at least one candidate fail resolution.
+67c4ccdec Merge pull request #1729 from jianzhangbjz/catalog
+97d3d41d9 update error logs for channel head querying
+18425e141 Merge pull request #1756 from exdx/doc/default-polling-design
+971eec7e8 Updating Dockerfile baseimages to mach ocp-build-data config
+ecbff191e Merge pull request #1761 from awgreene/reusue-active-certs
+cabaf08b4 OLM should use valid CA certs if available
+cf99c6ef2 should not compare if no imageID
+9c29e9835 Merge pull request #1755 from exdx/fix/update-pull-policy
+5f02268eb Merge pull request #1732 from njhale/fix-op-csv-cond
+8380a9ab7 Merge pull request #1731 from exdx/fix/catalog-sync
+c4221e7e9 Merge pull request #1745 from awgreene/hco-bug
+488b9a98c fix: update catalog pull policy to Always in case the image is not digest-based.
+bb2d1f9c1 Merge pull request #1723 from exdx/fix/duplicate-pods
+431446661 doc: default polling
+9dbee83f8 Merge pull request #1735 from dinhxuanvu/add-skips-operator
+4c83276a9 Merge pull request #1 from njhale/hco-bug
+1c0c6d759 test(install): expect revision history = 1
+ab10b80da Merge pull request #1751 from awgreene/changelog
+f03d4aa21 Genereate 0.16.1 changelog
+8a1c5c478 Merge pull request #1750 from awgreene/0.16.1-manifests
+3089813cd Release: Generate Manifests
+c6eae26ea Merge pull request #1749 from awgreene/bump-olm-0.16.1
+2ad4bb577 Bump OLM Version to 0.16.1
+e4de9a206 fix: remove catalog update pod if it's in a failed state to prevent cycles in the catalog reconciler.
+5615cfde1 fix: requeue catalog source sync if update pod has not reported ready; remove duplicate pod immediately after imageID check; turn down polling logging
+3229876cd add correct polling interval based on modulus
+b556fef5d Handle mutliple skips and add unit test
+2be67979d Set RevisionHistoryLimit per Deployment
+21a75f3af Merge pull request #1739 from operator-framework/update-OWNERS
+1916b0391 fix typo in the error message
+a6c3ed229 Update OWNERS
+2ee3f9d1b Merge pull request #1738 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config
+113d6e40b Updating Dockerfile baseimages to mach ocp-build-data config
+922f80ba0 Add skips information to Operator representation
+29ad22b82 chore(modules): update vendor
+e163e0c72 fix(operator): map top-level csv phase to component conditions
+1a9425858 fix: resync catalogs with jitter if polling enabled
+e1fc1b741 Merge pull request #1624 from ankitathomas/registry_poll_interval_retry
+025c57fb9 Merge pull request #1727 from awgreene/ownerz
+04dfd27ef Merge pull request #1725 from benluddy/fix-subscription-without-channel
+55abcbe27 Merge pull request #1720 from simrandhaliw/update-manifests-to-include-bug-fix
+03e14b465 Merge pull request #1728 from awgreene/node-selector-bug
+28d41bb77 Bug: Fix nodeSelector subscription config override
+bbff47839 Bug 1861605: Update manifests to include the bug fix
+c36b26fc8 Update Owners file
+1fd8c055c Apply suggestions from code review
+56a72a9c8 doc: add reporting bugs doc and small nit improvements in the README
+377d39126 Fix install plan creation for subscriptions that omit channel.
+979464bc5 Merge pull request #1613 from konsotirop/installplan
+3fe1a7169 Move server side apply patch code to library, use ssa to update catalog source pods
+107eb20b4 Merge pull request #1715 from dinhxuanvu/fix-stale-bundle
+4c2de89bc Merge pull request #1721 from njhale/fix-crd-adopt
+349a617dd Merge pull request #1717 from Bowenislandsong/total_test
+9fa50a815 Merge pull request #1716 from awgreene/nodeSelector-support
+ba9a5238d Bug: Fix SubscriptionConfig NodeSelector field
+558dc887f fix(operator): re-adopt manually disowned crds
+d6b742e85 Add Total Test Number to report
+6a2f1f6c7 Fix stale content in configmap due to stale bundle image in the node
+61447446b Merge pull request #1713 from simrandhaliw/operatorstatus-description-bug-fix
+8f47f42e1 Bug 1861605: Reduce length of explanation of status of Operator resource
+79b073783 Merge pull request #1706 from Bowenislandsong/catsrc_weighting
+294de7359 Add Catalog Source priority for dependency resolution
+81e19588a Merge pull request #1699 from dinhxuanvu/deprecated-filter
+e52905795 Vendor registry 1.13.6 and fix unit test
+599a6a4c6 feat(resolver): filtering deprecated bundles in resolver
+be5540368 Merge pull request #1687 from dinhxuanvu/add-label-type
+93be814b4 Add unit test to resolver for label dependency
+e3023d9c7 Vendor the registry changes for label dependency constraint
+af0e53552 feat(resolver): Add label dependency type to new resolver
+258584b1c Merge pull request #1661 from njhale/ext-adopt
+ce6aa2dd4 Merge pull request #1696 from ecordell/remove-legacy-resolver
+c19e532ab Merge pull request #1702 from benluddy/spurious-bundle-cardinality-error
+59af78a3a Remove spurious check for duplicate operators in resolver.
+9d815df1e Merge pull request #1649 from simrandhaliw/add-conversion-webhook-support-for-olm
+49d15bae4 Addressed review comments
+1797b8835 Merge pull request #1680 from kramvan1/patch-1
+4819decd2 WIP: Add Conversion Webhook support for OLM
+ad1eb2ee6 test(e2e): pass ip test w/ created or present steps
+7a3c40ef9 Merge pull request #1695 from dmesser/update-default-catalog
+c0ec73047 feat(operator): adopt referenced installplans
+27b072d64 remove legacy resolver
+9c259b8ad Merge pull request #1694 from njhale/v1-default
+52254226e change default catalog to index image
+a2fab316a chore(vendor): include v1 operator api version bump
+e5113cd39 feat(operators): reconcile v1 operator resources
+3adebe965 chore(manifests): add v1 operator crd spec
+31ea82c96 chore(codegen): drop v2alpha1 clients/listers/informers, add v1
+9c6e9bbeb chore(scripts): drop v2alpha1 from codegen
+1c9ba958f chore(modules): bump api dep to include the v1 operator spec
+fddbe484a Merge pull request #1692 from benluddy/baseimage-path
+19489c72b Remove unnecessary ENV directives from base.Dockerfile.
+e88a8971f Merge pull request #1652 from operator-framework/new-resolver
+bbaaf7651 Merge pull request #1684 from njhale/fix-ip-gen
+b7d3b9e7f add CsvAbnornalReplacing alerts
+a73b45e48 configure metrics for new resolver
+6131cc467 rebased
+17e553ae1 check for cache consistency issues when querying for a dependency
+d0d574645 look in all catalogs when no catalog specified
+0d00bfc8c emit events when resolution fails
+7c49aef22 fallback to standard path for kubebuilder assets
+16c810d7e fix catalog grpc connection state updates
+123c6cfcd don't include docker image in the docker build test for kind test runs
+b37f67697 fix crd upgrade e2e test
+ebd4b9a5e retry for flakes
+3712fd8be make catalog delete tests less flakey
+7f66ef02d add a parity test for transferring api ownership between operators
+5351327b4 make catalog updates in tests less flakey
+849a2aa41 update package anti-affinity test
+e4134dfff properly handle solver invariants
+5875675e4 track existing CSVs without subscriptions as mandatory
+614a7a8ff handle csvs that are already installed but don't have subscriptions
+0b02783b4 extract properties/dependencies from existing operators in the cluster
+4665d355c Fix check for whether or not a sub was added during resolution.
+4a35e1780 Prefer bundles from the default channel in resolution.
+bbd94f70e Try to detect kubebuilder installation path if not explicitly set.
+3c10ae8f3 Regenerate registry client test fake.
+1e5d3e5c4 Bump operator-registry dependency to v1.13.3.
+90de599d5 deduplicate input installables
+fec1bf7bb expire cache when grpc connection is READY
+8d036cb9d fix sorting of inputs for dependencies
+96cef9cec enable new resolver by default
+2e2a50512 prefer the same catalog for dependencies
+69aaf5cce fix resolver bugs, fix cache race, and re-enable tests
+eaa4a5790 fix nested dependency resolution
+0b20f2b20 fix verify
+74573bce9 ensure cache is filled with content before marking it as not a miss
+a91786a6f renaming / refactoring
+8b4439bfe rename solve package
+0df4f6c09 treat dependencies generically
+8bed2cff2 refactor dependency walking to avoid recursing
+236ab6523 support skip list in bundles
+131f6870e support startingCSV
+359a5d640 pin etcd and grpc
+05a5abdd7 split old/new resolver and tests
+e0afeb7bc test updating to a package with skiprange that is not head
+c6b66150c search for operators in catalog order
+5552fe6d9 move csvname filter to a predicate when finding bundles in the cache
+7ab5dca1f use cardinality-based AtMost constraint
+376167a77 resolver can resolve updates
+be82373d9 chore(deps): bump operator-registry
+7cae89364 don't mark virtual package nodes visited
+1afecb8eb Decouple filter predicates from the operator cache itself.
+e9f83b6ca memoize bundle walking
+fb7f6754d support semver ranges
+4083aa6ff use new solver interface in satresolver
+8f79243c5 Adapt resolver unit tests to run with both implementations.
+964862934 Fix unit tests and add GVK dependencies extraction
+8a4dd1a4d Strip plural from APISets in resolver cache
+774e83054 Extract dependencies info from bundle and add to Operator object
+b56ac763b (feat): Add sat resolver for version dependencies
+ac25cb747 fix(install): account for installplans when calculating generation
+b6ab64dbe Merge pull request #1657 from anik120/dependency-resolution-metrics
+01d2def74 [metrics] Dependency resolution metrics
+20241c60c Merge pull request #1678 from awgreene/rebuild-busybox-operator-index-image
+f6b4cd739 Add busybox-dependencies-index image manifests
+3502ac2ab Remove unneeded toleration from catalog source pod
+8188429e4 Add additional logs to syncCatalogSources
+b3effc618 Merge pull request #1662 from awgreene/fix-webhook-e2e-test
+f019f85cb Merge pull request #1669 from ecordell/gc-installplans
+ff2ee560f fix(installplans): GC older installplans
+7ca6ce962 Merge pull request #1645 from Bowenislandsong/feat/add-flake-analyzer
+c6d569901 Merge pull request #1656 from exdx/fix/delete-grpc-e2e-fix
+55ea14156 Merge pull request #1642 from dinhxuanvu/ocs-lib-fix
+690347a67 Merge pull request #1655 from benluddy/unyum
+305d4ea15 Bug: Fix incorrect deployment annotations
+3ba83affa Merge pull request #1659 from dinhxuanvu/fix-deprecated-test
+820db5c86 fix: explicitly delete collection of catalog source pods in grpc e2e test
+28fe1bb5c Fix UpdateSingleExistingCRDOwner test case
+54ec2f5e8 Merge pull request #1654 from benluddy/error-duplicated-solver-inputs
+44d441f8d Fix validate CRD compatibility check and deprecated CRD test case
+59995d9a9 Omit (hopefully) redundant yum update from downstream builder stage.
+0e59b2509 Return an error when solver input contains duplicate identifiers.
+9e5c6c421 Merge pull request #1641 from exdx/fix/crd-e2e-test
+c581bb237 Merge pull request #1650 from benluddy/preferences-refactor
+cc6e86884 Merge pull request #1629 from matskiv/unique-binding-names
+9c9f305be Merge pull request #1647 from exdx/fix/remove-e2e-skip
+d5cdd52e3 Refactor solver preference searching.
+23c48dfe1 Merge pull request #1643 from Bowenislandsong/feat/e2e-artifacts
+afb72be15 fix: remove bundle e2e skip
+bac1cbd7c Add flake analyzer
+18150f98d Update the e2e test case
+c2dbcd51b fix(resolver): Exclude all installed packages in dependency search
+bc1841d55 Merge pull request #1639 from ecordell/fix-metrics
+84fc5feb0 Merge pull request #1623 from ankitathomas/plural_resource_in_relatedObjects
+a6962c83c Bug 1855088: generate unique role and binding names When same permission rules are defined for different ServiceAccounts, OLM would generate same name for (Cluster)Role and (Cluster)RoleBinding related to this rules. This change should ensure that unique names are generated, taking into account ServiceAccount name and CSV Name and CSV namespace (for ClusterRole)
+65c355cbf Merge pull request #1635 from njhale/fix-always-cleanup-e2e
+7bd6c2276 feat: add parity tests to resolver
+a97ce0076 fix: use server-side apply in crd e2e test when changing the subscription to point to a new channel to avoid transient object modified errors
+9e63ad488 Merge pull request #1607 from njhale/adoption
+dc4f6894f renaming / refactoring
+aad28cd0a fix: Use PR head commit in artifact naming instead of merge commit
+4438cc1f1 rename solve package
+8e90ac0c5 Merge pull request #1478 from marcusportmann/master
+543b569c5 Merge pull request #1637 from exdx/fix/vpa-crd-e2e
+a5b29b4c6 fix(e2e): make problematic test specs eventual
+092d68751 fix(e2e): copy rest config from test ctx
+0870a36c3 fix(csv): prevent duplicate service ownerrefs
+f03ceeb0a feat(operator): automatically adopt generated resources
+1db5869c4 Merge pull request #1640 from njhale/skip-cr-test
+42a972bdd treat dependencies generically
+3b895b771 refactor dependency walking to avoid recursing
+0f800116b fix: install VPA CRD directly on clusterfor bundle e2e test.
+a5096dd30 support skip list in bundles
+7341a41fc support startingCSV
+cabdc2bd7 test(e2e): skip bundle cr install test
+408a24b3e fix(metrics): query cache found object count metrics
+8e1c299b0 Merge pull request #1636 from exdx/fix/check-installplan-e2e
+a82db70fd pin etcd and grpc
+465df39dd split old/new resolver and tests
+33c9587bb test updating to a package with skiprange that is not head
+de9d35d6f fix: add installplan check after subscription status check for gc tests. this will help reduce the e2e test flakiness as resources were sometimes checked before the installplan completed.
+92c781053 test(e2e): delete all subs, installplans, catalogs, and csvs in test teardown
+c1af96599 Merge pull request #1631 from exdx/fix/bundle-objects-test
+6b3c309ce Merge pull request #1630 from matskiv/documentation-improvements
+35ef62299 search for operators in catalog order
+dac555dd3 move csvname filter to a predicate when finding bundles in the cache
+768a8dd80 use cardinality-based AtMost constraint
+5e2cec7bb resolver can resolve updates
+665390c8b chore(deps): bump operator-registry
+0f8841f62 don't mark virtual package nodes visited
+3bdcaa030 Decouple filter predicates from the operator cache itself.
+6fe6abc14 memoize bundle walking
+ec3dc5c5f support semver ranges
+d72759da9 use new solver interface in satresolver
+836d35cb2 Adapt resolver unit tests to run with both implementations.
+bac7177db Fix unit tests and add GVK dependencies extraction
+d4ada84aa Strip plural from APISets in resolver cache
+ee898423f Extract dependencies info from bundle and add to Operator object
+717b951cc (feat): Add sat resolver for version dependencies
+2b2c4cfe1 Merge pull request #1632 from benluddy/atmost-constraint
+c4cd7ad83 Merge pull request #1604 from benluddy/test-csv-owned-api-retry-update
+1147ce9d6 Add an AtMost cardinality constraint to the solver package.
+9ff5ad0b6 fix: checkinstallplan status in bundle e2e test
+b84d6989d fix: add kubebuilder to development requirements
+50cdb32e1 fix: broken link in PR template
+02060ef38 Bug 1855088: generate unique (Cluster)RoleBinding names
+e0561c2c8 Setting resource to plural in relatedObjects
+9febd1677 Merge pull request #1619 from benluddy/solver-preferences
+a73043275 refactor(solver): small naming changes and iterative search
+3a68739e3 Merge pull request #1618 from Bowenislandsong/feat/e2e-artifacts
+d1c13c63b Retry update in flaky test of CSV w/owned API Service.
+e4f48e0f5 Introduce preference order for solver.
+745bd8e96 Allow ConsoleYAMLSample resources from bundle manifests
+b6995763e Add workflow to save e2e test artifacts
+fb2a2e988 Merge pull request #1577 from exdx/feat/support-pdbs
+54258b940 Merge pull request #1617 from njhale/fix-e2e
+61a270d43 test(e2e): patch installplans w/ server-side apply
+3ea8e306b Merge pull request #1564 from exdx/feat/gardener-objects-bundle
+486ca4b96 Merge pull request #1603 from anik120/subs_sync_metric_re-fix
+4bed98128 Bug 1822396: Update metric when Subscription is updated
+b3af2089e feat: add design docs for including additional objects in bundles
+5deac9513 Merge pull request #1611 from exdx/fix/olm-book-link
+d78799b02 Merge pull request #1610 from benluddy/metrics-test-matcher
+5558d501c fix: update README to point to the OLM book website instead of github repository
+86fba414c Merge pull request #1600 from kevinrizza/node-selector-update
+20edf9fdf Merge pull request #1592 from Bowenislandsong/e2e-operator-failfast
+856be6fba Add more precise matching to the metric end-to-end tests.
+509fac3c4 feat: support new bundle object types: priorityclass, pdb, and vpa objects are now resolved from the bundle by OLM.
+41feee706 Merge pull request #1596 from benluddy/assertions-in-assertions
+7e610de6d Merge pull request #1598 from benluddy/e2e-local-nodes
+68dd6da4c Fix a flaky CRD test.
+4eb7bfed4 Merge pull request #1601 from kevinrizza/bump-version-0.16.0
+5cc19b361 Disable parallel e2e-local runs by default.
+a41857056 bump olm version to 0.16.0
+1275235ad Update ocp manifests with latest template
+24e78eaf6 Replace assertions within async assertions.
+4e76eba9b Merge pull request #1589 from ecordell/ip-status-is-status
+2525d918e Remove failfast from operator e2e test
+db4cbcbc7 fix(installplan): don't store the manifest contents on the installplan
+feaf1977b Merge pull request #1519 from anik120/subs_sync_metric_fix
+64f80e7a5 Merge pull request #1583 from kevinrizza/bug-1847540
+fe88505ed Bug 1847540: resolve only default channels
+c8b448430 Bug 1822396: Delete subscription metric when an operator is uninstalled
+8e05b8e83 Merge pull request #1562 from kramvan1/remove-deprecated-os-label
+112a1035d Merge pull request #1579 from njhale/fix-default-logo
+6242436b7 Merge pull request #1479 from camilamacedo86/add-contribution-doc
+d3da93782 fix(package-server): get icons from default channel
+eae7d0a46 Merge pull request #1578 from njhale/bump-api
+5a00be47f chore(modules): bump api dep to v0.3.7
+a401b7194 doc: add CONTRIBUTING.md
+67d4ac887 Merge pull request #1512 from harishsurf/reporting
+96cd8c4ee Merge pull request #1438 from camilamacedo86/uninstall-2
+40e8b308d Merge pull request #1539 from anik120/0.15.1-changelog
+2b4233852 Changelog for 0.15.1
+40d46789c Merge pull request #1542 from benluddy/release-fixes
+fa6c0a6a2 Merge pull request #1465 from benluddy/fix-goroutine-panic
+4b18ae463 Merge pull request #1558 from benluddy/install-flakes
+c8e001b31 Merge pull request #1443 from harishsurf/metrics-e2e
+0a52ac8b1 Merge pull request #1501 from beautytiger/cleanup/duplicate_import
+861d9990d Merge pull request #1563 from ecordell/weights
+710493bd1 feat(resolver): don't build new clauses for weights
+55eec053b feat: add uninstall
+3018c771a beta.kubernetes.io/os deprecated since v1.14, removed in v1.19
+39bf0c782 Merge pull request #1379 from awgreene/remove-webhook-enhancement
+da441902e Merge pull request #1535 from exdx/fix/block-storage-version-crd
+649df59ee Reduce install.sh flakiness.
+11151c8c2 Merge pull request #1549 from ecordell/rbac-fix
+7646ccbf6 fix: add check for storage version changes when installing CRDs. This prevents data loss when a CRD is upgraded and no longer supports existing stored versions of CRs on the cluster.
+5f045c0b2 Merge pull request #1482 from Bowenislandsong/bug/updateDisplayName
+7473aec47 Update PkgManifest upon catsrc update
+9b507ca14 fix(catalog): no operatorgroups in a namespace should be an error when resolving
+1e10c12bf Merge pull request #1550 from harishsurf/bug-1822040-og
+0869e8db4 Convert metrics_e2e_test to ginkgo
+cb7e74edc Fix delay when OLM applies label to Namespaces
+5131c6860 Merge pull request #1521 from dinhxuanvu/required-api-package
+b712bf1df Add more comments on e2e test case to clarify test flow
+cf32df90c Add test for release installation instructions.
+d166546a3 Merge pull request #1540 from awgreene/webhook-container-port
+49c1fde91 Remove CRD manifests from 0.15.1 quickstart's olm.yaml.
+bd15e2400 Preserve .crd.yaml suffix for manifests copied from api.
+f3550584f Don't put CRD manifests into olm.yaml.
+0e17c44da Merge pull request #1516 from exdx/fix/bug-1833195
+34bbcc959 fix(webhook): Wire ContainerPort to Webhook
+aca04c257 Merge pull request #1538 from anik120/manifests-0.15.1
+ab0e18356 Manifests for OLM 0.15.1
+b7891aa28 Merge pull request #1537 from anik120/bump-0.15.1
+cef848348 Bump OLM to 0.15.1
+92ec23767 Merge pull request #1525 from harishsurf/bug-1819308
+f063fdbfa Address feedbacks on registry client interface
+0f13ffff5 Compose registry client & interface under a new interface
+923b93f2b Merge pull request #1533 from anik120/0.15.0-changelog
+1e77c07f2 Changelog for 0.15.0
+6bdb86b90 Add e2e test case to test multiple dependencies with same package
+f9adcc282 Update unit test cases to adapt to new changes in NamespaceSourceQuerier
+3480006cd Edit test cases to work with new changes on NamespaceSourceQuerier
+a16ec47a7 Mockgen for registry client
+abc44c8c2 fix(resolver): don't pick operator from same package when resolve requiredAPI
+4d7cd4d69 Merge pull request #1472 from awgreene/podconfig-test-flake
+f34530f60 Manifests for OLM 0.15.0
+ba2cb1b3b Update scripts to include crds during release
+55b9124b2 fix: add ownerrefs to bundle objects; add e2e tests for bundle object gc
+14fae5e9a Merge pull request #1439 from harishsurf/pkg-msft-e2e
+4181bcce3 Converted packagemanifest_e2e to ginkgo test
+1d0bcd5a2 Merge pull request #1520 from awgreene/packagemanifests-keywords
+dd49980c3 Merge pull request #1513 from njhale/fix-qset
+06e71752c Deleting a CSV removes related CSV metrics
+424dc2928 Pod Config Deployment Hash Error
+74ce8c1c0 PackageManifests should include CSV Metadata
+fce8caf9d fix(queues): requeue events against all-namespace queue if present
+552187525 Merge pull request #1424 from harishsurf/e2e-part1
+4bac72c0f Modify dynamic_resource_e2e_test to ginkgo
+eb9959d86 Merge pull request #1515 from awgreene/robust-webhook-selector-test
+b2098e361 Modify prow ci logging for e2e tests
+b12c6244f Update Webhook E2E Namespace Labels
+3566b2442 Merge pull request #1429 from harishsurf/e2e-gc
+46b6c1b26 Merge pull request #1509 from awgreene/csv-updated-on-webhook-change
+de8797b47 Detect WebhookDescription changes in CSVs
+620986f1b Merge pull request #1503 from anik120/bump-olm-version
+b6da2f600 Convert gc_e2e to use ginkgo
+e533e19b7 Merge pull request #1489 from awgreene/webhook-unique-names
+ffe908629 (fix) Admission Webhook names must be unique
+4b8166082 Bump OLM version to 0.15.0
+e52a0cd1a Merge pull request #1496 from awgreene/operatorgroup
+df543faf2 Fix upstream.Dockerfile
+51ae73552 Update OLM to use UID for OG Labels
+5a46a5dce cleanup: delete duplicated import in olm
+8f8a1a86d Merge pull request #1470 from exdx/fix/bug-1825330
+2f9a54c2c fix: address sttts feedback
+fb457991d fix: support creating v1beta CRDs to avoid data loss during conversion to v1. Due to data loss during client side conversions OLM will support two different paths for v1 and v1beta1 CRDs.
+90a8b4aa8 Merge pull request #1483 from awgreene/dependency-bug
+af714e91b fix(resolver): Transferring API Ownership
+44cf5cf8b Fix Operator Generation code
+38098eedd Changed address for readiness probe and liveness probe on registry-server
+105cf4b61 Merge pull request #1468 from njhale/op-disc
+db879834d test(e2e): correct tls detection in metrics spec
+8c8e60bf6 test(e2e): make operator resource creation eventual
+a6afaddc1 test(e2e): simplify csv requirement event spec
+ef7257da7 chore(modules): pin controller-runtime to master
+335a24af9 chore(manifests): include double-hyphen olm deployment options
+9adb4efdb fix(client): supply missing params
+da527ce92 test(operator): gracefully stop test controller manager
+9c5a9337d fix(operator): swap top-level update for status update
+8840a5a65 feat(operator): enable configmaps to be operator components
+9322a0fa1 test(lib): add unit test for metav1 time conversion hook
+1b519dbf6 chore(make): use existing kubebuilder installation
+e428e8b84 chore(logs): set manager setup log level to 4
+0e759d6f1 test(operators): add e2e test for the v2alpha1 operator resource
+738e9ee07 feat(operators): add v2alpha1 operator controller
+08e085e83 Merge pull request #1458 from benluddy/resolver-cache
+a9a42c2ed Add an operator cache for use by the resolver.
+b2b68b9a4 Merge pull request #1464 from ecordell/ofapi2
+5f230069e Catch failed Ginkgo assertion in test goroutine.
+fe19a530c chore(api): switch to operator-framework/api
+b664fed89 fix(secret): use a synthetic kind instead of an api field to determine bundle secrets from pull secrets
+81650bbaf chore(make): copy crd manifests from apis repo
+4745e326f chore(deps): bump to kube 1.18
+56f1a45b6 Merge pull request #1447 from exdx/feat/support-secrets
+3cbeec064 Merge branch 'master' into feat/support-secrets
+09cd6b564 Merge pull request #1460 from benluddy/fix-unpack-test
+10e77a9ad Fix failing E2E bundle unpacking test.
+bfccbaa7a Merge pull request #1440 from benluddy/sat
+274e03836 Add initial SAT solver package.
+9f0784075 feat: support secrets from bundle
+cc9352619 Merge pull request #1455 from exdx/fix/add-empty
+62d866165 fix: add empty go file to packge to fix make verify
+2795e5660 Merge pull request #1416 from exdx/feat/v1-crds
+6a37a199a feat: support v1 CRDS in OLM. Simplify InstallPlan Execution via new Stepper interface. All CRDs will be converted and handled at the v1 APIVersion.
+15825bacc Merge pull request #1454 from benluddy/regenerate-test-chart
+7c893c486 Regenerate the chart embedded in the test installer as needed.
+88654beec Merge pull request #1451 from harishsurf/github-workflow
+4e90e55a5 Merge branch 'master' into github-workflow
+27610abe5 Merge pull request #1452 from njhale/fix-image-build
+f1c2eb3a2 chore(gh-actions): install conntrack before minikube
+906b22a0a fix(docker): include util dir in upstream image build
+42a64c175 test(gh-actions): add upstream image build test
+783882c70 Merge pull request #1436 from awgreene/admission-webhoooks
+68aafcc8a Added Github workflow for running e2e tests
+478af2f24 OLM Support for Admission Webhooks
+86057a491 Move APIService to installer
+ceb8545f3 Merge pull request #1446 from njhale/kb-assets
+84a82d3ae chore(docker): add kubebuilder to base image
+5fb92c868 Merge pull request #1442 from dinhxuanvu/owners-component
+0b3bcb1bc Merge pull request #1434 from exdx/feat/support-configmaps
+edc57f3af feat: support configmap creation from the bundle
+1cda8b82c Merge pull request #1444 from exdx/fix/fix-catalog-polling-test
+3c024be07 fix: use busybox csv for polling e2e test
+c7d109aa7 Add BugZilla component to OWNERS file
+4f5b08c84 Doc: Remove legacy webhook proposal
+1c49808fd Merge pull request #1418 from awgreene/apiservce-reorder
+182566ed9 Merge pull request #1410 from benluddy/e2e-go
+d35504c2f Create APIService after API server deployment
+5c619adc6 test commit please ignore
+1e50f968a Merge pull request #1419 from njhale/fix-codegen
+6023448e0 chore(codegen): update to drop license year
+68b1a703f chore(codegen): use controller-gen for deepcopy
+f5ece8e07 chore(codegen): remove license year from boilerplate
+91afbda97 Merge pull request #1350 from flickerfly/patch-1
+f0fee0b7d Merge pull request #1414 from njhale/fix-nilref
+c4824d268 feat(catalogs): add spec validation for sourcetypes
+6ee3f23a7 Merge pull request #1387 from dinhxuanvu/pkgm-csv
+95a7bfcb2 Merge pull request #1408 from awgreene/reconcile-namespace-og
+1b73afe38 fix(sub): prevent nil pointer access
+0195afb06 Merge pull request #1411 from benluddy/clusterscoped-gc-tests
+9d422bc25 Reconcile Namespace OG Labels in Namespace Syncer
+2b2b1858d Update the code and test case
+ef8614707 Add tests for GC assumptions.
+7d8987a18 Update related images func and test case
+338586617 make codegen for packagemanifest changes
+0fc809408 Add more CSV information to the PackageManifest
+4a2d1a014 Merge pull request #1370 from anik120/bump-k8s-1.17-rm-k/k
+030e6841e Merge pull request #1224 from Jamstah/master
+d9ac63c9a Merge pull request #1401 from ecordell/fix-bundle-install
+64aabcb89 chore(apis): Regenerate API types for openapi3 specification
+c418778b5 Merge pull request #1398 from awgreene/operatorgroup-labels
+a5142bc73 chore(deploy): update manifests
+ac0c454f0 fix(bundles): include csv name in installplan for bundle images
+96a15cc02 Add OG label to namespaces in OperatorGroup
+5ccb5f9d0 chore(deps): bump to kube 1.17.3
+f9473fee0 Merge pull request #1391 from benluddy/helm3-chart
+c2e7151c9 Merge pull request #1372 from harishsurf/ginkgo-e2e
+00568b748 Convert e2e go tests to ginkgo
+d6d8f0531 Merge pull request #1388 from awgreene/test-2-apiservices
+63848c351 Merge pull request #1389 from ecordell/remove-catsrc-memlim
+ec04c310c Update chart to use the new "crds" directory.
+86437faac Merge pull request #1381 from harishsurf/fix-typo
+e043b38f0 Merge pull request #1390 from benluddy/og-conditions-flake
+6ea521dba Ignore differences in CSV .status.conditions in unit tests.
+6237dc399 Add e2e test for multiple APIServices on a pod
+88b5b1ba1 fix(catsrc): remove limits on catalogsource pods
+1ab6a9452 Fix typo in subscription.crd template file
+06d852196 Merge pull request #1339 from awgreene/bug-1805412
+b1dce629c Rewrite
+6e3932972 Merge pull request #1073 from javanthropus/add-security-context
+9d236a8dd Merge pull request #1371 from ecordell/alert-sev
+f81ec068c Merge pull request #1334 from umangachapagain/subs_config
+8630695db Add updated manifests from make release
+c499308f5 Optionally lock down package server runtime environment
+33cc7da0d manifests(prometheus): failing operators should be a warning
+dcb5971da Merge pull request #1313 from madorn/patch-2
+785ddd6d1 Merge pull request #1348 from benluddy/api-clusterrole-ownerrefs
+8a0754125 Support multiple At PIServices on a single Deployment
+528363f3f Make provided API ClusterRoles be owned by the corresponding API.
+0b36b4b17 update examples for Subscription config features
+e3ed855eb (test) update e2e test
+aa94aa77e (feat) inject 'Tolerations' & 'Resources' from config
+beb129520 Merge pull request #1353 from ecordell/jittery
+d273283fa feat(jitter): add jitter to controllers to smooth out our spiky resource usage.
+3d3422b97 PackageManifest isn't actually a CRD
+f18f89376 Remove specific client tool names
+73680b27d Merge pull request #1341 from njhale/fix-ip-orefs
+8a820c936 Clarify roles and adds info about Package Server
+403a33371 Merge pull request #1340 from simrandhaliw/update-subs-sync-total-metric
+cf35327ec fix(installplan): crs are ownerreferenced to their resolving csv
+4dcad6720 test(installplan): add cr ownerref unit testcase
+b462e7ddb Bug 1809294: Update subscription_sync_count to include the package name
+12a8b69bd Merge pull request #1337 from njhale/fix-run-local
+ccd6755ee Merge pull request #1332 from benluddy/unbreak-minikube-script
+f99d7e9fc fix(make): build cpb as prereq of e2e-local
+72e50d5f3 Merge pull request #1316 from njhale/installplangen
+b96cbc5ea Merge pull request #1301 from ecordell/depspec-hash
+93e29bea8 Unbreak the minikube mode of build_local.sh.
+92c7d1921 style(logs): mention generations instead of manifests for subs
+0f2d1790a fix(subs): retry status update on conflict
+9aa59eff6 Merge pull request #1308 from dinhxuanvu/remove-run-level
+66fdeb024 Merge pull request #1322 from exdx/fix/duplicate-packages
+b4dbade36 Merge pull request #1323 from benluddy/unblock-on-start-error
+149a7c0b7 test(installplan): ensure single installplan per resolution
+887102abb fix: use label selectors in package server List response for all namespaces if label selectors are provided
+fe0fb1cc9 fix(deployment): remove separate operatorgroup annotation updater
+a74c49f41 Merge pull request #1324 from benluddy/local-kind-detection
+abacf871f Merge pull request #1319 from Bowenislandsong/stalebot
+3e79ee5a8 fix(deployment): use deployment spec hash for determining if change  is needed on cluster
+0dad6c092 Fix kind detection for local builds.
+2787f38ac Don't block on ctx.Done() if startup fails.
+90b291a37 Fix TestUpdateCSVInPlace e2e test case
+4bccd9087 fix(resolution): add generation to installplan
+7d230384e Add stale bot
+f77eb7018 Merge pull request #1314 from awgreene/olm-book-doc
+b42cc1699 Update README to include OLM-Book
+4ae604918 add link to olm-book definition of subscription
+edf563cfd Merge pull request #1307 from madorn/patch-1
+1da145e91 Remove run-level 1 from olm and openshift-operators namespaces
+e25a75c33 Update subscription-config.md
+376197a97 Add some examples for Subscription config feature
+5c5423670 Merge pull request #1300 from awgreene/bug-1798051-copy
+cf72e5b4d Bug 1798051: Reinstate v1alpha2 operatorgroup
+da45918d8 Merge pull request #1284 from dinhxuanvu/pkgm-fix
+f23312756 Merge pull request #1252 from njhale/fix-bundle-extract
+112de3e2e Merge pull request #1278 from kevinrizza/version-0.14.2
+40fa07a45 feat(util): add cpb command
+a60a41166 Merge pull request #1257 from exdx/fix/polling-e2e-test-registry
+f56148540 Merge pull request #1282 from dmesser/readme-update
+1803e5a4c fix: update e2e test to use internal docker registry and openshift registry. removes quay credentials.
+23631fba1 fix(packagemanifests): Fix index key func to avoid key collision
+ad0638098 mention OLMs features in the introduction
+4202372e0 fix(bundles): execute opm from tooling container
+4fb7859fe Merge pull request #1277 from benluddy/fix-ready-not-closed
+fdcc6ecb7 Fix cases where an operator's ready channel may never close.
+ab96e3061 Bump version to 0.14.2
+4c2d221f3 Merge pull request #1268 from kramvan1/fix-1238-configmap-probes
+2a0f757b9 Merge pull request #1276 from exdx/fix/update-robot-creds
+861c4c56e fix: update existing robot credentials
+172b16f38 Merge pull request #1274 from Bowenislandsong/Makefile
+6722fc968 refactor rh-operator test directory
+662564c78 Merge pull request #1261 from njhale/update-owners
+e285a00a8 Merge pull request #1265 from benluddy/manifests-for-0.14.1
+c9a31cea1 Merge pull request #1266 from benluddy/changelog-0.14.1
+26f3fd842 Merge pull request #1267 from ecordell/fix-bad-opgroup-annotations
+c049549c5 Merge pull request #1171 from exdx/bug-1777144
+8752b897e BUG 1238: Fix configmap registry server readiness probe timeouts
+6ec6514d6 fix(gc): clean up copied csvs that have incorrect operatorgroups
+368caf0cb test(e2e): add test to reproduce bug where copied csvs with annotations
+7f9657813 Generate changelog for 0.14.0 and 0.14.1.
+2c8af04ec Generate manifests for version 0.14.1.
+aedaf153f Merge pull request #1264 from benluddy/version-0.14.1
+e3c18253f fix(operatorgroup): don't overwrite operatorgroup annotations on copied
+121fb85ed test(ci): add failing test assertion showing that operatorgroup annotations on copied csvs will get overwritten to the wrong thing
+11945b37a Bump version to 0.14.1.
+43dd62290 Merge pull request #1258 from benluddy/revendor-registry
+5d3e7e771 chore(ci): update owners
+ae082363c Update operator-registry dependency to v1.5.8.
+c6ad718fe Merge pull request #1250 from benluddy/fix-release-gitignore-pattern
+04a07526a Merge pull request #1253 from awgreene/dynamic-client
+0b24bdb1d Fix overly broad .gitignore pattern that was excluding a vendored package.
+184e1e1c4 Add support for Prometheus Custom Resources
+20c1033be Merge pull request #1248 from benluddy/version-bump-0.14.0
+4123504a4 Bump version to 0.14.0.
+6c7320ce2 Merge pull request #1247 from benluddy/vendor-helm
+2d252327b Vendor helm, since it is used for templating manifests.
+a135d9d9a Merge pull request #1233 from Bowenislandsong/e2e_metric
+1a1940514 adding e2e test framework for rh-operator metrics
+6858f165b Merge pull request #1231 from benluddy/e2e-test-ipv6
+ce7b927af Merge pull request #1228 from benluddy/helm-template-v3
+bb30b1ddc Change to using a hash instead of ordering
+a81253d9b Addresses the bug where updating the packageserver fails with a unable to adopt APIService status message. This is a result of ownership mismatches between the packageserver (owner) and the APIService (the owned object). This can be resolved by setting the actual k8s owner references or the label-based references that OLM uses. This commit ensures that ownership references for the APIService are cleaned up on OLM restart and that the olm.owner:packageserver label is set on the corresponding APIService object.
+aa7a49034 Merge pull request #1235 from robszumski/update-proposal
+92dde5519 Merge pull request #1219 from ecordell/test-ci
+193ba4980 update internal objects proposal
+2d442b3a8 Merge pull request #1229 from benluddy/release-doc-prereqs
+44ebf7c7b Merge pull request #1232 from exdx/fix/doc
+ca965a2d9 fix: typo in catalog polling doc
+af11ce01a Merge pull request #1220 from ecordell/packagserver-labels
+ebcc695f8 Fix IPv6 incompatibility in TestGrpcAddressCatalogSource.
+13772ff2a feat(packagemanifest): add default os/arch labels if not present
+e6d0273bc Merge pull request #1226 from exdx/fix/catalog-polling-spec
+2653e086e Remove pyjq and yq from the release documentation prereqs.
+ad3d9140d Update release script to require version 3 of helm.
+ce31edd6c Merge pull request #1097 from robszumski/proposal-internal-image
+285b9ca05 Merge pull request #1225 from benluddy/manifest-templates
+f7ba83ccf fix: refactor catalog polling spec to use more general update strategy field
+042d7fa19 Reconcile manifests with templates.
+3217fd46c Add alm-examples-metadata
+cdd04e244 Merge pull request #1215 from njhale/unpack-bundles
+302ae173e test(e2e): fix subscription update flake by retrying
+d8d902573 docs(design): add bundle image unpack design
+bead4ccab refactor(resolve): simplify bundle lookups
+7f339d092 fix(catalog): add ownerreferences for bundle image resources
+c01fa467c fix(e2e): remove local dev test registry image
+f7ab7e3eb fix(e2e): remove local dev test image
+1df508a4c test(e2e): add test for bundle image
+3396ed2b5 chore(fakes): make mockgen
+15a5147f7 chore(codegen): make codegen
+2aadb869f feat(bundleimage): resolve bundle images
+40cb8ccab feat(catalog): make install possible from bundle image
+47697f399 chore(vendor): get latest operator-registry
+a99cf0776 Merge pull request #1161 from exdx/feat/catalog-polling
+7978bb9cd chore(build): only enable cgo for ci/prod builds
+c5f2e9758 Revert "feat(packageserver): support label queries and copy CSV labels onto the packagemanifest"
+88d76135d feat(packageserver): support label queries and copy CSV labels onto the packagemanifest
+d5917a5ea feat(packageserver): support label queries and copy CSV labels onto the packagemanifest
+a241df47b feat: add polling doc
+ac4864ca3 fix: update Poll to be pointer
+ca65ac3af Merge pull request #1217 from benluddy/vendored-yq
+099921692 feat: implementation of catalog polling feature with e2e test
+6cdf06d3f Use vendored transitive dependencies for "go run" of vendored yq.
+62691f243 Merge pull request #1216 from jianzhangbjz/kuryr
+dcd4db1f2 Enable CGO and CGO_DEBUG
+a7fb3e9a8 Merge pull request #1212 from ecordell/ci-base
+2cb787f4a chore(codegen): update generated code for 2020
+43458956b chore(ci): add dockerfile as a base for building in CI
+1a21520e6 Merge pull request #1173 from beautytiger/dev-191205-errcheck
+d6e406f9b Merge pull request #1154 from Intermax-Cloudsourcing/fix-run-console
+61f1b24ed Merge pull request #1105 from ecordell/trust-grpc
+2c0e34f4b Merge pull request #1185 from clyang82/br_olm_versions
+db14fd512 Merge pull request #1207 from ecordell/remove-limits
+45b0907cb test(e2e): testing CRD upgrades shouldn't create a new subscription
+3f3bd125a feat(resolver): rely on info from catalog to determine updates
+02b289dd4 fix(deploy): remove resource limits
+fb4548dda Merge pull request #1202 from njhale/cleanup-codegen
+47c7e969b chore(vendor): update
+db5bad726 chore(codgen): regenerate code, mocks, and openapi
+17b39d0a0 refactor(pkgsvr): remove apps group
+04d2c823d chore(codegen): clean up codegen make rules and scripts
+0cab798bc chore(ci): remove old gitlab ci config
+46aa2a5bf Merge pull request #1152 from njhale/design-goals
+0cae336db Merge pull request #1194 from ecordell/csv-fallback
+8e4880401 Merge pull request #1157 from awgreene/prune-unknown-fields
+f6767bb59 feat(resolver): fallback to csv parsing if grcp api does not contain the information required
+41c8c8d2e Merge pull request #1192 from gyliu513/etcd
+330999145 Corrected etcd CRD URL.
+b69a18fee Merge pull request #1163 from gyliu513/high-light-yaml
+05124913e Merge pull request #1176 from jmccormick2001/doc-bundle-breadcrumb
+75f4ff122 Merge pull request #1187 from gyliu513/dep
+a948f986c Dep is not required.
+57e76cac2 Add note for version field
+d8c26fd45 docs(design): add general design goals
+bdc3e72e2 Update manifest CRDs
+b1d4c8712 Implement controller-gen
+1d74e7d4e Update CRD go types
+ce298fcab Merge pull request #1150 from njhale/spur-pkgsvr
+4ba847801 chore(git): remove and ignore packageserver test key pair
+bb936402e chore(modules): vendor deps
+f69ddb6dd fix(packageserver): cache packagemanifests
+8d5a38c18 Merge pull request #1175 from awgreene/test
+e9ab0d60b Fix CI unit tests
+d6b393db9 add a mention of bundles to the README to help users find bundle information
+b697bbb17 fix: add err check before further operation
+b9541d4f6 Merge pull request #1125 from dinhxuanvu/sync-improve
+5fef82d31 Change index func to return list of ns instead
+20a473cac Added `keywords` in operator metadata.
+3316e73ef Merge pull request #1151 from jpeeler/cert-rotation
+e2136b71f Merge pull request #1123 from Bowenislandsong/bugfix_dup_secrets
+baef6f536 Fix updateInternalCatalog namespace bug
+f8a759c74 Add e2e test case for syncSourceState
+10e929350 Enable multiple namespaces sync if catsrc is updated in global ns
+4cf347298 Bug 1769030 Replacing (updating) operator creates duplicate secrets for the operator's ServiceAccount
+5435cfaf3 feat: make run_console_local.sh sh compatible
+0792b0f52 fix: make run_console_local.sh working on WSLv1
+e9e8f4985 bug(metrics): serve metrics using new certs when replaced
+d78b41f18 feat(filemonitor): add new filemonitor package
+0645ebeb6 chore(modules): add fsnotify
+1a95d31ce Merge pull request #1147 from dinhxuanvu/unit-fix
+13860d5d9 Merge pull request #1142 from Denton24646/bug-1760608-resource-limits
+1138f3510 Fix minor namespace bug with NewFakeOperator
+a0301923f Update k8s version for local cluster (1.16.2)
+70e8c2159 fix: double limits
+b17f500f9 fix: double packge server limits for CI
+e1574e34c feat: add resource limits to all OLM pods for OLM releases on OCP above 0.13.0
+3d9b0c6ab Merge pull request #1116 from Denton24646/fix/catalogsource-context-leak
+49bb20259 Merge pull request #1137 from gallettilance/release-docs
+eedfb5100 Merge pull request #1132 from Denton24646/fix/operatorhub-catalog-windows-vm-scheduling-bug
+9e0318d85 fix: simplify test by removing additional map
+570808327 feat: add test to confirm node selector behavior
+40d868a9c fix: add NodeSelector to catalogsource pod spec
+e24ca3a33 Merge pull request #1135 from gallettilance/release-changelog
+57a200dbb Merge pull request #1134 from gallettilance/make-new-release
+c5f7ee9bf [release] updating changelog
+3c7f94379 [docs] update changelog command
+6bd05fba8 Merge pull request #1114 from jpeeler/fix-status-invalid-csv
+665319353 [release] - making new release
+ea140d7be Merge pull request #1130 from gallettilance/version-bump
+5ce35a378 Merge pull request #1131 from gallettilance/new-release
+c2fa1a492 [docs] - update release docs
+e531d001c [release] - version bump
+a0d1ea445 fix: defer RUnlock in AsClients
+18c15a386 fix: use defer cancel to cancel context waiting for state changes
+cbcf7796a Merge pull request #1115 from bandrade/subscription-config-doc-adjust
+24653792d Fixing doc typo
+9527d7d9e fix(olm): defer provided api update in operator groups
+f510cc902 Merge pull request #1096 from beautytiger/dev-191029-tfatal
+21e57eefe Merge pull request #1111 from dinhxuanvu/fix-flaky-e2e
+25ddd845a Fix flaky subscription e2e test case
+07af0d106 Fix several flaky e2e test cases
+3b41a4dc4 Merge pull request #1104 from anik120/add-promethues-rule
+8bec5a0af Alerts for failing OLM operators
+e1a383faa Delete file that was renamed
+6085eb699 Merge pull request #1100 from awgreene/increase-cardinality-on-csv-metrics
+417a973f4 Swap annotation namespace
+1d463935e feat(metrics) Report subscription channel
+c53417f2f Merge pull request #1101 from ecordell/resolver-required-apis
+2dc06d2ac feat(resolver): use provided and required apis from grpc instead of calculating from the csv
+c6f1304b8 Merge pull request #1099 from awgreene/limit-cardinality-on-csv-metrics
+3674abbbd Use the correct title
+7c814f265 Ammend proposal to include data CRDs and new annotation names.
+a35c3b29c feat(metrics) Limit Cardinality of CSV metrics
+5b4afbb7d Merge pull request #1095 from gyliu513/update-operators
+def5f2e48 Merge pull request #1094 from dinhxuanvu/minkube-status-fix
+d41cd0bb9 Add unit test for minKubeVersionStatus
+009151be1 Merge pull request #1089 from gyliu513/customize
+6730f38b6 doc: add internal image proposal
+f0a3566fc fix: t.Fatal should be used in main goroutine
+ccda1d25a docs: Corrected CSV upgrade version.
+46f72fbe6 Merge pull request #1092 from Denton24646/fix/docs-fixup
+40cc6459a fix(olm): No longer report status if minKubeVersion not specified
+7ef66b823 fix: refresh architecture and philosophy
+b6208c864 Updated values.yaml location.
+d45959783 Merge pull request #1085 from operator-framework/ecordell-fix-logs
+129997451 Merge pull request #1086 from Denton24646/fix/csv-documentation-typo
+0fcaa0d0d fix: fix particular typo in clusterserviceversion_types.go
+5f42cdfe8 Update resolver.go
+6939b516e Fix log message in resolver
+97d9c7a75 Merge pull request #1083 from sbose78/patch-1
+bcd443dbd URL with modified manifest directory structure
+5d3831f7f Merge pull request #1080 from awgreene/initialSource
+c1d2699d5 Merge pull request #1078 from awgreene/update-package-table
+2810eaa13 Merge pull request #1071 from beautytiger/dev-191011-nilmap
+99c780af6 Merge pull request #1054 from tkashem/proposal
+ba5a9d197 bug(dependencies) Prioritize APIs from same CatSrc
+930279b29 Merge pull request #1079 from alecmerdler/remove-alecmerdler-owners
+c0fa43829 Merge pull request #1069 from ecordell/relatedimages-proposal
+8a0e2f31d update OWNERS
+1e5e2e957 Update PackageManfiest table handler
+70e41728a Merge pull request #1059 from dinhxuanvu/installplan-approval
+cde129861 Merge pull request #1058 from awgreene/sub-config
+0dc42b12d Merge pull request #1067 from operator-framework/apk-up-1
+420a2847a bugfix: assignment to nil map will cause panic
+560325a59 Fix InstallPlan stale variable issue
+fc6f6233d Add e2e test case
+0843f7499 proposal(relatedimages): combine the two previous proposals
+80aadbd2c proposal(relatedImages): update related images proposal to use kustomize
+816662558 proposal(relatedImages): add a proposal for specifying related images in CSVs
+02355a625 Add document for SubscriptionConfig
+5942fea8d feat(subscription) Config Volume and VolumeMounts
+29e1854e4 Rename envVar package to overrides
+7d2db3312 Add `apk upgrade` to upstream builder
+b77cc4ace Merge pull request #1065 from spadgett/fix-console-link
+652bc5c63 Fix links to console repo for moved packages
+14d6f0798 Merge pull request #1062 from awgreene/fix-install-script
+1ccd84303 bug(install) Fix packageserver name in install.sh
+807db4999 Bug 1758008: Manual approval strategy ignored for subsequent releases
+b30729903 (proposal): add bundle image deployment text
+7a004cf12 Merge pull request #1055 from awgreene/csv-health-metrics
+3b86f8648 feat(metrics) record CSV sync events
+2ef3ef37c Merge pull request #1056 from awgreene/make-e2e-bug
+59c8596b9 Bug: Fix olm chart
+05f703022 (proposal) Make bundle accessible to a cluster
+f0bfbb67a Merge pull request #1052 from njhale/bump-openshift-client-go-version
+7a898691c chore(modules): update vendor dir
+cac3406a7 chore(modules): bump openshift/client-go pseudoversion
+45bdb14d9 Merge pull request #1051 from awgreene/changelog
+f3a42bec6 Merge pull request #1048 from ecordell/k8s-1.16
+cef67da2c Merge pull request #994 from njhale/shell-lib
+b54586244 Merge pull request #996 from njhale/fix-tags
+21e0b2277 Merge pull request #995 from njhale/refactor-opstatus
+8daaa439f (release) Update changelog
+e3dd1540e Merge pull request #1050 from awgreene/manifest-0.12.0
+39d24fd50 (release) Generate manifests for 0.12.0
+e58e3d43d Merge pull request #1046 from awgreene/release-0.12.0
+1f979f072 chore(deps): bump to kube 1.16
+370e31ec1 Merge pull request #1047 from awgreene/docs
+74295d326 (docs) Update release.md documentation
+a89680d52 (release) cut a release for 0.12.0
+c5c9efabb Update PULL_REQUEST_TEMPLATE.md
+f995cc631 Update PULL_REQUEST_TEMPLATE.md
+2dfa925b2 Update PULL_REQUEST_TEMPLATE.md
+79a92fbb1 Merge pull request #988 from dinhxuanvu/update-csv
+b5f0f797c Merge pull request #1039 from jpeeler/bug1749036
+160f52e26 (doc) How to update operators documentation
+03d4e769a test(e2e): add operator group SA permission tests
+17c04dc5a fix(olm): requeue as needed upon permission changes
+fed600926 fix(olm): handle CSV install failure gracefully
+0cbd28c9b Merge pull request #1038 from skitt/go-1.1x
+17bb059cc Enable vendoring on Go 1.1x
+2595af7f0 Merge pull request #1027 from ecordell/depup
+d82e71cd9 feat(olm): don't calculate a patch when updating via a replacement chain
+bb6413343 Merge pull request #983 from dinhxuanvu/removeDeprecated
+9c295523d Merge pull request #984 from dinhxuanvu/crd-update-docs
+07ea73c61 Merge pull request #1033 from njhale/fix-docs
+54923da18 chore(docs): consolidate doc directories
+dd81460e4 (doc) Add deprecated CRD version procedure and note
+3fb49bb14 Merge pull request #1031 from dimitraz/fix-links
+a92826603 Fix broken doc links
+7fb132565 Add unit and e2e test cases for deprecating a CRD version
+987952733 Merge pull request #1029 from njhale/fix-pkg-list
+089c7c915 Merge pull request #992 from camilamacedo86/fix-doc
+c05682e09 Merge pull request #991 from camilamacedo86/github-templates
+a9b2fa632 fix name of dir - replace Documentation for doc
+816ff27e2 Merge pull request #993 from camilamacedo86/README
+9ef425419 Merge pull request #1019 from skitt/dns-suffix
+fc77d31a1 fix(registry): return all valid packages
+6c2cb4840 chore(mocks): generate mock list packages client
+6a5fd922a Merge pull request #1026 from alecmerdler/bugzilla-1748771
+f934999cf Merge pull request #1018 from jpeeler/add-fields-related-objects-2
+b176583bf fix(clusteroperator): update status after initial creation
+77cce5479 fix(clusteroperator): fix naming of related objects
+85bfc4312 add default for packagemanifests/icon subresource
+4b9969934 Merge pull request #1023 from tkashem/bz-1744245
+f79647bfb Merge pull request #1025 from njhale/clean-env
+e64f62286 fix(init): cleanup leftover cross-namespace  ownerreferences
+79143ac99 feat(readme) : Ajustments
+bfefa59e5 feat(github) : Add github files in order to follow org standard
+0141a890d Bugzilla 1744245: Subscription should not point to deleted ip
+109153ae7 Drop the hard-coded DNS suffix
+0cd00dd5a Merge pull request #1011 from skitt/pgrep-no-q
+72b6a8d5e Remove deprecated CRD's stored versions to allow CRD update
+fe8dff2a9 Merge pull request #1014 from awgreene/configure-global-catalog-ns
+37467b317 feat(clusteroperator): plumb additional clients
+34a934f79 [CatalogSource] Set Global Catalog NS with EnvVar
+f67454030 Merge pull request #1013 from kevinrizza/bug-1741799
+86810199f Remove InstallPlan Source, SourceNamespace from UX
+da3c9fcd0 Merge pull request #1012 from jpeeler/add-fields-related-objects
+83341f520 fix(olm): report name and group for related objects
+be15bd5cb Stop relying on pgrep -q
+fd42877ef Merge pull request #989 from ecordell/packageserver-upgradeable
+5174ca8c6 Merge pull request #978 from tkashem/bz-1737057
+7b850f99c Merge pull request #1008 from ecordell/grpc-update
+19dfe701a Merge pull request #1006 from tkashem/bz-1740332
+5edeb9c0e feat(sources): syncronize access to lastupdatetime for sources
+73fdcf346 chore(deps): update grpc dependency
+1c75ca4c8 Bug 1740332: OLM should resume operator install
+9cb7d109d Merge pull request #1005 from alecmerdler/bugzilla-1744490
+ae365b171 Merge pull request #1002 from alecmerdler/bugzilla-1727800
+dc39aeaab add packagemanifests/icon to aggregated OLM RBAC roles
+2445a1902 Merge pull request #998 from ecordell/update-perms
+335bb6c01 Merge pull request #980 from dinhxuanvu/display-catalog
+b4d5adf5d Merge pull request #973 from dinhxuanvu/crd-versions-fix
+64ab35654 Merge pull request #970 from jpeeler/cleanup-roles-sa
+4a4ae9c85 Merge pull request #939 from tkashem/csv-reporting
+543a27d08 Merge pull request #924 from galletti94/master
+f489d8cd9 feat(operatorstatus): report packageserver as upgradeable
+200084864 test(e2e): add test verifying permissions are updated during an operator upgrade
+3ea223264 Bugzilla 1737057: Sub CRD does not validate config
+daba5228a Merge pull request #1001 from tkashem/fix-missing-ip
+73d5df35f filter icon fields from PackageManifest object (use packagemanifests/icon subresource instead)
+73e74d015 Bug 1744245: recreate of sub should not fail install
+6a81f7f0a Merge pull request #990 from alecmerdler/OLM-1211
+e1ade4bb0 packagemanifests/icon subresource
+5b4a0053f fix(spelling): just a comment correction
+1a0325a02 fix(olm): clean up resources on CSV deletion
+cf4349220 fix(subscriptionconfig): add missing merge struct tags
+ce42d8bac refactor(operatorstatus): make monitor constructor variadic
+9bd7065bf feat(scripts): add shell lib with some common helper funcs
+0b60b8ee7 test(e2e): ensure resources are deleted after CSV delete
+d885cf2ad Merge pull request #985 from alecmerdler/OLM-1211-proposal
+5209579a0 Merge pull request #974 from tkashem/catsrc-status
+987609830 Bug 1737081: catsrc status should show error
+beda2d82d Merge pull request #987 from jpeeler/local-ns-rename
+3b10b4189 Bug 1732914: Operator upgrades fail when versions field is not set
+a6605bd75 fix(deploy): change local deploy to use olm namespace
+75d7ad1fe add proposal for 'packagemanifests/logo' subresource
+7281b9125 test(grpc): add basic connection event tests for source manager
+f9ae16b49 feat(grpc): adds grpc source manager which notifies main controller when grpc events occur.
+c485cad60 Merge pull request #960 from dinhxuanvu/relatedobjects
+4dba884c8 Bug 1702552: Two "NAME" fields by command "oc get catalogsource"
+3c06e88e9 Merge pull request #969 from tkashem/doc
+9c683f5ae Merge pull request #968 from tkashem/release-doc
+6bd80c98b bug(1717636): Add relatedObjects to cluster operator status
+4edaafada Merge pull request #971 from kevinrizza/report-upgradeable-clusteroperator
+c8bfa53a4 Merge pull request #965 from jpeeler/existing-installplan
+e781b89fb (doc) add doc for scoped operator install
+98c23f6ea Report `Upgradeable` in ClusterOperator status
+974bf5509 Merge pull request #967 from tkashem/changelog
+f77932cef (doc) update make new release doc
+67d15b445 (release) update changelog
+5b7433362 Merge pull request #966 from tkashem/release-0.11.0
+be4c7f2c9 Merge pull request #961 from tkashem/bz-662263
+8fa586d30 fix(unit): allow logrus log level to be adjusted
+695f6d776 fix(catalog): re-install resources in existing installplan
+6e109b4ea Merge pull request #958 from tkashem/follow-up
+8f85cafc3 (release) generate manifests for 0.11.0
+27b5042b7 (e2e) fix e2e test flakes
+202406f45 (feat) requeue the csv when subscription changes
+360f75b35 Rename and remove commented code
+c5564e7cd Merge pull request #962 from tkashem/release
+3e65dc786 (feat) empty proxy env var should result in unset
+484b866ca Merge pull request #959 from cblecker/label-panic
+db884e743 (release) cut a release for 0.11.0
+25e399052 bz-1662263: include git sha in ART builds
+ca02a92b2 Fix panic when binding already exists
+497b67c66 Merge pull request #955 from jpeeler/set-resource-requests
+76a3554ed Merge pull request #957 from ecordell/fix-env
+1ab0d8b96 Merge pull request #950 from tkashem/pod-configuration
+c613ffc1b Merge pull request #933 from dinhxuanvu/cr-validation
+c0e4f825e Add e2e test case for existing CR validation
+8a48e657f Validate existing Custom Resources against new schema prior updating
+34f07ed3b (test) add e2e test
+74e6e3059 (feat) inject 'Env' from config to deployment spec
+3c56773db (feat) incorporate proxy configuration support
+b52e789a7 add operator configuration to subscription spec
+d4d3428b0 Merge pull request #954 from njhale/pin-1.14
+a2f47f1d6 fix(unit): refactor to use shared pod resource
+77ce42156 fix(manifest): fix env var projection in command
+1cad4c865 feat(deploy): add resource requests to all pods
+e176196fc Merge pull request #951 from ecordell/metrics
+2808ec7e6 chore(modules): re-vendor
+a359bf757 chore(generated): run code/mockgen
+7aaa69e45 chore(modules): pin k8s 1.14
+cd6fb9a51 feat(metrics): record sync count for subscriptions, labeled with name and most recently installed CSV version
+b4e3f5de2 Merge pull request #2 from dweepgogia/project-proposal
+64b09c24f [doc] Add fake README to the project proposal
+d4825c74b Merge pull request #942 from ecordell/csv-packageserver
+c1ea748d2 fix(init): move cleanup to olm startup
+fecaec053 feat(metrics): record sync count for CSVs, labeled with name and phase
+b4f8827e9 feat(init): add init container to olm operator that can clean previous deployments
+6065197ee chore(deploy): remove packageserver subscription and catalog from chart
+f226d7255 Merge pull request #902 from jpeeler/crd-schema-change
+a116896c9 Merge pull request #943 from njhale/catalog-benchmarks
+767b0fd70 Merge pull request #945 from jpeeler/minor-fixes
+7f8c31725 fix(olm): List does not return NotFound error
+477b0affa fix(e2e): fix baremetal e2e
+7a38a5d04 Merge pull request #941 from ecordell/config-proposal
+71c15a6fb test(catalog): add sync resolving namespace benchmark
+752740f21 Merge pull request #931 from operator-framework/depupdate
+4c60d4c64 feat(olm): allow CRD updates with multiple owners
+861fa27bd feat(csv): detect changes to a deployment and persist them
+55478901a proposal(operator-config): initial proposal for persisting configuration of operators
+1940f7bd0 Operator validation library project proposal
+30d6fa5e6 Merge pull request #929 from njhale/pprof-option
+11687df4c Merge pull request #938 from njhale/remove-extra-comparison
+cf83a2842 Merge pull request #913 from jpeeler/proposal-webhooks
+2b551453a (proposal) improved csv status reporting
+58378e8af test(e2e): remove extra resource comparison
+7cbf34848 Merge pull request #937 from tkashem/bz-1723818
+0c5c34bc9 1723818: package server 4.1 to 4.2 upgrade should not fail
+c236361d2 Merge pull request #921 from jpeeler/compile-bare-target
+f058be7b3 Merge pull request #925 from tkashem/bz-1723818
+9c7f7d278 (bug) CSV name change causes upgrade to fail
+79684d6bb Merge pull request #892 from tkashem/user-defined-sa
+d9043cfc1 Add webhook proposal
+224ada1dd docs(profiling): add basic usage doc
+00826e8e1 feat(cmd): add profiling option to olm and catalog commands
+3a7164c7a feat(profiling): add pprof handler registration function for mux servers
+752da4774 Merge pull request #928 from paulfantom/servicemonitor
+6458351fc manifests: move ServiceMonitor manifest to runlevel 90 so it will be applied after ServiceMonitor CRD is created
+3ac82ee37 (e2e) add e2e test for user defined service account
+47260e13d (feat) validate that secret is valid api token
+3fb4bb161 (feat) use scoped client for plan execution
+7eb33d819 Merge pull request #923 from njhale/sub-ips
+a532d6c85 chore(logging): logging fixes / small enhancements
+53c918399 chore(modules): add hashstructure and revendor
+7d238a85e test(sub): add subscription installplan condition e2e test
+521979f76 feat(sub): add installplan reconciler to syncer
+593589aab feat(sub): add installplan status reconciler
+65593bd22 feat(state): add subscription installplan states
+6305b1324 feat(sub): add subscription installplan status conditions
+f16d8f0c9 feat(equalitor): add equalitor interface and hash implementation
+465214e5c (feat) create scoped client from bearer token
+f436600b1 (codegen) generate operator group type changes
+71b4951ac Merge pull request #863 from tkashem/csv-monitoring
+72d20ecf5 Merge pull request #920 from jpeeler/does-anybody-ever-read-these
+5f5f2eda6 feat(makefile): add target for compiling e2e
+14d62744f Merge pull request #878 from dinhxuanvu/update-crd-one
+729de7a54 fix(test): fixup bare test imports and vars
+54441a84f Merge pull request #917 from dinhxuanvu/update-changelog-0.10.1
+1b14b82fc Update CHANGELOG to include changelogs from 0.10.0 and 0.10.1
+e4ecf57fb Merge pull request #916 from jpeeler/release-docs-2
+73b071c57 (feat) monitor package API server CSV progress
+75590ea49 Receive notification of CSV(s) being watched
+b4b70b918 (deploy) add cluster operator for package server
+d89e8353f Merge pull request #918 from jpeeler/fix-go-build
+da97549ac fix(build): set GO111MODULE=on
+bec3a473f docs(release): add additional clarifying details
+eb110c940 Merge pull request #914 from ecordell/go-1.11
+5a9c3ca03 Merge pull request #889 from dinhxuanvu/release-0.10.1
+100a23bb8 Switch to go 1.12 in the root Dockerfile
+a486f5aba Add a new test case to cover preexisting CRD case
+0e806f146 fix(unit): fix unit test flake
+90229baa4 Merge pull request #912 from ecordell/remove-helm
+c6905c3e1 Add e2e test case for single owner CRD update
+9a16d4a92 Add IndexFunc using ProvidedAPIs as key to look up CSVs
+86faf88b0 Enable OLM to update CRD when there is only one owner of that CRD
+d523fb5c3 make release 0.10.1
+33a13e5fe Merge pull request #900 from ecordell/fix-owner
+5ee8bce5b Merge pull request #910 from jpeeler/crd-descriptions-3
+3fe51df5f Merge pull request #911 from njhale/sub-csh
+b62dc0a67 fix(build): don't use helm in src image
+bf05d0477 feat(queueinformer): add config options
+f09e47ad0 fix(chart): add missing descriptions to operator group
+579aa8ddd fix(catalog): do not add owner references to clusterroles or crbs
+d8084e48c Merge pull request #881 from njhale/sub-csh
+f8a5ca06a Merge pull request #909 from jpeeler/kubeconfig-env
+b2c649bae feat(e2e): allow KUBECONFIG to be set from env
+8be3ad854 Merge pull request #907 from madorn/patch-5
+bb4c35aa7 add -l option to $POD_MANAGER attach
+83fd61813 test(subscription): add e2e tests for catalog health
+aa6c82b93 test(bare): use new operator constructors
+cc58cc72e chore(codegen): generate conversions/deepcopy
+8892cd38d feat(subscriptions): add catalog health conditions
+162483988 refactor(packageserver): plumb context throughout
+3707deed5 refactor(main): use signal context and new operator contructors
+ca20e6350 refactor(olm-operator): replace factory method parameters with options
+49fc05754 refactor(catalog-operator): use new queueinformers
+25e078a77 feat(subscriptions): add subscription catalog health syncer
+7f2bcbc5a feat(registryreconciler): add now function
+9cdccba5a refactor(operatorstatus): make sync channel receive-only
+2e4bc7f77 refactor(queueinformer): use kubestate resource events
+55295262c feat(kubestate): add generic typestates and interfaces
+10ae9f8f0 refactor(signals): replace stop channel with signal context
+2d43a3749 Merge pull request #904 from alecmerdler/OLM-1111
+fc4a5ea62 clone labels from CatalogSource to PackageManifest to prevent concurrent map writes
+485474201 Merge pull request #880 from tkashem/operator-group-sa
+248c669be (proposal) Add user defined service account
+e68056973 Merge pull request #890 from alecmerdler/OLM-1080-redux
+6269a6792 Merge pull request #885 from madorn/patch-4
+619c2035b change packageserver global namespace to openshift-marketplace
+4acee7fbf Merge pull request #887 from dinhxuanvu/release-version-0.10.1
+2db8ef0d3 Bump release version to 0.10.1
+4f147c4bc Merge pull request #871 from alecmerdler/OLM-1080
+84ad7ab88 Merge pull request #864 from ecordell/1.14
+2df701059 add --rm, remove cleanup func, and attach to block
+2b167dd5e chore(deps): bump kube deps to 1.14
+c4d210a71 repair run_console_run.sh script
+74dfdf377 change global catalog namespace to openshift-marketplace
+a4b8ea757 Merge pull request #875 from ecordell/installer
+2ee6f96af Merge pull request #876 from marcoderama/doco
+c05651951 Merge pull request #877 from njhale/internal-types
+02ec025a2 chore(types): codegen internal convs, clients, listers, and informers
+74aa5da51 refactor(codegen): add conversion to make rule
+513db51ae refactor(types): add internal types for olm resources
+97ad48e5c Documentation: Fix a few typos
+a16cf0f6e feat(install): Add new install scripts for releases, update release instructions.
+1c16bd4b5 Merge pull request #869 from dinhxuanvu/opgroup-status-ns
+b9de76ad7 fix(operatorgroup): Remove namespaces requirement for opgroup status
+1aa1059df Merge pull request #867 from jpeeler/release-docs
+712241bb0 Merge pull request #861 from ecordell/grpc-close
+f57626747 Merge pull request #866 from jpeeler/manifests-bump-0.10.0
+0cac27e56 docs(release): add basic steps for making release
+8bcd68729 update manifests to 0.10.0
+775721557 Merge pull request #865 from jpeeler/version-bump-0.10.0
+7fdeba2a2 bump version to 0.10.0
+393ec5613 Merge pull request #754 from alecmerdler/OLM-954
+4d650f944 Merge pull request #860 from tkashem/refactor
+5e2b3d8ab fix(catalog): close grpc connections before deleting them
+a29307be8 (refactor) Move csv set and replace to a package
+ef08dc726 Merge pull request #750 from jpeeler/apiservice-sync
+7e04af578 Merge pull request #837 from jpeeler/unit-flake-fix
+26af2e8cd Merge pull request #856 from ecordell/adming-ag-test
+20c1d0760 add provided APIs to PackageManifest
+c0f804775 Merge pull request #795 from alecmerdler/OLM-974
+df7c96c56 fix(unit): fix flake in TestUpdate
+c16b50b28 fix(unit): operator group test flakes
+4562dc0a8 fix(olm): unit test flakes
+043d9a059 feat(unit): allow specific unit test execution
+7ca42e8c5 added e2e test for garbage collecting ClusterRoles
+3c911f062 Merge pull request #859 from dinhxuanvu/util-test
+e5b27ae45 Merge pull request #851 from dinhxuanvu/op-ns
+ad50da316 Merge pull request #852 from ecordell/fix-release-scripts
+290a2b95b fix(unit): Remove leftover println causing excessive log in unit test
+45ce08c51 fix(operatorgroup): No targetNamespaces matched namespace selector
+235928b97 Merge pull request #839 from dinhxuanvu/catalogSourceNS
+734031b1a test(olm): test role aggregation for aggregate apiservices
+acda68d68 Merge pull request #858 from camilamacedo86/ISSUE_785
+458ebf0b1 fix(run_console_loca): Fix command and improve output message
+3d61dac26 chore(deploy): install helm in `src` image so that verify manifests job can run
+9cd805b5a chore(deploy): re-sync manifests with the chart
+e3e248a60 chore(deploy): add `verify-manifests` command to ensure chart and manifests are synced
+a52e043e4 chore(deploy): fix release scripts
+2cc4af52a Merge pull request #821 from tlwu2013/patch-2
+ae27eea1f fix(catalog): Fix subscriptions without a sourceNamespace hang forever
+e900058b7 Merge pull request #855 from ecordell/fix-testupdate-flake
+414aa3be2 Merge pull request #806 from marcoderama/doco
+9bdf1de7b Merge pull request #751 from lveyde/patch-1
+6184c4682 Merge pull request #768 from leszko/support-windows
+6804a283a fix(unit): TestUpdate no longer flakes
+d0e13ea7b Merge pull request #787 from bergerhoffer/fixing-indentation
+01b28833b Merge pull request #848 from jpeeler/crd-descriptions-2
+5a9c4e370 Merge pull request #850 from ravisantoshgudimetla/fix-tolerations
+3d549003c Fix tolerations
+ac3a5d268 fix olm-operators tolerations
+4a4d4b4fd Merge pull request #847 from ecordell/fix-stuck-subscriptions
+c369b8040 Merge pull request #844 from alecmerdler/bugzilla-1707071
+23a2a2f70 fix(deploy): add missing descriptions to manifests
+fd2f765e8 Merge pull request #845 from jpeeler/crd-descriptions
+c5173bf50 Merge pull request #843 from ravisantoshgudimetla/fix-tolerations
+3db37f805 fix(catalog): fix issue where subscriptions sometimes get "stuck"
+f5ed53df4 fix(deploy): add missing descriptions
+9679a7b1a Fix tolerations
+0d7cb55c3 add terminationMessagePolicy: FallbackToLogsOnError to OLM deployments
+7682b0c4e Merge pull request #816 from ecordell/udpate-catalog
+dfe90fbed fix(e2e): fix installplan test cleanup
+0111c45df fix(operatorgroups): fixes rbac checking for multinamespace groups
+ea0d3fc86 feat(olm): speed up csv updates
+5fc146ac8 test(catalog): add tests for catalog reconciliation
+2ede4ad35 feat(catalog): check catalog health and recreate if bad
+dffcbd5c2 fix(roles): use correct group for package permissions
+f20a80348 Merge pull request #838 from ecordell/fix-dependent-subs
+78e6f5110 fix(e2e): test changes
+f78dd528e Merge pull request #836 from tkashem/csv-conditions-length
+7fba013a2 feat(resolver): treat the registry as the source of truth for replaces fields
+ee20bf553 fix(olm): race when a subscription updates many versions
+13853d1e5 fix(resolver): resolved dependent subscriptions don't detect updates
+9b9996139 Merge pull request #834 from ecordell/semver-range
+6ad4be7ee Set limit on length of Status.Conditions of a csv
+c8ac766c4 Merge pull request #766 from jianzhangbjz/fix-provider
+269395ff6 fix labels.provider issue
+a6a3dde51 Merge pull request #835 from njhale/fix-registry-recreation
+46de47618 feat(resolver): allow skipping a set of updates if the channel head explicitly states that a range of existing operators can update directly
+974f55c36 fix(catalogs): make grpc registry check for < 1 pods
+12f359087 chore(deps): switch to blang/semver from coreos/semver
+a0dcab078 Merge pull request #827 from dinhxuanvu/missing-events
+561653551 Add e2e test case to verify the events flow
+ad4e44a3d test(reconciler): refactor reconciler tests with k8s decorator
+dcd80b0eb test(clientfakes): add k8s client decorator and shared options
+6da60367b Merge pull request #833 from ecordell/fix-e2e
+65c2c7ec7 fix(permissions): the aggregated edit role should grant view access to operatorgroups
+41d292433 fix(olm): don't requeue operatorgroups for deleted copied csvs
+0084a2cb7 test(e2e): wait for deployment to exist in csv replacement test
+e51da8160 Merge pull request #830 from soltysh/fix_nil
+f357dce93 Always set LastTransitionTime in OperatorStatusCondition
+5cc96d51e Merge pull request #828 from ecordell/revert
+bc697200d Revert "chore(cvo): remove ClusterOperator from manifests"
+3205c4f7f fix(olm): Fix the issue with missing events due to rate limit
+bc0524ca2 Merge pull request #824 from ravisantoshgudimetla/add-annotation
+7f77eb0c3 Merge pull request #826 from ecordell/upgrade-ts
+dce549eb0 chore(cvo): remove ClusterOperator from manifests
+283c67b89 Merge pull request #817 from jianzhangbjz/priority
+0a3e83439 Add node-selector annotation to namespace
+b05b06a17 Merge pull request #823 from ecordell/update-cvo-libs
+065e52da6 chore(cvo): update openshift/api so that OperatorFailing is changed to OperatorDegraded
+b5bb2cdde One more doco typo fix
+0f9416ed7 documentation:  Fix a few typos.
+463caa2a0 Merge pull request #820 from njhale/sub-ip-ref
+de57dceee Add validation details for `spec.maturity` field
+3f5a8fecd refactor(queueinformer): prevent > 1 run calls for duplicate informers
+d01b225f1 refactor(subs): add objectreference installplan refs
+0092750c5 feat(types): add reference for olm types
+50dbe5e51 chore(deploy): update manifests
+9d3034efa add priorityClassName attribute
+4af9f7b4c Merge pull request #812 from ecordell/admin-perms
+3f4906359 Merge pull request #811 from ecordell/progressing-timestamp
+90c8a604d Merge pull request #759 from dinhxuanvu/deployment-update
+fcdebc4e6 Merge pull request #813 from ecordell/packages-ns
+9f3f393a3 Merge pull request #809 from jpeeler/wip-test-mux
+ef518dcff feat(packageserver): add additional info to package server output
+30defa3e0 Modify and improve unit test on deployment
+c7d6cae8d Rework cleanupOrphanedDeployments
+74f236c2c fix(deployment): Clean up orphaned deployments
+3726aed3a Merge pull request #807 from njhale/fix-registry-recreation
+11ee3da7d fix(catsrc): force registry update on dep resource deletion
+232bd9ad1 feat(registry): add registrychecker
+29c6d4b43 feat(lister): add catalogsources to operatorlister
+5f55b4279 chore(mocks): regenerate mocks/fakes
+3b2cdd80f chore(vendor): vendor mock/fake dependencies
+fc5805d02 chore(mockgen): use modules for mockgen
+a4085910a test(catalog): add registry pod delete e2e test
+0eb0a4d80 feat(rbac): restrict permissions for namespace admins
+a6a368013 chore(cvo): report progressing=true if the version has updated
+affc657d3 fix(e2e): metrics are now served 8081
+eeff07c7a fix(metrics): remove optional from secret parameters
+5490daeac fix(metrics): add logging and separate muxer in catalog
+54f6dc0ec Merge pull request #794 from ecordell/starting-csv-multiple-ips
+58d3c806f fix(metrics): add logging and separate muxer in OLM
+ecae4ef2b fix(e2e): remove ip count check
+e7efbc995 fix(olm): generate rbac roles for ownnamespace operators correctly
+c83204b18 test(aggregation): Add test for operatorgroup role aggregation
+9d04dc404 Merge pull request #810 from njhale/changelog-0.9.0
+c3b888e32 docs(changelog): regenerate changelog for 0.9.0
+d62135c00 docs(release): add release doc with changelog generation section
+68006792b Merge pull request #802 from alecmerdler/OLM-1017
+7b6d2fcc0 test(e2e): add sanity check for project admin permissions
+11c7da475 test(subscription): add additional testing around installplan generation during manual approval subscriptions
+77dd28b3e Merge pull request #805 from njhale/fix-modules
+1b34ba16c fix(git): remove nuget ignore rules
+327865338 chore(modules): revendor
+35a7f1301 cut release 0.9.0
+aea532d65 fix(modules): update replaces fields
+378fabf39 Merge pull request #801 from alecmerdler/cut-0.9.0
+0fc1030a1 test(e2e): add test for orphaned api services
+5de67db91 bump version to 0.9.0
+8d459b889 end-to-end test for cleaning up apiservices after CSV delete
+9290d5345 fix(olm): add deletion monitoring for api services
+c84c2540f Merge pull request #741 from njhale/sub-status-proposal
+b5c396c60 Merge pull request #775 from ecordell/priorityclass
+232422018 docs(subscriptions): add improved sub status proposal
+f30961255 Merge pull request #793 from jpeeler/rebase-1.12
+ceb060a99 chore(deploy): set priorityclass on olm pods
+b6d295303 Merge pull request #792 from ecordell/fix-deploy-annotation
+83d1d4195 fix(annotation): don't annotate deployments that aren't owned by a CSV
+9981cadc0 Merge pull request #791 from njhale/fix-back-support
+a76cdf732 chore(package-server): adjust to new API
+c7cc3067c chore(vendor): add jsonpatch
+949333e51 chore(codegen): regenerated due to vendor updates
+940e2a673 chore(vendor): update vendor directory
+b69917ae6 chore(vendor): prep for update to 1.12.7
+04ec6ba04 fix(packageserver): add struct tags to PackageManifestList
+24e5f435b Merge pull request #788 from njhale/back-support-pkgs
+60cfcc8eb chore(codegen): run codegen and mockgen
+375682d11 feat(packageserver): support apps.redhat.com and operators.coreos.com
+a1e329edf Fixing indentation for spec field
+5fcebfbaa Merge pull request #774 from ecordell/api-v1
+5521fd34f chore(deploy): regen /manifests
+13c9c6ed9 refactor(charts): normalize packageserver templates
+df200f5fc Support v1 OperatorGroup and v1alpha2 OperatorGroup
+647666533 chore(api): bump operatorgroup and packagemanifest to v1 and group operators.coreos.com
+85dd72356 Merge pull request #682 from jpeeler/metrics-add-servicemonitor
+a3dd5dab4 chore(deploy): don't include openshift stuff in upstream
+64194fdc4 fix(deploy): move service creation to new file
+84948471d fix(metrics): add service monitor config
+544ec926b feat(templates): make use of TLS options in deployments
+d65ca70dd feat(olm,catalog): add TLS support for metrics
+cbdd04dd5 chore(deploy): renumber files from 02* onwards
+ce6651da0 Merge pull request #778 from ecordell/fix-api-labels
+a5953899d Merge pull request #776 from ecordell/progressing-metrics
+a960f43d0 Merge pull request #777 from ecordell/faster-local
+044e1af26 chore(deps): bump openshift/api to get new ClusterOperator types
+4327a42f8 fix(olm): use hashes for provided api labels
+4443b14a0 chore(build): build binaries locally and load them into containers
+ba1e984c0 chore(catalog): add ClusterOperator status for catalog operator
+0826a7f90 Merge pull request #771 from njhale/recut-0.8.1
+47103b038 chore(manifests): recut 0.8.1
+396935e4d Merge pull request #765 from njhale/add-changelog
+10dd7c2ab docs(git): add changelog
+b265e8455 Merge pull request #764 from ecordell/ns-list-for-all
+e850b337e Add support for Windows WSL in run_console_local.sh
+06f50aecc Merge pull request #763 from njhale/csv-crd-requeue
+daef19a8a feat(csv): label CSVs with provided/required apis
+4b5c59de2 fix(build): add some minor support for building locally with kind
+72376e8fc feat(operatorgroup): operators in operatorgroups that select all namespaces are now granted namespace view roles (get/list/watch)
+f6baedc32 test(e2e): add failing e2e test for operators in global operatorgroups
+c4bb8b126 Merge pull request #762 from ecordell/upstream-catalog
+91ac21027 fix(chart): persist operatorstatus reporting changes to chart
+deb826a73 feat(upstream): add operatorhubio catalog to upstream release
+a4cb71cdf Merge pull request #760 from tlwu2013/patch-1
+c9e7be947 Merge pull request #722 from jpeeler/cvo-upgrade
+bde122446 fix(installer): include generated manifests
+5e0b2ea2d fix(ocp): add csv and deployment for package server
+caaa4a3ce Merge pull request #761 from ecordell/multiple-upgrades
+43a6a75e0 feat(e2e): generate a larger set of namespaces during testing
+49fff8558 fix(e2e): use ifnotpresent for all test images
+bc1a2efe8 fix(olm): don't attempt to annotate deployments if the deployment hasn't yet been created
+c3a87aff3 fix(catalog): kind was omitted from ownerlabels
+150e5e774 fix(operatorgroups): gc copied csvs from a separate queue
+87a468e04 fix(e2e): e2e test for pre-existing crd owner tested incorrect behavior
+aad72bd04 fix(resolver): take a snapshot of the current generation before updates
+7e402189d fix(catalog): fill the csv cache with informers
+dfafa089b test(subscription): add an e2e test for validating that subscriptions step through multiple intermediate versions
+1c5cd4c8b Merge pull request #752 from njhale/change-upstream-base
+e56fe1134 refactor(images): use operator-framework namespace for all olm images
+77119f2db feat(make): add quickstart generation to release rule
+37b777559 chore(docker): update upstream.Dockerfile base to go 1.12
+7a7e799cf refactor(scripts): use existing manifests in package_quickstart.sh
+8e749eaa0 style(scripts): rename package-release.sh to package_release.sh
+f48dd912f chore(modules): revendor
+c543c6de7 Merge pull request #748 from smarterclayton/report_level_status
+0a1f38560 clusteroperator: Report when OLM reaches "level" and check syncs
+e8bb5e7c0 Merge pull request #758 from njhale/fix-conflict-detection
+cf9b23893 Fix typo - k8s version format
+0f7f70b60 fix(csv): properly detect owner conflicts for crds and apiservices
+a56211824 fix(transitionCSV): reorder apiservice resource check
+bea78fcb5 Merge pull request #749 from alecmerdler/bugzilla-1654977
+54c581ecd more event emitting for CSV phase transitions
+7065a6af9 more event emitting for CSV phase transitions
+4b74799ce Fix small typo.
+e14a4d9dc Merge pull request #736 from ecordell/opgroup-expand-contract
+99e2789b9 fix(contraction): requeue any csv that may need it after operatorgroup expansion/contraction
+fa5a473c8 feat(olm): update deployment annotations as soon as the csv annotations are available
+d61293557 fix(e2e): fixing e2e test after rebase
+4b373f2d4 chore(rebase): fix errors from rebasing
+5520800a6 fix(opgroup): incorrectly detecting CSVs as "copyable"
+7d192ef48 fix(operatorgroup): set labels on copied resources correctly
+f53e33ae3 fix(olm): move csv copying into its own workqueue to free up csv processing
+b316d13d0 fix(e2e): fix e2e tests for operatorgroups
+aef7bb9f2 refactor(olm): refactor provided api pruning
+24e1f5b78 refactor(olm): simplify CSV copying/pruning
+d4f6e448c feat(namespaceSet): add Contains method to namespace set
+229a7640c feat(olm): don't copy csv to operatorgroups if it's not in certain copyable states
+02bb42210 fix(olm): delete copied child csvs with no parent annotations
+299d1f62d fix(operatorgroup): annotate all csvs and allow collisions
+55f60797a fix(olm): delete stale resources after op group change
+0d2443f71 fix(opgroup): revert order of operatorgroup updates
+880c3bcb4 fix(requeue): requeue owners that are referenced with labels
+5ad676ac8 fix(olm): change operator group / CSV requeuing
+82bd6628d chore(opgroup): allow selector to be nullable so that marshaller can output an allnamespace operatorgroup
+995a686cb Merge pull request #704 from leseb/git-objects
+ee078b270 Merge pull request #713 from operator-framework/update-csv-link
+8d599a1bc Merge pull request #745 from jpeeler/deploy-status
+7dcfade0a Merge pull request #690 from dinhxuanvu/api-owner
+400c2a8e1 feat(test): adds CSV phase reporting for package server
+47f938c6c fix(test): fix labelselector pointer
+7904558b1 fix(olm): delete api services upon CSV deletion
+2525021e7 chore(olm): add debugging logging and handle potential list failure
+2676da569 fix(util): fill in GVK info from InferGroupVersionKind
+33a71df8e fix(olm): Fix CSVs api-servers battle for ownership of APIServices
+684b7e51f Merge pull request #739 from dinhxuanvu/minkube-validation
+1ec96efc4 Make release
+1bcaded95 Add minKubeVersion validation to templates
+f6e7cdc30 Merge pull request #744 from njhale/update-group-manifests
+8bda3c94a chore(manifests): regenerate manifests to include new validation
+2d87dd9c3 fix(operatorgroups): use pointer for labelselector
+1164ff67a Merge pull request #733 from njhale/fix-installmodes
+65007bf93 Merge pull request #738 from ecordell/ifnotpresent-packageserver
+206a2c418 fix(packageserver): set packageserver to IfNotPresent
+541bc8eb5 refactor(operatorgroups): bail out after successful namespace update
+a39619335 Merge pull request #716 from alecmerdler/ALM-913
+c348d6f2b Merge pull request #671 from aweiteka/rbac
+df6116e36 fix(csv): fix unsupported operatorgroup status update
+7d017d5a7 test(operatorgroups): add installmode support e2e test
+28f94c0cd Merge pull request #721 from njhale/operatorgroup-docs
+4b00253c1 fix(installmodes): update support logic to match expected behavior
+92bb1510b docs(operatorgroups): add more extensive docs
+83a62d13a Merge pull request #731 from ecordell/pkgmanifest-api
+1e3248dbc fix(packagesever): add missing name field to api definition
+7148266d7 Merge pull request #729 from ecordell/cross-ns-ownerrefs
+5843601e4 fix(owners): remove cross-namespace and cluster->namespace ownerrefs
+50ebe7b8c chore(deploy): run release scripts to get view permissions on edit/admin
+c2e9072ee Merge pull request #720 from dmesser/quickstart
+812ce8a35 Merge pull request #723 from ecordell/remove-regex
+29dc1c34e fix(csv): remove regex on base64 image data
+d94cc58ef add all-in-one yaml and helper script
+4b95eeaa4 Merge pull request #717 from ecordell/add-use
+d8ae7c5c3 fix(csv): icons in csv schema should be an array
+3cca62d35 feat(csv): allow use verb in permissions
+bc48633c3 fix API validation for OperatorGroup spec
+33b98af21 remove minishift support
+8be006590 Merge pull request #710 from jpeeler/clusteroperator-discovery
+c04306f22 Merge pull request #709 from njhale/grpc-address
+5bf5bbbe0 Merge pull request #708 from njhale/tolerate-masters
+b3869c50b fix(registry-pods): add everything toleration to registry pods
+acfadef73 feat(catalogsource): allow grpc source types that don't require an image
+75ad2fb44 Merge pull request #711 from alecmerdler/ALM-910
+8b5c584fc fix(olm): properly detect cluster operator API
+c49999a1c docs: update CSV link
+039e47176 remove rbac changes to 0.7.1 deploy maniftest
+c44d485a8 update aggregate clusterrole to chart template
+24bbd94f7 add view rbac to 'admin' and 'edit' default roles
+952d5eba8 graceful shutdown for PackageManifest server
+a3092c17b Merge pull request #712 from njhale/fix-prefixes
+745728d12 fix(manifests): start manifest file names with 0000_50_olm_*
+794268b25 Merge pull request #701 from njhale/group-intersection
+52831522d Merge pull request #683 from pmorie/doc-install-mode
+3f92a704e fix(csv): only allow one CSV per provided API across intersecting operatorgroups
+6515a11be Merge pull request #697 from dinhxuanvu/add-installmodes-pkgm
+fbcf63306 test(registry): add InstallModes to CSV
+cc05e9bff fix(openapi): add InstallMode definition
+6e77ba0f6 Merge pull request #699 from dinhxuanvu/minkube-fix
+794f2cae0 fix(olm): Remove the "v" prefix in minKubeVersion if presents
+6a466f953 revendor and run codegen
+7d9b9ee97 fix(packagemanifest): Add InstallModes info from CSV to PackageManifest
+c8fe8b023 Merge pull request #703 from jpeeler/e2e-fixes
+ca547f2df fix(e2e): fix instability in test runs
+7e2ca2e1c fix(e2e): add MinKubeVersion to helper function
+4289671f9 Merge pull request #702 from smarterclayton/add_prefix
+1563b1912 fix(deploy): Add a component prefix to manifests
+9961aa332 Merge pull request #691 from njhale/update-registry-version
+7d5cd25dd Merge pull request #693 from ecordell/downstream-registry
+ffecc1f1e chore(modules): update operator-registry module to v1.0.6
+77c6fb3a9 Merge pull request #695 from ron1/patch-1
+aeeba1161 Update README.md
+6a65344bb Merge pull request #676 from njhale/fix-startingcsv
+1cca69c52 fix(subscriptions): respect startingCSV
+85cc30498 fix(deploy): fix image references
+b51fc99c3 fix(deploy): set writeStatusName for ocp builds
+302070fa3 Merge pull request #688 from ecordell/command-pod
+03ac86373 Merge pull request #652 from jpeeler/operator-status-2
+f07c0def0 fix(installplans): only create installplans if something new has been resolved.
+4d4253a3a chore(olm): run make vendor
+f58894422 feat(olm): write operator status by default
+c89cef935 fix(reconciler): set command in pod spec of registry images
+ff8c20dc8 Merge pull request #689 from njhale/fix-ip-race
+a8e57bb9d fix(subscriptions): add check for csv manifest dif before applying new installplans
+000a4b3b0 fix(e2e): ensure all subscriptions are deleted in replacing test
+d5a3c2502 fix(subscriptions): fix race between subscription sync and cache
+9b43046b6 Merge pull request #687 from ecordell/fix-perms
+683f9d7eb fix(permissions): Generate unique Names for permissions
+6a74e5d54 Merge pull request #685 from alecmerdler/ALM-873
+73a8ea8e7 Merge pull request #681 from alecmerdler/ALM-878
+03b814372 add ownerReference to backing ConfigMap for given CatalogSource
+87acfcab0 Merge pull request #679 from ecordell/fix-multiple-installplans
+6e84542ac fix link for Package Server CSV
+5c73d1404 fix(catalog): use installplan lister instead of api client
+9bb9f5f94 feat(lister): add installplan lister
+13db70106 Add godoc for InstallModeTypes
+d2a4eb107 fix(e2e): only select installplans owned by subscriptions
+b612cf5e5 feat(catalog/olm): add tracking ids to logging
+f6145e85e fix(catalog): remove gate on operatorgroups for resolution
+72fc2a293 test(subscription): update unit tests to use the namespace resolver for subscription tests
+a6e32462a fix(catalog): move write of installplan state from installplan execution into namespace resolution - this prevents races where installplans are created twice.
+19bf93ed9 fix(installplan): only resolve if there's a subscription in the ns that isn't up to date
+9d5f6d77d fix(installplan): fix bug where too many installplans can be created
+753982892 Merge pull request #680 from njhale/fix-registry-pod-overwrite
+39afd79a9 fix(cm-reconciler): query for pods to overwrite by CatalogSource label
+b6dc9b7f5 Merge pull request #678 from ecordell/change-runlevel
+55f43b9a6 chore(deploy): change 30 prefix to 50
+8d41d3bc8 Merge pull request #674 from njhale/support-services
+6f593941e chore(style): run goimports
+fc4f30796 fix(installplans): add ability to apply Services
+77c39c393 Merge pull request #670 from ecordell/configmap-changes
+7aa6f6d79 fix(test): get kube version from client go for tests
+e8177cf17 chore(deps): vendor
+a47a41d60 fix(catalogsources): omit unhealthy catalogs from resolution
+0d408adc6 fix(installplan): fix race in installplan resolution
+f14b1bf2c fix(e2e): make e2e-local-docker work again
+ae47a6b8d feat(catalog): add grpc sourcetype to CatalogSources
+8bac3e9ef fix(registry): service label selector doesn't include resourceversion
+51d644563 fix(catalog): use a different queue for each namespace
+99c2341b7 test(catalog): add e2e test to verify configmap changes are detected
+45eb3bd23 Merge pull request #663 from dinhxuanvu/min-kube
+33bc9b39d fix(olm): Provide correct format of kube version in CSV
+81211b825 fix(olm): always return a status on minKubeVersion checks
+5bb1fa22b Add minimum kube version to CSV & check it against server version
+cca23e2dd WIP: add new minimum version field for kube
+30dfa6b9d Merge pull request #672 from njhale/fix-minimums
+cb80326e0 test(validation): add test to verify OLM can use bundles with CRDs with min/max fields
+768446ae8 Merge pull request #667 from njhale/fix-listing
+9244f819b fix(packageserver): don't error out when listing
+49cf7b8b0 Merge pull request #669 from njhale/csv-installmode-status
+10d383166 fix(operatorgroups): write out CSV status on OperatorGroup issues
+d8f98fada Merge pull request #637 from jpeeler/metrics-fix
+1e6fa8cb9 chore(deps): update vendor directory
+44c8d7a38 fix(metrics): create another endpoint for prometheus
+a5c5bfc17 Merge pull request #662 from ecordell/rm-rh-ops
+41c69e975 cut 0.8.1
+a57b51747 Merge pull request #653 from ecordell/linux-hosts
+e795f339d Merge pull request #665 from njhale/fix-target-csv-update
+68d4db92e Merge pull request #650 from njhale/packageserver-use-registry
+13be5df1c fix(operatorgroups): use copied csv for update status
+60e5583e4 test(unit): fix TestAPIMultiOwnerSet_PopAPIKey tests
+ed82334af feat(packageserver): consume registry pods
+3443609f1 Merge pull request #658 from chancez/update_metering_install_modes
+3c5bda7c7 Merge pull request #657 from chancez/local_watch_all_Ns
+2f82ff79c Merge pull request #654 from ecordell/no-gitlab
+b4c8ded42 Update metering InstallModes to support SingleNamespace
+ef0b8062c Watch all namespaces in local setup by removing watchedNamespaces in local-values
+4fd0c6691 chore(ci): remove ci checks for PRs
+10f16edaf Merge pull request #638 from ecordell/new-resolver
+e760e888b fix(deploy): add linux nodeselector
+c309e83f5 feat(registry): remove in-mem registry implementation
+77ddabd89 feat(resolver): take all subscriptions into account when resolving
+53559a257 Merge pull request #651 from kevinrizza/remove-opsrc-installation
+1a9533551 Merge pull request #645 from jcantrill/1663113_env_log_vars
+8a431d3fd Remove operatorsource installation
+e308a8102 Merge pull request #649 from jboyd01/refine-limits
+582ef02a6 Merge pull request #647 from EmilyM1/add-metering-to-OLM
+47f8c286d adding csv, crds, package for metering operator
+831b6dba5 Merge pull request #640 from njhale/csv-installmodes
+c52328bc8 fix 1663113. Add component image ENV vars to cluster-logging-operator fix 1662397. Add permissions to create shared-config roles and bindings
+15d2bd814 update Service Catalog memory & cpu limits
+521b70045 Merge pull request #646 from jcantrill/update_code_gen
+939fabd48 update codegen for 2019
+fb05ebc86 chore(codegen): run codegen to satisfy validation due to year change
+12d0a1a4d feat(installmodes): add installmodes to templates
+14f94f939 feat(installmode): add InstallModeSet
+4b9ba8f44 refactor(operatorgroup): account for TargetNamespace field in updateNamespaceList(...)
+fcebf86bf feat(csv): add installmodes to CSV spec
+73201241d Merge pull request #641 from rodrigovalin/mongodb_operator_update_06
+8e6b35965 Merge pull request #643 from ecordell/e2e-registry-pod
+63277ac15 test(catalog): add an e2e test verifying that the rh-operators catalog starts up correctly
+8cc24e049 Updated MongoDB Operator to 0.6
+5c38ea112 Merge pull request #636 from ecordell/remove-all
+e44a86e5a fix(crds): remove category all from CRDs
+7bfbac8df Merge pull request #614 from jpeeler/jeff-533
+96eb5d267 Merge pull request #633 from ecordell/requeue-subs
+0317cb73b fix(packages): add sourceNamespace to packages apiserver
+896dec301 requeue dependent subscriptions when a catalog syncs
+964e57e41 fix(sub): set subscription to failed if there's no catalogsource
+387e1c64e Merge pull request #634 from njhale/fix-run-local
+4433e8982 Merge pull request #622 from kevinrizza/master
+f1564e340 fix(charts): add operator_namespace to run-local values
+dbf5cc968 Merge pull request #629 from jboyd01/bump-up-mem-for-cm
+52da24fd7 Merge pull request #630 from ecordell/fake-registry-client
+37fbb88e3 chore(fake): add fake for registry client
+b9e0a5af5 Merge pull request #556 from ecordell/registry-pods
+e97c4a879 increase memory limits on all service catalog pods
+af2055a52 chore(deps): vendor
+8f2451f39 feat(olm): add message to requirement statuses
+8a9723e87 Install operatorsource crd and default cr
+0b97ff52c Merge pull request #616 from jpeeler/jeff-601
+60235d973 Merge pull request #618 from ecordell/ALM-785
+43b915d0e Merge pull request #621 from ecordell/awgreene-marketplace-csv
+6bf8f5c85 fix(deploy): fix marketplace manifests
+1c48eedcd Merge branch 'marketplace-csv' of github.com:awgreene/operator-lifecycle-manager into awgreene-marketplace-csv
+30c149139 Merge pull request #570 from jcantrill/aggregated_logging_csv_edits
+85cff0223 Creating csv, crd, and packages for clusterlogging and elasticsearch operators
+4d51a44e4 feat(rbac): generate cluster role for viewing CRD for each provided api
+a92f652d5 Add Marketplace csv
+5420a1fca test(registry): add checks for registry pods
+5ebf78847 feat(catalog): use operatorlister in catalog operator
+7820e5f36 feat(registry): when syncing catalogsources, generate pods that serve the operator registry api for configmaps
+e04534c48 feat(catalog): add configmap server image config flag
+f2bcb3759 feat(api): add registryservice to catalogsource status
+ba15afaae add 'get' permission for the CRD itself to the created Role
+97160b54e Merge pull request #620 from ecordell/runlevel
+bda466e37 fix(deploy): add runlevel to openshift-operators
+6c0451731 Merge pull request #617 from ecordell/require-apiservice-name
+574d29d3f fix(schema-check): fix schema check error bug and update manifests
+83dbd51ff feat(csv): make apiservicedefinition pluralname required
+4bcf04b59 chore(olm): make use of operator group constants
+241269fb0 fix(olm): don't annotate target namespace on copied CSVs
+543711d06 Merge pull request #589 from ecordell/copying-in-csv-loop
+7efdfc198 fix(unit): fix tests involving CRD status
+f8baea449 feat(olm): generate clusterroles for provided apis in csv loop and aggregate them to operatorgroup clusterroles
+51dde613e feat(operatorgroups): don't process CSVs that aren't in an operatorgroup
+56df9f650 Merge pull request #609 from njhale/package-server-subscription
+616b5904f Merge pull request #587 from galletti94/master
+3596b3dd7 Merge pull request #615 from jboyd01/serv-binding-finalizers
+7a3cc0337 chore(manifests): regenerate manifests
+220912653 Merge pull request #575 from wongma7/use
+d421664b8 Merge pull request #574 from jpeeler/architecture-linted
+d4417629d Merge pull request #573 from jpeeler/docs-operator-group
+da23b2067 add rbac for servicebindings/finalizers
+69f314566 fix(unit): use global logrus logging instance
+f284ab0f4 Merge pull request #562 from jboyd01/remove-resource-limits
+ef067d2b0 Verify CRD's condition to ensure it's registered with k8s API
+87284dc52 test(packagemanifests): add wait for package-server to be ready
+16fb5c033 feat(subscriptions): requeue dependent Subscriptions on CatalogSource sync
+1747b92f2 feat(helm): create helm templates for package-server subscription
+a930e1855 Merge pull request #612 from ecordell/image-refs
+ab2af2eac chore(release): switch image-reference tag to operator-lifecycle-manager
+b509e1e02 Merge pull request #608 from jboyd01/fix-image-repo
+bd34aad44 Merge pull request #611 from ecordell/regen-manifests
+66bb41a6e regen manifests
+290923657 chore(docs): fix markdown lint warnings
+8dd4743e2 Merge pull request #591 from jpeeler/global-namespace
+9964fb376 Merge pull request #584 from ravisantoshgudimetla/add-descheduler-crds
+2d4f256e7 docs(arch): add operator groups
+94b211a90 fix(scripts): clean up all resources when done
+0fb838472 feat(deploy): add operator group to watch all namespaces
+d6727651a chore(scripts): add quoting for safer bash
+0af032085 chore(docs): fix up whitespacing
+643d19baf Merge pull request #603 from jpeeler/operator-group-robust
+4e4e11d7c increase limits for embedded etcd
+441d9a76c use quay.io vs registry.reg-aws.openshift.com
+deae2f7b1 fix(e2e): make operator group test more robust
+451c378f1 Merge pull request #602 from ecordell/slightly-mame-gitlab
+da0f248c1 feat(ci): remove e2e tests from gitlab
+71ac2f7e6 Descheduler operator CRD, CSV
+8dee386d8 Merge pull request #594 from njhale/selfhost-package-server
+8fee1575e chore(manifests): make release
+922a67d5a feat(package-server): self-host package-server with CSV
+c931a433b Merge pull request #599 from njhale/fix-tests
+3d941d976 Merge pull request #596 from smanpathak/patch-1
+fdb68cfc1 fix(e2e): create CSV first to use in CRD ownerref
+5597fd3b9 fix(e2e): use testNamespace for ownedAPIService test
+1ef129f4f Merge pull request #590 from alecmerdler/ALM-823
+7e861bb79 fix panics in package-server
+368514919 Fix a typo in documentation
+fcdadcc35 Merge pull request #552 from ecordell/e2e
+b8e634bbd fix(e2e): set up variables for non-bare e2e runs
+7d309e83e feat(e2e-bare): add utilities for running olm and e2e locally against a remote cluster
+6a5ab53a8 feat(make): add e2e command for running from ci-operator
+5090f4140 Merge pull request #593 from njhale/use-mock-ext
+3afe9b539 test(csv): use mock-ext-server for owned apiservice e2e test
+f8455ebac Merge pull request #585 from njhale/fix-mod-checksum
+0cf3efeba fix(annotations): merge CSV and pod template annotations instead of replacing
+01ede6835 Merge pull request #592 from alecmerdler/fix-client-go
+ecaf794d3 fix client-go in gomodules
+feb00156e Merge pull request #583 from alecmerdler/issue-577
+a1fcb7965 Updating: adding description to package manifest object - solves ALM-819
+fa72497d9 Merge pull request #571 from ecordell/serviceaccount-rbac
+b15c2a945 feat(operatorgroups): move annotation projection to csv loop
+57a542525 test(operatorgroups): more comprehensive tests of operator group copying and rbac generation behavior
+b7935e6bb fix(e2e): add operator namespace to target ns list
+cada67262 fix(unit): account for correct rbac resource parsing
+f0565a877 fix(e2e): account for operator group type change
+c01878878 feat(operatorgroup): create role bindings for operator service accounts in target namespaces
+c7493bce5 add packagemanifest:aggregated-apiserver-clusterrole
+ed9c15e02 Merge pull request #576 from alecmerdler/ALM-809
+6176cc402 Add packagemanifest:aggregated-apiserver-clusterrole
+799d6b594 propagate labels from 'CatalogSource' to each 'PackageManifest'
+f8ade6d5e Make use a valid clusterPermissions rule verb
+dec89d2a8 Merge pull request #572 from njhale/fix-slowness
+a6e1a3c87 fix(csv-requeue): requeue on namespace all if all namespaces are watched
+32f42f6bc Merge pull request #568 from jpeeler/add-operator-group-2
+60df92c7d fix(olm): create cleanup function for olm deploy mod
+662dbc452 fix(olm): fix RBAC cluster role creation
+933452c2e Merge pull request #569 from njhale/caches-for-everyone
+a37c37162 feat(olm): use cache listers in olm-operator
+bb78f61e9 Merge pull request #567 from ecordell/cut-0.8.0
+ecb4902b0 cut 0.8.0
+a7deb0601 Merge pull request #566 from ecordell/fix-it
+d9177db1d chore(build): remove vendor commands from base dockerfile
+b607b33a0 Merge pull request #565 from ecordell/bump-0.8.0
+4ac8ae1ea chore(olm): add additional debug in requirements
+564bba7e9 fix(olm): add additional validation for operator groups
+3bc39b9d2 chore(release): bump version to 0.8.0
+fba0f380b Merge pull request #564 from njhale/container-mockgen
+91afee829 feat(mocks): generate fakes and mocks in a container
+74216ea18 Merge pull request #560 from njhale/redetect-deployments
+9c3ced389 fix(rbac): use separate queues for each rbac resource
+1e32a28c6 fix(queueInformers): use separate queue for each namespace
+73930379e fix(logging): use structure logging in checkAPIServiceResources
+e2289683a Merge pull request #563 from ecordell/remove-ns-annotator
+616eb9333 chore(olm): remove cleanup func from operator
+225511192 remove namespace annotator
+fe8f13cda Merge pull request #561 from alecmerdler/fix-gomodules
+06e74ef2d fix gomodules (broken by client-go mutating their release tag)
+a04f4b84f Merge pull request #554 from ecordell/go-modules
+766cc0276 chore(ci): remove verify step from gitlab
+d682ea346 feat(container): make container builds faster
+856339b9c chore(codegen): run all codegen in a container
+c63f1fd90 chore(deps): switch to go modules
+cfca0c433 Merge pull request #536 from njhale/redetect-deployments
+e1dab8b54 feat(csv): detect deployment and requirement changes in Succeeded and Failed phases
+7d4fd988b Merge pull request #545 from jboyd01/initial-rework-on-csv
+56c7d7ad6 Merge pull request #547 from rhamilto/amq-icon-update
+8fb473f33 Merge pull request #537 from rhuss/patch-1
+b5b5625c2 Merge pull request #516 from jpeeler/no-minikube
+b06aea6dd Merge pull request #480 from jpeeler/add-operator-group
+59edcdf55 fix(olm): make operator group copy CSVs more efficiently
+ff44fc7bf fix(olm): remove duplicated code
+2a76048cf chore(olm): refactor updateNamespaceList
+c91260ddd fix(unit): create OperatorGroups with initial fakes
+d6978a43c Merge pull request #548 from dinhxuanvu/multi-crd-test
+e8ac902b6 feat(build): allow skipping minikube during local builds
+316f7c0d7 Merge pull request #517 from jpeeler/fix-clean
+2535b3950 Merge pull request #549 from dinhxuanvu/olm-log-fix
+dada508cd Merge pull request #550 from jpeeler/fix-deployment-lister
+b05747619 fix(olm): set lister up for deployments
+4f7cfcb43 fix(olm): do not check namespace if casting failed
+aed3d3764 Merge pull request #541 from alecmerdler/ALM-666
+12aa70d8a fix(build): add cleanup for package release files
+f34e52b38 add 'spec.nativeAPIs' field to CSV and check that native APIs exist before install
+8c6171c56 Merge pull request #539 from alecmerdler/prometheus-service-ownerref
+a6b1a2c97 fix(olm): operator group annotations and listers
+7b8f5efd0 fix(e2e): slightly improves execution time
+8b0dab168 fix(olm): set event handler functions correctly
+1943e1880 fix(olm): refactor e2e and check annotations
+e3bb3a9ef WIP: cvs in operator namespace are being annotated, csvs in target namespaces should be annotated
+c5f7d9b35 fix(olm): adds debug logging for operator groups
+e30e107a7 Update AMQ logo to new brand standard
+35ecdcc14 Add test case for supporting multi-version CRD
+e5f4d6c93 Fix olm pod name so log to be written correctly to olm.log
+fa806225b use OpenShift's ServiceCatalog build, fix rbac + more
+d3661f9cd feat(olm): detect dangling child csvs in olm operator
+7a49edc10 fix(olm): handle copied CSVs when deletion occurs
+5c2319536 fix(e2e): update e2e for refactoring
+388f228ae fix(unit): fix race condition
+9113d09a6 fix(unit): set expected owner refs for deployments
+c03447195 refactor(operatorgroup): split apart the larger sync functions
+d8dff17ba fix(e2e): ensure created objects are deleted
+f71f79868 fix(olm): make RBAC creation resilient
+b5c332293 test(e2e): add second e2e for operator groups
+6f0cfc49c fix(unit): call Run on operator directly
+8f32e3bf3 test(e2e): add e2e test for operator groups
+956773962 fix(olm): make status updates on deployments, not CSVs
+358ece0ab test(unit): add unit tests for operator groups
+1194918a6 fix(olm): change annotations to be allocation safe
+9ec09bce4 feat(olm): copy "dummy" CSVs to target namespaces
+00914f8c8 feat(olm): handle required RBAC permissions
+ff07844dc feat(olm): make namespace updates trigger annotation updates
+7665de86f chore(olm): rename annotateNamespace to syncNamespace
+e69d38f94 feat(olm): add operator group control loop
+28fceea4d feat(olm): add CRD definition for OperatorGroup
+83c8ddae0 chore(olm): generated files
+d9528d426 feat(olm): add OperatorGroup types
+016d80f63 Merge pull request #525 from njhale/refresh-certs
+8ee21d58d feat(listers): add and use aggregate informer lister
+c6f116c99 add Service as owned resource for Prometheus/Alertmanager CRDs
+09daab0a8 feat(csv): add generated APIService resource check
+c874b5125 fix(ci): cleanup packagemanifest APIService during deploy stop job
+8601151b0 feat(csv): add succeeded to pending transition on cert refresh
+29e6ca79d feat(csv): add configurable APIService cert expiration
+44ccec038 feat(apiservices): add APIService adoption logic
+8764b2ca1 refactor(ownerutil): make HasOwnerConflicts generic
+27c684884 chore(test): bump minikube kube version to 1.12.0
+c0cb86182 Fix template values for 'olm' parameters
+bea6183ba Merge pull request #522 from alecmerdler/ALM-754
+bb32660ba fix ClusterServiceVersion CRD to allow any descriptor default value
+80442ecd0 added spec/status descriptors for Dynatrace Operator
+300e7a008 Merge pull request #530 from alecmerdler/ALM-378
+2797fbce0 Merge pull request #531 from eriknelson/add-assign-verb
+2d0164a4a emit events when setting CSV phase
+1d9d4c45e Merge pull request #534 from njhale/release-0.7.4
+72218e7c0 Merge pull request #535 from alecmerdler/add-prometheus-configmap
+2f7fb6e26 add ConfigMap as an owned resource for Prometheus CR
+aa65ab4b8 Merge pull request #528 from aditya-konarde/patch-1
+d89177d0b chore(release): cut release 0.7.4
+c5b58ca29 Merge pull request #533 from njhale/bump-version
+de07a94d3 chore(release): bump version number to 0.7.4
+47f0b771b Add `assign` verb to csv crd
+27bb0da72 Merge pull request #526 from njhale/enable-auth
+0c04d0e29 Merge branch 'master' into enable-auth
+6f5f588d6 Merge pull request #518 from jpeeler/deploy-debug
+8f98411e1 Merge branch 'master' into deploy-debug
+c15c38eef Merge pull request #523 from ecordell/dont-annotate-immediately
+2367013fd Merge branch 'master' into dont-annotate-immediately
+4eebac945 Merge branch 'master' into patch-1
+bedd37ef0 Merge pull request #527 from njhale/fix-ports
+dd7edeedb [Doc] Add note about helm binary requirement
+ee5fa093c fix(e2e): switch to port 5443 for owned apiservice test
+e2acf29d2 chore(e2e): change package port to 5443
+7c5dfac0f Merge branch 'master' into dont-annotate-immediately
+7682a397a Merge branch 'master' into enable-auth
+69c5223c7 Merge branch 'master' into deploy-debug
+a68257eca Merge pull request #524 from ecordell/pkgserver-port
+8b077e998 chore(package-server): enable auth by default
+2c7b4a945 fix(package-server): make secure port configurable and default to 5443
+c0994b7cd fix(olm): don't annotate namespaces on operator creation
+fde481faf Merge pull request #521 from alecmerdler/ALM-774
+1ddefbafd pass annotations from CSVs to associated PackageManifest
+624901992 Merge pull request #520 from alecmerdler/ALM-753
+ee0bbd0ea adding more spec/status descriptors for CouchbaseCluster
+a469acd4a Merge pull request #519 from font/install
+d0749dce0 Merge branch 'master' into deploy-debug
+8384a09ee Merge branch 'master' into install
+69306979b Merge pull request #515 from jpeeler/crd-client-metrics
+2460160ee feat(deploy): add debug variable to all deployments
+be8625420 fix(metrics): use CRD client instead of k8s
+58ebd4978 Update OKD install instructions
+4194983ab Merge pull request #514 from njhale/non-resource-perms
+51b6a8a46 fix(requirements): add CRD served version requirement check
+66e04f524 fix(requirements): add support for non resource url rules
+c660c0784 Merge pull request #513 from alecmerdler/ALM-752
+36c5e1d2d rewrite 'metadata.namespace' of global PackageManifests
+59c835188 Merge pull request #512 from ecordell/0.7.3
+1af271d52 bump olm version to 0.7.3
+4e1317470 chore(deploy): remove unneeded dockerfiles
+84800de83 Merge pull request #511 from eriknelson/nonresourceurl-verbs
+9570511ca Merge branch 'master' into nonresourceurl-verbs
+a9ae9794f Merge pull request #506 from njhale/fix-blank-req
+34d53acd3 Add missing nonResourceURL verbs to csv validation
+ebf12385b fix(csv): make invalid install strategy transition from pending to failed
+9ffecba09 fix(requirements): remove extra empty permission requirement statuses
+8d5ed0436 Merge pull request #510 from ecordell/singleimage
+c9118b394 cut 0.7.2
+6c3c95b0e chore(deploy): update release scripts to not use 3 different images
+cf5a2dcda Merge pull request #508 from eriknelson/logfix
+1eaf17ad5 Merge branch 'master' into logfix
+a41cfbd3c Merge pull request #509 from ecordell/olm-deploy-singleimage
+ce535c211 Merge branch 'master' into logfix
+589e9dcca chore(deploy): put all binaries in the same image
+851518689 Small log statement fix
+1c13c1cce Merge pull request #505 from alecmerdler/ALM-750
+94e378dbb add 'catalogSourceDisplayName' to PackageManifest status
+8e7a25f8d Merge pull request #504 from njhale/fix-deploy-staging
+f3f096492 fix(ci): use deployment namespace as catalog_namespace
+ffe9e0c2c Merge pull request #503 from smarterclayton/labels
+1812c4c4a chore(deploy): use runlevel label on namespace
+7e6bccf6f Merge pull request #492 from njhale/manage-apiservices
+710055877 docs(apiservices): add some detail on APIServices in CSVs
+3b729ef60 feat(svcat): add service-catalog manifests
+e73e72ece feat(csv): install owned APIServices
+0e9ba409c Merge pull request #502 from ecordell/runlevels
+00dee8016 chore(deploy): Add runlevels to release
+55901eda7 chore(ci): Use a single Dockerfile for ci
+b10f31114 Merge pull request #501 from madorn/patch-3
+a5cd11e51 Merge branch 'master' into patch-3
+c7f7f7af6 Merge pull request #499 from wongma7/use-scc
+38b8043b9 Merge branch 'master' into use-scc
+0e0705a86 Remove explain 'annotations' and 'replaces'
+1b99ccd15 add example and additional info about optional CSV metadata  (replaces, annotations, labels, selectors)
+40f1ec2b9 Merge pull request #494 from alecmerdler/ALM-735
+36c2fa492 return PackageManifests from 'global' namespace
+6c4e92ea3 Merge pull request #500 from mrogers950/fix_imagestream_yaml
+ac77a6652 fix 30_14-imagestream.yaml formatting
+230f30537 Merge branch 'master' into use-scc
+0209fabd5 Merge pull request #498 from alecmerdler/federation-csv-provider
+e75ec5aae Make use a valid clusterPermissions rule verb
+1776a6d37 add 'spec.provider' to Federation CSV
+ef237384c Merge pull request #497 from font/e2elocalshift
+b4357182c Merge branch 'master' into e2elocalshift
+3eee10107 Merge pull request #491 from font/fedv2-v0.0.2
+49f8ed880 Add missing binary to fix run-local-shift
+fc80eaea3 Update registry unit test for FederationV2
+85b1ba98d Split out FederationV2 CRD file into many files
+40cdef4d2 Update FederationV2 CSV to add spec fields
+ed1f978b0 rh-operators: add FederationV2 v0.0.2
+89d2e37b4 Merge pull request #493 from ecordell/ci-fixes
+fc8054537 fix(deploy): add base images for ci-operator
+5b55ada20 Merge pull request #496 from abhinavdahiya/remove_label
+be70bd26f Dropping label for origin releasepayload
+3b3e69cac Merge pull request #476 from alecmerdler/ALM-722
+0b1d2408f implement watch for PackageManifest resource
+8909a2610 feat(package-server): add minimal watch
+3f5133c6c Merge pull request #490 from ecordell/remove-vendor
+ea90420af fix(build): don't vendor
+341d9c1e0 Merge pull request #489 from jpeeler/build-golang-1.10
+c85b44dea change go build to use 1.10
+28ce23571 Merge pull request #482 from madorn/patch-2
+f54911a34 Merge branch 'master' into patch-2
+76a534266 Merge pull request #483 from ecordell/deployment-fixes
+a981e480f fix(submodules): remove submodules
+cd0c8e0a6 fix(deploy): only use replace on configmaps
+ee1d27627 Merge branch 'master' into patch-2
+3734b9ae6 Merge pull request #487 from ecordell/add-package-image-stream
+490f273d9 Revert "fix(deploy): remove package-server until ci-operator is outputting the package-server tag"
+9ff1a27d1 Merge pull request #486 from ecordell/fix-image-stream
+a2a0acbcf fix(deploy): remove package-server until ci-operator is outputting the package-server tag
+01fea7099 fix(deploy): yaml error in imagereferences
+ac1456c93 Merge pull request #484 from ecordell/fix-manifests
+2bf227bdb fix(deploy) rename image stream to `image_references`
+e78ab125a Add manifests to dockerfile
+a9aec1f56 re-cut 0.7.1
+7f3c3d1a1 Merge pull request #479 from njhale/rbac-requirements
+c9875bba5 docs(rule_checker): update hasOwnerConflicts comment wording
+9e3d2a4f3 test(rule_checker): wait for informers to sync before continuing tests
+3881e4212 refactor(olm): use SharedIndexInformer listers for RBAC resources
+bd79623e1 docs(rule_checker): add reasoning note to hasOwnerConflicts method
+2a78522e7 chore(dep): constrain k8s.io/kubernetes to the release-1.11 branch
+0f4d07325 chore(comments): correct comment mistakes
+6bcb9a1e0 test(deployment): remove/refactor tests expecting RBAC installation
+441e2bae8 chore(code_gen): regen mocks and openapi
+ee7d3a4b4 refactor(olm): add DependentStatus message field
+2b2cde5d7 test(csv_e2e): add e2e tests for permission requirements
+4591823f2 feat(olm): add ClusterRole/Binding requirement checking
+d94767798 refactor(rule_checker): move rule_checker to install package
+edf824218 feat(permissions): add RBAC permissions as CSV requirement
+7a3a24056 refine cluster-admin OLM workflow
+9f4351730 Merge pull request #478 from baichinger/dynatrace-rectify-form-of-business
+584eb0f22 certified-operators: rectify form of business for Dynatrace
+f207fc104 Merge pull request #477 from ecordell/clusterroles
+7039b333b test(installplan): test clusterrole and clusterrolebinding resolution
+78e5bb81b refactor(resolver): move step resolution to resolver package
+59f2c880f feat(catalog): resolve ClusterPermissions on CSVs as part of an installplan resolution
+e24427b9f feat(deploy): add clusterPermissions to CSV
+639b8dbc2 fix(deploy): update upstream release
+5d0d0c772 Merge pull request #475 from ecordell/0.7.1
+1b2605f76 fix(ci): don't create namespace (it's in the chart now)
+cfada3c7b cut 0.7.1
+e9d04101e Merge pull request #474 from ecordell/push-tags
+c771a29d9 feat(ci): push tags to quay
+3a4c9f0c0 Merge pull request #472 from ecordell/0.7.0-packages-api
+c82e275b3 re-cut 0.7.0
+0183fe87f chore(deploy): add package server to release scripts
+dd3c005d0 Merge pull request #470 from praveenkumar/patch-2
+c8645173d Issue #469 update the service catalog instruction for minishift.
+6c243bb4d Merge pull request #459 from ecordell/apiserver-dependency
+d64eceef7 fix(olm): don't both checking for GVK in discovery for CRDs
+4b47c0049 feat(e2e): use newNginxInstallStrategy helper to clean up csv e2e tests
+49d0d484c test(olm): add e2e tests for depending on apiservices
+ac7f222dd test(olm): add unit tests for depending on apiservices
+ee39338e4 feat(olm): check for the existence of required APIServices before installing
+fa6287214 chore(deps): add kube-aggregator to get APIService types
+fb974a42d feat(apiservices): add support in CSV for apiservices
+639f296b7 Merge pull request #457 from njhale/rbac-plans
+f18a02595 chore(catalog): remove TODO comment
+3d3e7692b chore(mocks): regen client mocks
+2ab5b404b refactor(resolver): rename resolved RBAC resources
+0e83d35ed feat(catalog): add OwnerRef patching for ServiceAccounts, Roles, and RoleBindings
+2972534d4 feat(operatorclient): add Role and RoleBinding clients
+a33ba616b fix(catalog): update OwnerReferences with stored CSV UIDs
+f3fb63f3c refactor(installplan): move scheme build to init
+736ed7a8c feat(resolver): generate UIDs for freshly resolved CSVs
+ed0d96692 fix(catalog): handle creation of RBAC resources in plan execution
+e9c5d18ad test(catalog): add e2e test for InstallPlan RBAC resolution/execution
+4a6566748 feat(installplan): resolve RBAC resources during InstallPlan resolution
+c44695f7b feat(installplan): enable creating step resources from runtime.Object
+37c80b316 Merge pull request #466 from LiliC/lili/fix-install
+af3cd6f8e Merge branch 'master' into lili/fix-install
+eb5eb7250 Merge pull request #465 from alecmerdler/ALM-721
+2aa0546df return all 'PackageManifests' for 'all-namespaces'
+8d35ef469 Documentation: Change to full path
+3e7535ae2 Merge pull request #452 from jpeeler/add-metrics
+d0273a559 feat(olm): add metrics
+b8b8c9734 Merge pull request #464 from operator-framework/add-owners
+0976485ea Create OWNERS
+db1e0e0b7 Merge pull request #458 from rodrigovalin/mongodb_operator_csv_updates
+00c8044f9 Merge pull request #461 from madorn/patch-1
+e11fa9ce2 Merge pull request #463 from njhale/test-ownerref-gc
+d0e94518a Merge pull request #462 from ecordell/cut-0.7.0
+821d3968c test(e2e): add OwnerReference GC behavior test
+f28afd701 style(e2e): re-order imports
+fc98155bf cut 0.7.0 release
+04ab7bd26 feat(deploy): update makefile to generate deploy artifacts for okd
+07ff80e8a List out options for Descriptors
+7a0984c7f Merge pull request #460 from ecordell/0.7.0
+9941f036c cut 0.7.0 images
+7a8840955 Improvements on the MongoDB Enterprise Operator CSV.
+9a7deedb8 Merge pull request #455 from njhale/revendor
+720ad7110 fix(vendor): revendor dependencies
+0a48190c6 Merge pull request #453 from ecordell/remove-annotations
+793079cd2 feat(olm): attempt to cleanup namespace annotations on shutdown
+c1942075f Merge pull request #451 from njhale/queue-pipeline
+b9b308766 Merge pull request #440 from robszumski/update-csv
+e908d7132 fix(scripts): short-circuit up to length 1 running pipelines
+526a3e6c1 style(scripts): snake_case is_head function
+0ff9d2013 fix(ci): move wait-in-queue job before deploy-preview
+a1d6d032d feat(ci): add wait in queue job to test_setup stage
+68385ce1a feat(scripts): add pipeline queue wait script
+09cba2fb9 fix(e2e): update prometheus channel
+93901f33d rh-operators: use preview as channel for Prometheus
+96677e996 rh-operators: use preview as channel for AMQ
+7ddb9b517 certified-operators: use preview as channel for Dynatrace
+490c662e2 certified-operators: use preview as channel for MongoDB
+db8f2659d certified-operators: use preview as channel for Couchbase
+8c960c927 certified-operators: add double spaces in Mongo markdown
+e20203f82 certified-operators: fix Mongo markdown lists
+9bec7dc92 certified-operators: add required parameters for MongoDB
+3c5c32230 certified-operators: add required parameters for Dynatrace
+9d8ac6727 certified-operators: add required parameters for Couchbase
+42657c62d Fix certified operators packages csv refs
+edf552ab8 include certified-operators catalog in deploy on CI
+0f27723b1 Update directory loader test for amq-streams
+186236a98 certified-operators: update Dynatrace version
+730b26dd0 certified-operators: add Dynatrace CSV + CRD
+0459412e2 certified-operators: add Couchbase CSV + CRD
+02994afd6 certified-operators: add MongoDB CSV + CRDs
+c2d8e68ba rh-operators: add AMQ Streams CSV + CRDs
+6bf3cad97 Merge pull request #447 from ecordell/generate-aggregated-roles
+7c800d986 feat(catalog): add aggregated roles for each crd we resolve
+f0d3b21c0 Merge pull request #433 from njhale/pkg-api
+0ed929b8a Merge pull request #450 from ecordell/prom-update
+391d51e32 fix(reststorage): start with empty slice when filtering
+0936f3159 feat(inmem): collect CSV data in PackageManifestStatus
+e95b93ba0 chore(server): remove commented packages
+9b07a0c4c test(e2e): use CSVDescription in expected PackageManifestStatus
+ed207e334 chore(openapi): regenerate openapi spec
+2258a4eb7 feat(packagemanifest): add CSVDescription to PackageManifest
+824d02dc8 fix(build): add OLM_VERSION file and .git directory to e2e.Dockerfile
+adff217d2 fix(prometheus): add securityContext to alertmanager example
+89ae2d1d1 test(packagemanifest): add fetch function for packagemanifests
+faca2adad test(e2e): add logging to TestPackageManifestLoading
+348edd45c fix(charts): change cert secret mount path
+4c91f46ae fix(charts): change default package-server internal port value to 443
+a07ff5ca3 fix(charts): update expected package-server chart value name
+36f61d982 refactor(charts): use olm-operator-serviceaccount for package-server
+db2d4d7ab fix(charts): correct indentation
+46dabbd0a fix(charts): add missing coreos pull secret
+d9130b966 fix(scripts): uncomment cleanup
+ed9c71291 feat(ci): add package-server to ci
+b723612b6 feat(scripts): add package-server to build scripts
+1d516db51 feat(docker): add package-server to Dockerfiles
+6d1df15fd feat(reststorage): return NotFoundError if manifest not found
+7f9e37671 fix(provider): don't use pointer in manifest selection loop
+e78eeb197 feat(package-server): add debug flag
+dac5c051d fix(package-server): surface cobra flags to package level
+8252d706d feat(package-server): add run-local package-server helm values
+228fa902b test(package-server): add basic e2e test
+cab422840 feat(deploy): update package-server templates
+9a612461d fix(inmem): change struct tags
+b6e03761c refactor(packagemanifest): move all package data to status
+895898db4 chore(package-server): remove and ignore local config
+e82d823e4 feat(package-server): enable openapi
+d8ad5bb2e feat(package-server): adds skeleton of package server
+7a2a804da Merge pull request #449 from djwhatle/fix-install-doc
+1ab94b034 Merge pull request #446 from operator-framework/csv-guide
+c1f4466a3 docs: update broken link
+3c05b4dbb Merge pull request #448 from njhale/version-flags
+0723f2167 Recommend installing OLM with `kubectl create` instead of `kubectl apply`
+89dbea144 fix(build): remove GOOS and GOARCH settings
+2aa971062 feat(build): add version injection to go test build
+d743c7d51 style(flags): change version output format
+eef8635a5 fix(build): point version build ldflag to correct package path
+340c852f6 feat(cmd): add version flags
+dada4703c chore(osbs): remove unused Dockerfile.single
+989a71d52 docs: text -> label
+23e0797d9 docs: move desc to bottom
+8702b466e docs: add CSV guide
+f5fef4abb Merge pull request #445 from njhale/pull-console
+42da71917 feat(run_console_local): add docker pull for console image
+e967cee84 Merge pull request #441 from alecmerdler/fix-console-script
+cf392e3bb fix console script to work with both Linux and MacOS
+232748ead Merge pull request #444 from ecordell/perms
+b3f7069c7 chore(broker): remove servicebroker from CI
+289d1e0ab chore(rbac): add olm-specific ClusterRole
+00a4ba7c7 Merge pull request #443 from operator-framework/ecordell-patch-2
+cdcfa6f0f Remove outdated install instructions
+67f54b3d9 Merge pull request #438 from jpeeler/ALM-630-remove-broker
+9d5348444 Merge pull request #442 from ecordell/remove-aos
+a29b6f667 chore(deploy): remove ansible scripts for install
+2c99b206c Merge pull request #439 from njhale/dockerfile-single
+004a7615d feat(osbs): add non-multistage docker build
+d0e573efe remove non-go references to broker
+9cf92348a prune dependencies via dep ensure
+1b038d7fb fix(servicebroker): remove broker from repository
+4a342a5a5 Merge pull request #435 from jpeeler/e2e-fix
+42bde3739 Merge pull request #429 from ecordell/catalog-rename
+bc49404ef fix(scripts): allow use of existing KUBECONFIG env var
+84d0ebaf7 Merge pull request #432 from ecordell/mv-api
+0ff8f38a1 fix(scripts): make cp cross-platform
+30519eb8d chore(api): move non-generated apiclients out of the api dir
+ab96af79b chore(catalog): rename ocs -> rh-operators
+3d31e3519 Merge pull request #431 from alecmerdler/ALM-620
+f20ef2b19 add script and instructions for running OpenShift console
+b382d3557 chore(rbac): remove view verbs from edit role
+41bfb18fc chore(prometheus): remove namespaceSelector from ServiceMonitor
+bfd26cefa Merge pull request #428 from njhale/osbs-ready
+3e09a705f fix(Dockerfile): fix catalog copy typo
+7d0a42a17 fix(Dockerfile): add catalog bin to final docker image
+d44140f67 chore(ci): update gitlab-ci.jsonnet to reflect Dockerfile name change
+2525f996b refactor(Dockerfile): make Dockerfile.rhel7 OSBS compliant
+934c9c557 chore(dep): vendor dependencies
+23f62e7db Merge pull request #425 from sichvoge/update_prometheus_csv
+e49a88d86 Merge pull request #427 from njhale/catalog-e2e
+da020c364 test(e2e): add catalog loading between operator restart test
+479299d58 Merge pull request #426 from alecmerdler/action-descriptors
+37a2a154b add actionDescriptors block
+141a6d0de Merge pull request #423 from njhale/subscription-current-csv
+39d857795 Merge pull request #424 from njhale/fix-catalog-loading
+1234b1e7b fix(catalog): add check for loaded catalogs
+393082db9 feat(subscription): add dedicated currentCSV field to subscription status
+8cbefca49 Merge pull request #422 from njhale/fix-deployment-monitoring
+0a9638ecb fix(operatorclient): remove wait for deployment rollout
+9252bc43f updated prometheus csv according to the integration into openshift
+b20aefa3b Merge pull request #420 from alecmerdler/ALM-681
+87ba2785a set 'status' on Subscription when 'spec.source' is invalid
+9853c632e Merge pull request #421 from njhale/remove-deployment-cleanup
+be2e26571 fix(e2e): remove deployment cleanup
+4ec2ddca7 Merge pull request #415 from njhale/namespace-aware-plan-execution
+55707f79c refactor(operatorclient): remove error return in deployment poll
+9b4c22776 fix(operatorclient): return error from infinite deployment poll
+db27ccc03 test(e2e): add wait for deletion during OLM cleanup
+2f8fdcdb3 fix(catalog): ensure pre-existing check does not interfere with upgrades
+e5ac72fe6 refactor(resolver): incorporate custom error type
+0a494d098 feat(catalog): add namespace awareness to plan execution
+ec98eeec2 feat(controllers): add custom error type for multiple existing CRD owners
+312df3b1d Merge pull request #419 from njhale/catalog-status
+e87bdedf3 style(operator_test): reorder import statements
+7d90484e2 refactor(catalog): return early from sync catalog
+50341cf08 test(e2e): add deferred global cleanup calls to subscription tests
+4d64d0ae8 fix(e2e): move log after nil check
+d5d2a3737 fix(ocs): reduce prometheus requested resources
+f24fac129 fix(olm): restrict deployment watches to the watched namespaces of the operator
+44ea5a68d feat(operators): log which queue items are coming from
+167d97221 test(e2e): remove cleanupOLM calls
+2d070fa91 refactor(catalog): only load in-mem when a change is detected
+5dff27973 test(installplan): add helper functions for building test CSVs
+c17e14f5a fix(catalog): correct sync logic to accept catalog spec changes
+44a517c42 test(catalog): add wait for catalog sync to e2e tests
+22dd40de6 refactor(catalog): enable status subresource
+b8152490f test(catalog): add catalog source sync unit tests
+09dded4b9 refactor(types): remove Hash field from ConfigMapResourceReference
+a112bb36d feat(catalog): add catalog status block updates
+f727f4d13 Merge pull request #418 from ecordell/prom-fixes
+720a55b2b fix(e2e): re-enable prometheus test
+9916a718a chore(rbac): update roles to include resources
+6cdae285a chore(rbac): list out verbs in edit role
+44d13ab8a update 0.6.0 release
+160da9e80 fix(ocs): add securityContext to prometheus example
+6eeb650a3 Merge pull request #417 from mvazquezc/master
+70a244051 Fixes #416
+84153f348 chore(deploy): update 0.6.0 for okd
+82513b3b2 fix(ocs): update prometheus operator
+de1a4f994 Merge pull request #414 from pmorie/docs
+29dbfe460 Make key resources linkable in philosophy doc
+fc0d50908 Merge pull request #413 from ecordell/0.6.0
+5a2ae2f40 Merge pull request #402 from njhale/namespace-aware-resolution
+6dd73f6af style(resolver): remove nesting from owner CSV selection logic
+567b0dd62 refactor(catalog): remove map-based subscription caching
+dbf4e61d6 chore(dep): re-vendor with dep stable
+569e82e80 feat(resolver): add namespace and channel awareness
+569489cb3 cut 0.6.0
+2ad0128b5 Merge pull request #404 from ecordell/catalog-updates
+28142eb77 chore(docs): update docs for newer types
+96e313f1e chore(ci): update catalognamespace for olm
+259e1acbe fix(e2e): don't use vault in e2e tests
+1d89136bf chore(ci): disable teamui deploy
+de6a9916a chore(catalog): update prometheus deployment for 0.22.2
+050575729 fix(catalog_versions_test): test all releases
+b0c8fc91b chore(deploy): remove tectonic-alm-operator
+7de243e9c chore(deploy): remove old catalog entries
+05e52524c Merge pull request #412 from ecordell/remove-vendor
+35af681db chore(vendor): remove vendor directory
+058f7ad44 Merge pull request #411 from ecordell/csv-fixes-plus-e2e-fixes
+42db0fa23 fix(e2e): use fetchinstallplan in subscription tests
+6904c8f3b chore(e2e): delete duplicated test from merging
+534123bf9 refactor(opclient): remove fake operatorclient
+9b226365c fix(olm): re-enable a requeue
+b5f047e35 chore(fmt): order imports correctly
+dd0fd247f fix(e2e): update fetchSubscription call to new use version
+1cc429a27 feat(deploy): add OLM type access to aggregated cluster roles
+a7c9d5fce fix(csv): delete csvs immediately
+9b3324f7d feat(subscriptions): pick up installplan changes more quickly
+f4a25dc0c chore(logs): add debug logs if item can't be found in index
+0869ea288 fix(deploy): key the rolebinding to the namespace so that serviceaccount won't lose its access when a new binding is created
+85bc154a4 fix(e2e): clear existing CSVs before running subscription tests
+5a73be3a0 fix(installplan_e2e): add deferred cleanup calls to installplan e2e tests
+fd693873a fix(subscription_e2e): ensure subscriptions are completely cleaned up
+e3daf7743 fix(subscription_e2e): add check and wait for subscription status
+192f37bda fix(cvs_e2e_test): move old serviceaccount existence check
+0d992700e Merge pull request #408 from Jiri-Kremser/broken-link-architecture
+55bd22037 wip(olm): fix leaks
+e1d989a93 minor: broken link
+0a4fa4d76 chore(api): update apps/v1beta2 to apps/v1
+7bce13d5b fix(subscriptions): don't update subscription when there are no status changes
+d9bc7926d feat(olm): set up watches on deployments so that csv status can be updated more frequently
+fb15243a9 chore(tests): remove old mock-based tests in favor of fakes
+1b1508c77 chore(tests): rewrite TestIsBeingReplaced with fakes
+77490abfb chore(tests): rewrite TestIsReplacing with fakes
+db0fa43e9 fix(olm): add fixes for GC optimization
+75127e586 wip(olm): add failing upgrade csv test
+222e54012 Merge pull request #403 from ecordell/1.11-updates
+53fe8844e Merge pull request #405 from alecmerdler/spec-descriptor-selector
+d706d792e update 'urn:alm:descriptor:com.tectonic.ui:selector' to use GroupVersionKind
+631759eb7 chore(deploy): update deployment resources to use apps/v1
+45acaeedc chore(api): bump deployments from apps/v1beta2 to apps/v1
+4345b4e28 Merge pull request #398 from ecordell/1.11-libs
+2658e97ec chore(ocs): Update to prometheus 0.22.2 but disable e2e test
+a051a62b4 feat(makefile): allow running a single e2e test from the make command
+5b7dade3f chore(e2e): switch to using the versioned clients in e2e tests
+d1ebf93a7 feat(api): migrate apis to common group and regen apis/clients
+fc82cae77 fix(csv): update CatalogSource for 1.11
+07b1d1b01 fix(catalog): update Subscription control loops for 1.11
+188442aa5 fix(csv): update Subscription for 1.11
+529602d90 fix(catalogs): remove outdated EtcdCluster validation
+cdaf4073c fix(catalog): update InstallPlan control loops for 1.11
+fe58b4c0a fix(catalogs): update catalog data to use ClusterServiceVersion
+cff2f9a4a fix(ip): update InstallPlan for 1.11
+d7dfb072e fix(olm): update ClusterServiceVersion control loops for 1.11
+2ca630fde fix(csv): update ClusterServiceVersion for 1.11
+0757d12cd fix(build_local): don't start minikube if already running
+d69715b41 fix(csv): k8sjson encoders don't properly omitempty on json.RawMessage serialization.
+30473c953 fix(crds): update CRDs to validate in 1.11 (versions field now required)
+5303271ad chore(codegen): update codegen for 1.11
+26f1fc06e chore(deps): update k8s libs to 1.11 versions
+facde3cf4 Merge pull request #401 from njhale/verify-multi-source
+b29b319eb chore(catalog_versions): remove extra lines in import
+adbc87091 test(catalog_versions): add resolveCatalogs test for catlogs in each version
+0d3c126da refactor(resolver): make resolved step logging more helpful
+3e70e76cb Merge pull request #399 from alecmerdler/ALM-644
+a2a6a02ef add 'spec.sourceNamespace' to the Subscription CRD validation block
+f72890f47 Merge pull request #397 from robszumski/access-docs
+87a7cd43c Merge pull request #388 from ecordell/prometheus-0-22-0
+cdc506f5e Merge pull request #396 from njhale/multi-source-e2e
+7ac344194 docs: add access control workflow
+0b50c2154 test(installplan_e2e): change main package name to avoid conflicts
+376439ebb style(catalog): add missing semicolon to log
+c23d727f4 fix(catalog): remove required CRD existence check for service additions
+6eb7fe69e test(installplan_e2e): add multi source install test
+0c9b2e0fa test(util): add internal catalog source creation helper function
+4e331b89f fix(ci): deploy files to ci cluster in order
+e97fbf94d fix(makefile): fix run-local and run-local-shift
+ea0930d5c fix(e2e): update prometheus serviceaccount
+49d37c078 fix(make): fix local e2e
+3e1b9c1ce fix(e2e): update e2e prometheus test for 0.22.0
+a1321109c fix(deploy): put prometheus in ocs catalog
+c7bed1cb8 fix(ci): update ci to use replace
+9e2c188d4 deploy/chart: bump prometheus to 0.22.1
+135e2efa5 feat(catalog_resources): add prometheus 0.22.0
+56e15b8b0 Merge pull request #392 from jsm84/master
+cd72756cf Merge pull request #395 from ecordell/alecmerdler-openshift-ci
+2a201af79 chore(ci): update gitlab-ci.yml from jsonnet
+c25ab627d Merge pull request #394 from njhale/installplan-status-fix
+bc80df8fd fix(installplan): type InstallPlan.Status.CatalogSources to []string for backwards compatibility
+b11c289e5 Merge pull request #393 from alecmerdler/openshift-ci
+17592da9c chore(ci): update gitlab-ci.yml from jsonnet
+261e45475 need to use 'operator-lifecycle-manager' namespace but ffctl is broked
+e415a10cd Merge pull request #386 from njhale/multi-source-resolution
+e8c12e624 Merge pull request #390 from jzelinskie/depfix
+453e1c592 fix(subscriptions_test): replace single source resolver with multi source
+64fa9e875 refactor(resolver): accept prioritized list of source refs as a parameter
+6473a9e2b refactor(catalog): change parameters of getPrefferedSourceKey to take a source snapshot
+7534147ff fix(e2e-local): remove extra RBAC config on minikube start (default in newer kubeadm versions)
+1e5eed308 fix(e2e): apply charts from templates directory
+47265e610 refactor(InstallPlan): add source name and namespace to install plan custom resource
+67cd39ab4 refactor(catalog): limit sources snapshot to global and install plan namespaces
+6058d9e51 feat(catalog): add catalog and catalog namespace to install plan spec
+4a58b08a0 feat(catalog): add helper method to get preferred source key from plan owning subscription
+290cc908b feat(registry): add subscription key type
+96fa0d51b test(resolve): decouple expected results from test input
+ec8cad8d7 refactor(resolver): return used catalog sources slice from ResolveInstallPlan
+c62647668 chore(registry): dedupe to in comment
+ca85176e6 refactor(InstallPlan): use registry.SourceKey to keep track of used CatalogSources
+2b2c51758 chore(.gitignore): remove vscode file exceptions
+719d848c3 fix(resolver): set resolved csv namespace to plan namespace in MultiSourceResolver
+ac2e9fe33 feat(catalog): use MultiSourceResolver in catalog operator
+f18d1b3e3 test(resolver): add tests for MultiSourceResolver
+2643b9903 refactor(catalog): add helper method for getting a sources snapshot
+d0a068551 refactor(resolver): remove extra functions from DependencyResolver interface
+0449c930d feat(resolver): add CatalogSourceNamespace field to StepResource struct
+d020b84e9 Fix invalid `minishift start` option in install_local_shift.sh
+b08a54bbe Merge pull request #381 from ecordell/0.5.0
+7c6d25f02 vendor: re-run `dep ensure`
+6656c6ae8 Merge pull request #387 from njhale/fix-csv-namespace
+17e627ca7 fix SingleSourceResolver to use plan namespace for resolved CSVs
+f0814434c cut 0.5.0 release
+f2a4d4e14 Merge pull request #385 from njhale/step-catalog-source
+0995b5fa0 refactor catalogLabel to catalogLabelKey
+ebf8f18f7 fix namespace used for CatalogSource lookup
+fd59310cb refactor resolver to be in separate package
+8638ba5e1 refactor interface method parameters
+c759db72b fix remove .vscode/launch.json from .gitignore explicit include
+9df2501ee fix remove .vscode/launch.json
+476a9e8bd remove test for MultiDependencyResolver
+509bb2b56 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling
+03d5bd1a8 add test for step resource catalog source
+56f03a242 add DependencyResolver interface and SingleSourceResolver implementation
+3e383febf refactor interface method parameters
+d643d0724 fix remove .vscode/launch.json from .gitignore explicit include
+47dcd7d45 fix remove .vscode/launch.json
+f876c89b7 remove test for MultiDependencyResolver
+1fff51d79 fix CatalogSourceStatus.ConfigMapResourceReference json struct tag spelling
+e1b91e17a add test for step resource catalog source
+0f40860a8 add DependencyResolver interface and SingleSourceResolver implementation
+009810605 Merge pull request #380 from alecmerdler/ALM-639
+45ca4486c add 'spec.catalogNamespace' field to Subscription-v1
+3c6e4ba00 Merge pull request #384 from alecmerdler/ci-openshift-fixed
+f16a8eef9 fix catalog_namespace for deploying to OpenShift
+65e7d3f31 Merge pull request #383 from alecmerdler/ci-openshift
+15d8a6c2e Merge pull request #382 from aravindhp/master
+8b1cf8b10 deploy to TeamUI's OpenShift cluster
+1d29537bb fix(docs): correct spelling of philosopy.md
+2ea88d2a9 feat(release): build a release package from a tag
+7e69bb980 Merge pull request #377 from operator-framework/ecordell-patch-3
+3ab77867f fix(docs): typos in architecture.md
+34faa5c50 Merge pull request #375 from ecordell/check-doubleowner
+6d407d93a feat(olm-operator): prevent a CSV from installing if there is another CSV in the namespace that owns the same CRD, but isn't being replaced.
+856037c28 Merge pull request #374 from fabiand/patch-1
+43b4897f7 Fix a small typo
+11c8910f4 Merge pull request #361 from alecmerdler/ALM-581
+b2ac1856c add checks for runaway control loops in e2e tests
+58d0e1862 Merge pull request #372 from ecordell/fix-coveragebuild
+953e8cf0d fix(servicebroker): add main_test.go to servicebroker cmd
+cd8d9ec75 Merge pull request #371 from ecordell/fix-makefile
+714d75167 fix(make): fixes run-local and run-local-shift
+ddd865b42 Merge pull request #365 from alecmerdler/ALM-593
+0f745670b fixed panic(err) calls
+463a113ee Merge pull request #370 from ecordell/remove-tectonic-operators
+11ab35f06 check upgrade path per package directory
+d2aa0cd1f changed filepath for pragmas
+f9d9892c6 remove testing.T from manifest validation files
+3ad07e1f3 moved schema validation
+1683df4b2 chore(deps): remove tectonic-operators as a dependency
+efc318f8c feat(operatorclient): add minimal operatorclient types
+07f41092e Merge pull request #367 from operator-framework/make-run-local
+c73c02452 fix(make): set version var for run-local
+3acb562cb Merge pull request #364 from alecmerdler/ALM-623
+a39f5051f make 'InstallPlanPhaseInstalling' come before 'InstallPlanPhaseRequiresApproval'
+b7be2306f added docs for RequiresApproval phase
+76a7c967d Merge pull request #363 from operator-framework/reame
+5f750e8f1 readme: fix broken link to CSV example
+053103a8a Merge pull request #362 from ecordell/catalog-fixes
+e931a9a92 fix(catalog): catalogsources should only read from their configured namespace, not all namespaces
+2acef658a fix(catalog): release memory after loading catalog
+f1c2353ae Merge pull request #356 from ecordell/ansible
+d30204a80 fix(ansible): make sure git submodules are checked out before ansible build
+f4941de5d feat(build): add rhel build
+4e807c874 chore(deploy): add openshift_ansible as a submodule in order to symlink lib_openshift and lib_utils
+80d0373f3 chore(deploy): add ansible playbook for deploying OLM
+5b5b35e9a Merge pull request #359 from ecordell/fix-uid
+fafda6cc6 feat(ownerutil): update ownerutil to infer GVK for OLM types
+7ad3a4671 fix(subscriptions): directly include apiversion/kind of created resource
+d6c089ff9 fix(e2e): make e2e local scripts work again
+0c6f9c77e Merge pull request #358 from aravindhp/patch-1
+5051d9fb2 Fix the deploy to kubernetes command in install.md
+eb01e08e3 Merge pull request #357 from alecmerdler/ALM-601
+21c158eb6 do not update Subscription-v1 if nothing has changed
+fd5b256c7 Merge pull request #354 from ecordell/metering
+168d37f96 chore(deploy): add upstream release and deployment pipeline
+4ce8a80ef chore(build): use helm to template the catalog files in
+be81b22fd chore(deploy): which catalogs get included in a release is configurable
+b329f3fb1 Merge pull request #349 from ericavonb/ALM-568/serviceclass-per-pkg
+5ec07140d feat(servicebroker): list one serviceclass per package
+fdf597a11 Merge pull request #352 from ecordell/vendor-deps
+3d09ef271 fix(ci): codegen needs apimachinary to not be pruned
+f9196a883 chore(deps): update servicebroker for newer servicebroker libs
+28eed314a chore(deps): commit vendored dependencies so that project can be built by people without access to tectonic-operators
+7bab5b6d6 Merge pull request #348 from ecordell/subscription-approvalmode
+a954d2d34 fix(e2e): fix local e2e scripts
+8a134eaff test(e2e): add e2e test for Subscription/installPlanApproval
+4211c6a71 feat(subscription): installPlanApproval field
+be842e599 Merge pull request #347 from alecmerdler/ALM-339
+dd41d1887 Merge pull request #346 from alecmerdler/ALM-567
+a258fd5d8 implement manual approval of install plans
+6cb7b8bc8 strip Markdown from descriptions for OSB
+f59daf7f4 Merge pull request #345 from ericavonb/ALM-538/listcatalog
+7e8316a36 fix(servicebroker): reverse map check bool order
+9cc1a2eb5 test(servicebroker): check validatation of broker api version endpoint
+e1bcfa068 Merge pull request #344 from ecordell/osb-part2
+678f0a560 fix(apiserver): fixes rebase problems also removes the apiserver tests, which are empty
+a3ed14d2b fix(apiserver): update imports
+102aeabea fix(servicebroker/types): dedup description
+ed955eef8 fix(servicebroker/types): set bindable to false on serviceplans
+0d2a5198a fix(servicebroker/types): use link url for support url in serviceclasses
+73b1cfecc fix(servicebroker): grab namespace from interface object
+ed610876c chore(servicebroker): update types from broker libs
+471be7531 feat(servicebroker): display icons and pretty names in catalog
+50ba07844 fix(servicebroker/apiserver): use un-normalized CSV name
+6941a6f1f temp(servicebroker/apiserver): log debug lines
+117af7a36 wip(broker/sources): implement LastOperation handler logic
+855cc3cfc Merge pull request #342 from ecordell/rebase-osb
+b9c413639 fix(ci): fix e2e test runner
+97c09a5b6 fix(makefile): add build-coverage command back for e2e testing
+9ebe6f770 feat(ci): multi-stage builds and verify codegen and catalog during build
+aed1cdc92 chore(ci): simplify container builds
+71673e188 fix(makefile): fix release scripts
+ec2c6cca9 fix(deploy): chart naming after rebase
+91c8cd6f6 fix(makefile): support ocs and ccomponent catalogs
+822d4e0da fix(makefile): always build targets so that dockerfile builds work
+f7081f717 fix(broker): use updated imports for osb
+a3a886ce8 fix(makefile): xargs working cross-platform
+28e8af57c chore(deps): update lockfile
+213233f22 chore(rename): fix path in catalog version tests
+b50d813ec fix(Makefile): update makefile recipes for rearrangement
+dfbcb7157 chore(servicebroker/apiserver): update broker interface types
+897cc0060 chore(Makefile): add target to run e2e with minishift
+8847db68a fix(deploy/chart/templates/01-alm-operator.serviceaccount): specify pullsecret
+3a22e3bd4 rearrange(deploy/chart/templates): create secret before clusterservicebroker obj
+5360b35e5 fix(.): update scripts with e2e dir move
+90e10ab66 fix(Makefile): codegen clients correctly
+09e797cfb chore(*): update github repo org
+c2f775a94 chore(makefile): clean up build
+d5ad6ed55 fix(Makefile): add '-' back to flag (rebase fix)
+8ba65f256 feat(deploy): add servicebroker templates
+88c782a69 feat(broker): add service broker service for alm
+1967560ae fixup(api/client/util): return err instead of panicking
+989f5c6a1 Merge pull request #341 from alecmerdler/teamui-host-var
+7d925aeff use environment variable for TEAMUI_HOST
+1c30ff285 Merge pull request #335 from alecmerdler/ALM-572
+e21ee7c07 Merge pull request #337 from alecmerdler/webhook-olm
+3145b14b2 Merge pull request #340 from ecordell/recut-0.4.0
+9849ac381 Update manifests for 0.4.0 release
+e4f41e039 Merge pull request #339 from ecordell/remove-pull-secret
+183ee949f fix(catalog): pull secrets are no longer needed for vault and chargeback
+1a11f6f6e use InstallCheckFailed instead of DependenciesConflict
+a31f51028 s/ALM/OLM for Slack webhook
+940e3ff5c Merge pull request #336 from wallyqs/patch-1
+63d9031b4 Update README.md
+a4e256433 Merge pull request #334 from operator-framework/ecordell-patch-2
+9057ecfc1 Merge pull request #333 from operator-framework/ecordell-patch-1
+2099041d0 Update README.md
+c570251ca Update architecture.md
+6d863b2cd Merge pull request #332 from ecordell/renaming
+08a80891e chore(rename): ALM -> OLM in design docs
+6381cc736 Merge pull request #331 from ecordell/update-install
+9fa313c0a Add simple install instructions for using a released OLM
+de5bbc846 chore(rename): rename ALM -> OLM in install docs
+eeabc9227 Remove unneeded install steps (minikube fix and pull secret)
+fb86364a6 Merge pull request #330 from operator-framework/update-quay-repo
+7e41d8f4c chore(rename): rename quay.io/coreos/alm -> quay.io/coreos/olm
+e1ac9c4a0 Merge pull request #329 from operator-framework/robszumski-patch-1
+0070d819b readme: restrict SVG height
+c898afe42 Merge pull request #328 from sichvoge/master
+0dd62abb1 Merge pull request #327 from operator-framework/pipeline-status
+3b19c2612 fix(ci): update paths in dockerfiles
+6412c50cc added intro for framework
+916ba2a5b chore(codegen): run codegen on renamed codebase
+36176c6e1 chore(rename): rename alm -> operator-lifecycle-manager
+5b40d9673 chore(ci): update ci to use new operator-lifecycle-manager repo
+b9c0e32df Add pipeline status to readme
+f09f63bae Merge pull request #326 from coreos/readme-update
+66e226bbb Update readme
+cf4f50a23 Merge pull request #325 from jzelinskie/coc
+60ef57954 *: add code of conduct 🎉
+1b3927531 Merge pull request #322 from ecordell/v0.4.0
+a900e1e51 re-cut 0.4.0
+a7dff677f fix(e2e): same deployment install strategy shouldn't change label selectors, which are immutable
+5c17f64cf fix(ci): better names for e2e test objects
+260af5d52 fix(e2e): generate different label selectors for test deployments
+a503a46b4 fix(e2e): use different csv names for each test case
+c6de6e03e fix(ci): don't error if serviceaccount is already patched
+2917401f0 fix(subscriptions): startingCSV is not required
+5bc4fc0df fix(rename): coreos-inc -> coreos
+8b31486e7 fix(ci): vendor in sanity check to remove codegen error
+fabdd576e fix(e2e): use name of catalogsource instead of name of configmap
+0bf38f34f fix(deploy): update x-operator version to one that supports CRs
+0511a2124 fix(deploy): use DeleteAndRecreate strategy for CatalogSource updates
+e798660fd fix(deploy): catalogsources should have different names
+48e7a8cf1 fix(deploy): put catalogsources in catalog namespace, not hardcoded to tectonic system
+71140acf8 remove generation of catalogsources from catalog/main
+a4330ce8b write out both ocs and component catalogsources
+897f7e02f update catalog version test to handle multiple catalogs
+2617cfdbb split catalogs into OCS and cluster components, package 0.4.0
+a774a5a3c Merge pull request #323 from ericavonb/org-change
+3ffce335c chore(Gopkg.lock): update dependencies
+97f460edf chore(*): update github repo org
+6e87311ab Merge pull request #321 from ecordell/review-docs
+b81c38aa9 Review docs for outdated information
+8f74697eb Merge pull request #315 from alecmerdler/hide-slack-url
+58aeb1d02 Merge pull request #318 from ecordell/etcd
+7ec83bf2c move Slack webhook URL to environment variable
+4d240e48d catalog: update etcd-operator to 0.9.2
+3bf8c1810 Merge pull request #317 from ecordell/failfast-fix
+3c0b23664 fix(ci): switch to short sha for naming
+71c800252 fix(ci): update failfast namespace for new ci cluster
+2232d43f3 Merge pull request #314 from alecmerdler/ALM-562
+c6a2bafd1 do not update Subscription-v1 if unmodified
+791f1c214 Merge pull request #309 from alecmerdler/ALM-514
+75e7f7b6a Merge pull request #291 from jzelinskie/apache2
+332daf717 Merge pull request #312 from coreos/docker-login-ci
+5b6e4b4b8 fix(ci): change $SHA8 gitlab var to new $CI_COMMIT_SHA
+1c97e2502 fix(ci): update docker host path
+3a4c13a88 add bill of materials
+b32acbd28 Merge pull request #308 from alecmerdler/ALM-556
+65ab3c77d removed UICatalogEntry-v1
+f44e42a5c Merge pull request #304 from alecmerdler/ALM-517-again
+f5d13283d added docs for Subscription control loop
+df1dd4623 fix(e2e/subscription): update import paths
+3d114cd40 chore(Makefile): clean up all test files
+6e2925aa2 refactor(e2e/subscriptions): add cleanup fns
+85c088cab test(e2e): test subscriptions control loops
+f21f668b6 Merge pull request #305 from ericavonb/ci-namespace
+f6dbb9c59 chore(.gitlab): use commit sha in ns
+79746d284 Merge pull request #300 from alecmerdler/ALM-517
+b59d49cfa refactor Subscription control loop to only call Update() once
+70e009236 Merge pull request #298 from alecmerdler/fix-slack-again
+9af4fbe4b fix Slack notification
+92cdd850c Merge pull request #297 from alecmerdler/fix-slack-webhook
+5509ad892 fix Slack notification webhook in CI
+bdb711983 Merge pull request #296 from alecmerdler/slack-webhook
+b0aad99b9 send Slack update when deploying to Team UI cluster
+429d1e2b2 Merge pull request #295 from alecmerdler/ALM-518
+74beda753 GitLab CI deploys to Team UI cluster watching all namespaces
+c2772b214 Merge pull request #294 from alecmerdler/ALM-518
+50cf85768 modify GitLab CI to deploy master branch to Team UI cluster
+1b4cd8bf3 Merge pull request #293 from alecmerdler/ALM-519
+c1da279ac fix example YAML
+04805c98b Merge pull request #292 from alecmerdler/ALM-517
+63c74f24c fix subscriptions being stuck in UpgradePending state
+1b3611100 add Apache 2.0 License
+2593e41ca Merge pull request #290 from ericavonb/fixups
+77b13702d chore(.gitignore): ignore all generated resources
+e721e53ad Merge pull request #289 from alecmerdler/ALM-513
+a65cc4591 set Subscription 'status.state'
+f417c4703 Merge pull request #286 from ecordell/update-deps
+2a777a7b2 refactor(tests): split source and calculate coverage over non-generated code.
+1c9cfd95e docs(development.md): encourage test running after dependency update
+514948720 fix(ci): pull common variable out into vars.libsonnet
+37bab8896 test(e2e): add coverage generation to e2e tests
+dd28b65fb Merge pull request #287 from alecmerdler/ALM-310
+e26e6eb5f update ALM templates with correct JSON schema
+4e45eee6b fix(tests): update tests to use the new client fakes
+e3bc1546d refactor(clients): switch to using generated apiclients
+10bcf45e0 feat(ci): add sanity check step which does basic verification before building the images
+2dff2314a fix(ci): update fmt-ci to handle multiple files
+ec5fe26d4 feat(ci): run verify-codegen and verify-catalog before building
+92f479534 remove gocoverutil, go 1.10 coverage tools can aggregate coverage now
+6aae532b6 switch to go 1.10
+7480a5a8d fix(e2e): fix invalid CSV in e2e test
+e0ac387f0 fix(catalog_resources): update deployment specs for 1.9
+593a94bc3 fix(makefile): separate vet and docs testing
+65046a066 fix(e2e): use newer apiversions
+6da5d5969 Add $(DEP) as prereq to vendor make commands
+4222a20ae Switch references from glide to dep
+c292db210 Generate clients with code-generator
+afe6cb041 Update api usage to 1.9 apis
+daac0fbdf Update api usage for 1.9
+d92b7fcbc switch to k8s.io/code-generator
+24e57a7f3 Switch to dep and update dependencies
+01c4de0eb Merge pull request #281 from alecmerdler/ALM-462
+250f70471 fix subscription status
+628febd16 Merge pull request #285 from ecordell/cut-0.3.1
+138d8d36d Merge pull request #283 from alecmerdler/ALM-397
+77a65bb9b add annotations for example custom resources to CSV
+6f2c9ffd0 Merge pull request #284 from ecordell/update-install
+cba3b5abb Cut 0.3.1
+afc94a115 Update install instructions and add a `make run-local-shift` command to run locally in minishift.
+34dcafeb8 Merge pull request #282 from ecordell/fix-for-1.9
+60fc4bd6c Merge pull request #279 from ecordell/cut-0.3.0-2
+f7c0f56d9 cut 0.3.0-5
+a10cc2f6e update csv requirements
+12fcc5b9b cut 0.3.0-4
+2dabeb696 cut 0.3.0-3
+3831ad9f4 Merge pull request #280 from ecordell/remove-vault-pod-status
+8b3069d47 clean up during e2e tests
+303dbfc7a fix(crds): nest csv, uice, sub, and installplan validation under "spec"
+b45cf3bd0 Remove vault podstatus descriptor
+118767c77 fix(crds): nest catalogsource validation under "spec"
+842f1bd0e Merge pull request #278 from ecordell/cut-0.3.0-2
+8674c88ba Add prometheus 0.14.0 and update 0.3.0 release of alm
+b18efb38f Merge pull request #275 from ecordell/ALM-415/label-csvs-with-catalog
+b6beb807e feat(operators/catalog): label resolved CSVs and CRDs with the catalog source they come from
+ea719b26e fix(operators/catalog): set phase to failed when resolution fails and enable the e2e test for it
+333c43f24 Merge pull request #277 from hongchaodeng/up
+8aa46d920 Merge pull request #276 from ecordell/orphaned-resources-csv-upgrade
+7a730d80a Merge pull request #269 from ecordell/uicatalog-cleanup
+9a0f720be hack(ownerutil): hardcode groupkindversion for ownerreferences to CSV
+e35094d77 Merge pull request #271 from ecordell/csvs-stay-dead
+bb4987dd2 refactor(uicatalogentry): minor renaming / refactoring
+82c09aaa0 When a watched object is deleted, purge it from the queue
+53cf3c410 e2e test for uicatalogentry updates and pruning
+b70b9b9eb Prune old UICatalogEntries from the cluster on catalog sync
+243b8ee35 catalog: update etcd-operator to 0.9.0
+0dacb994a fix(install/deployment): use ownerreferences when checking for SAs
+8d532e499 Merge pull request #273 from ericavonb/ALM-463-installplan-spam
+6dcca4ea5 fix(client/installplan): use correct resource name
+f6c51b9cb Merge pull request #272 from alecmerdler/ALM-452
+047cd3215 catalog operator ensures labels on Subscriptions
+cc4fbe914 Merge pull request #270 from ecordell/fix-update-frequency-csvs
+1de8a3105 fix(alm/operator): don't update the status timestamp if we aren't transitioning
+7885505d9 Merge pull request #268 from hasbro17/haseeb/update-catalog-vault-operator-0.1.9
+1d63245c7 catalog: update vault-operator to 0.1.9
+135396abf Merge pull request #263 from ecordell/fix-e2e-reporting
+fcb548755 Fix chargeback e2e test
+af30d23e8 Fix e2e test reporting in gitlab
+877e5332b Merge pull request #266 from ecordell/update-0.3.0
+588109443 Update images for 0.3.0
+b4d6900ac Merge pull request #265 from ecordell/test-catalog-version-compatibility
+735aa9a91 fix imports
+1b67f2386 Merge pull request #264 from ecordell/test-catalog-version-compatibility
+aa7e593f9 fix(catalog): add tests for compatibility between versions of the catalog configmap and fix the errors that the tests revealed
+c30733a31 Merge pull request #261 from ecordell/0.3.0
+5e53f0ed3 cut 0.3.0
+acfa8cec5 Merge pull request #262 from alecmerdler/vault-ocs-label
+2091d7314 add alm-catalog label to Vault CSV
+dbfa09021 Merge pull request #260 from ecordell/fix-matchlabels
+afa80c885 Revert changes to labels/match labels on the deployments
+79b8e551c Merge pull request #259 from coreos-inc/HOTFIX/ericavonb/ALM-280/fix-subscriptions
+5baff2c9e fix(pkg/client/installplan): only set name if provided
+ea9e30d90 Merge pull request #258 from ecordell/fix-overloop-catalogsource
+f47d734d6 fix(operators/catalog): don't update catalogsource status when processed
+e63a22231 Merge pull request #257 from ecordell/fix-subscription-loop
+cb3ca1579 fix(operators/catalog): don't share informers between installplan and subscriptions
+6b5f84a7f Merge pull request #249 from chancez/add_chargeback_to_catalog
+3539b245f Merge pull request #256 from coreos-inc/ericavonb/ALM-280/fix-subscriptions
+7b5e7e9f5 pkg/registry: Update tests for Chargeback
+2014e31d0 catalog_resources: Add Chargeback resources to catalog
+751d48d9b fix(operators/catalog/subscription): specify csv in installplan (duh)
+b956294d3 fix(apis/uicatalogentry,subscription): set list items to correct type
+d26070076 Merge pull request #255 from ecordell/fix-uicatalogentries
+2f82f3122 fix logs in e2e tests
+6fd549df2 Add package loading to catalog directory loader (only used for tests)
+6f8b2bfff Add additional logging to catalog loading
+353ff363b Fix makefile build directive
+6f78d53d4 Remove `replaces` from prometheus operator since we don't have an older version
+4d481cb1a Merge pull request #254 from coreos-inc/ericavonb/ALM-280/fix-subscriptions
+8e0d02cbf fix(apis/subscription): correct meta in List obj
+32f98ac78 Merge pull request #253 from ecordell/fix-subscriptions
+249cb27b9 fix(operators/catalog): use the right plural name to list subscriptions
+53fc7c1d0 Merge pull request #252 from ecordell/fix-bad-merge
+f0414c14a Switch from gomock to counterfeiter and update tests
+32ffa33f9 Merge pull request #233 from coreos-inc/ericavonb/ALM-280/subscriptions
+f584f78c7 Merge pull request #251 from ecordell/packages-in-uicatalogentries
+42ebb6277 feat(operators/catalog): standardize to UTC time
+cc8db4627 Add package metadata to UICatalogEntries
+c9633339e fixup(apis/subscription): use the sane json tag
+03555deb1 Merge pull request #250 from coreos-inc/ecordell-patch-1
+9fa0a5851 Update philosopy.md
+71688e824 chore(zz_generated.mock*): regenerate code for k8s types
+2c11385e4 chore(.gitlab-ci): ignore not found errors on delete
+f4e9bb264 feat(operators/catalog/subscription): use startcsv if specified
+67df0abf8 fixup(subscriptions): use CurrentCSV in status block
+f3de8d35d test(operators/catalog/subscriptions): test lastupdate times
+fe88b45cd fix(operator/catalog/operator): ensure safe concurrent map access
+62d093947 Merge pull request #248 from hongchaodeng/up
+a185673b5 fix(operator/catalog/operator): update queueinformer fun signature
+dabf649e6 fixup(operators/catalog/subscription): store apiversion/kind info
+5f962f041 test(operators/catalog/subscriptions): ensure installplan existence checked
+331522962 fixup(subscriptions): check for installplan existance
+402637b34 fixup(operators/catalog/subscriptions): regen mocks and such
+f894bb664 chore(operators/catalog): generate mock catalog
+a2c3662ef test(operators/catalog/subscriptions): add unit tests
+b567a24dc fix(operators/catalog/subscriptions): save subscription
+7a42bf1f4 chore(operators/catalog): generate mock clients for subscription tests
+936b01de6 chore(**/zz_generated.mock_*): update mocks
+6e61c85c9 feat(operators/catalog/subscriptions): add subscription ctrl loop
+216f10206 feat(subscription): save install reference
+75ad7b356 feat(pkg/client/installplan): add create method
+0ddaf47cf feat(pkg/client/subscription): wrap subscription ops in client
+58645801e feat(apis/subscription): add subscription crd back in
+2f86b6f39 catalog: update etcd-operator to 0.8.3
+0256ecc54 Merge pull request #247 from ecordell/resync
+2f33d3268 e2e: Load catalog entries from the in-cluster catalog and verify they  install
+9f7f18051 Requeue more often when we know we can shortcut a resync
+290a00f28 Merge pull request #246 from ecordell/debugging-docs
+3695458cf Merge pull request #188 from ecordell/GC-CSVs
+68f7ab026 Add a doc on tracing errors through from ALM resources
+b099acc14 Merge pull request #245 from hongchaodeng/up
+bdfa7f0e1 Minor renaming / refactoring
+b0cecb698 Refactor e2e test utils
+cbdf8579c Port drive design docs to the repo
+55cf862f5 Add docs on GCing and the new packaging format
+428cede68 catalog: update etcd-operator 0.8.2 and vault-operator 0.1.8
+3d84b8786 Fix e2e tests
+f9ec5b11e Only query for csvsInNamespace once per loop
+4770ac7ad Add requeuing logic to simplify state handling
+7914ea6b3 e2e tests for CSV upgrades
+c74887f7b Clean up old CSVs if they're successfully replaced.
+c7067efb0 Don't queue up delete events (we take no actions for any of them)
+4ace6f49a Merge pull request #243 from ecordell/update-vault-etcd
+b9cc6ef7f Update packaging for vault and etcd to use the new package format
+5ff9c26d6 catalog_resources: add etcd backup/restore operator and bump up etcd/vault operator version
+05fa73b64 Merge pull request #242 from josephschorr/joseph.schorr/ALM-394/package-crd
+f0ac71ce3 Implement ListLatestCSVsForCRD, which finds the latest CSV holding a CRD, per channel
+23de2bafd Merge pull request #238 from josephschorr/joseph.schorr/ALM-394/channel
+8641ec583 Add concept of packages to catalog, for tracking of services at a grouped level
+11817365e Merge pull request #240 from alecmerdler/ALM-412
+817290acd better description for EtcdCluster in Vault CSV to drive UI
+049c95247 Merge pull request #239 from alecmerdler/etcd-resource-requirements
+26d56074c add spec descriptor for ResourceRequirements for etcd
+ddcf8ac5f Merge pull request #237 from alecmerdler/prometheus-resource-requirements
+fa6f10b59 modify spec descriptors for Prometheus OCS
+824c629a8 Merge pull request #235 from ecordell/fix-master-e2e
+e70ebc763 Use generate unique name for e2e job
+d44d23df7 Merge pull request #234 from josephschorr/joseph.schorr/ALM-392/latest-lookup
+b08f555c7 Rename and export FindReplacementCSVForName method
+406668fab Merge pull request #232 from josephschorr/joseph.schorr/ALM-392/catalog-lookup
+a8b7d23c6 Remove references to Service Name in catalog
+bec809cc4 Merge pull request #225 from ecordell/cd-to-separate-cluster
+94c0b2930 Merge pull request #231 from josephschorr/joseph.schorr/ALM-392/catalog-sort
+6e76a45fe Merge pull request #230 from alecmerdler/ALM-395
+ab2c65122 Cleanup Catalog interface in prep for fixing how we handle service names
+0a66aee97 Don't use helm upgrade
+c99e53ddf add labels to OCS catalog ClusterServiceVersion templates
+5408b2e77 Move all scripts to /scripts
+5d6d6f134 Seperate update-catalog into its own script
+4c7502bdc Update e2e tests to run in separate cluster
+c5b1d2db9 CD to separate cluster
+6c5dd48ec Merge pull request #226 from jzelinskie/tectonic-visibility
+9a01b400a add visibility annotation to catalog resources
+d5049fa56 move build catalog script to hack/
+49f7593b8 fix whitespace stripping from configmap generation
+2eb49ee52 Merge pull request #223 from jzelinskie/lithium-x-operator
+f630af96d deploy/TAO: use stable release of x-operator
+a8c2a814f Merge pull request #224 from alecmerdler/etcd-csv-servicename
+e002a5b9e update EtcdCluster s/service/serviceName
+6a7996901 Merge pull request #222 from coreos-inc/chore/ericavonb/clean-up-artifacts
+2a0bf3cc7 chore(.gitignore): ignore test artifacts
+bc9a49f45 chore(Makefile): remove vendor update from e2e-local
+572b8fc62 style(buiild_catalog_configmap.sh): trim trailing whitespace
+6c4d6077d test(e2e): test catalog entries visibility set correctly
+b7af133ff Merge pull request #217 from coreos-inc/ericavonb/ALM-347/label-uice-visibility
+62e196288 style(catalog_resources): add newline at end of file
+14d01bf07 feat(catalog/uicatalogentries): add label via csv annotation for visiblity
+55ee69b91 Merge pull request #213 from dcondomitti/e2e-backend-1
+6e4520468 Consolidate vault operator version references
+9aa3216b9 Merge pull request #220 from coreos-inc/fix-cp
+461b9e3a4 fix(package-release): use gnu compatible cp options
+0be59144f Add errors package to vendored dependencies
+5e73bef6c Add readme for tests
+126917d77 Add note for running single test
+b360fe530 Add test ensuring Vault cluster is created with etcd pods
+b85e8b968 Cleanup
+14e18c4ea Add failed InstallPlan phase and skip test for it
+301a44bfd Refactor InstallPlan fetching and allow passing an anonymous checker function
+0793b6146 Add test for creating InstallPlans with invalid CSV names
+f587bd2db Add test for creating InstallPlans with invalid CSV names without a Failed plan state
+ae1f1716d Add test for creating InstallPlans from UICatalogEntry list
+ccdf79627 Adds test for expected UICatalogEntries
+55bfd5824 Add the ability to run a single test
+e68c42720 Merge pull request #219 from ecordell/containerized-e2e
+e8fa1278e Tag e2e test container with latest when master builds
+97d44bc31 Take $NAMESPACE as an argument for updating the catalog
+715202dbd Put jq script for convert to tap format into a separate file
+d99da25c6 Containerize e2e testing and output TAP format
+87bef05ef Merge pull request #216 from robszumski/fix-list
+324022bac catalog: fix inconsistent header size
+9de742bc4 catalog: fix markdown formatting/rendering
+12abca115 Merge pull request #215 from hhoover/testmanualapproval
+478bb1ee4 [e2e] Add a test for InstallPlans with  manual approval
+91b819803 Merge pull request #214 from ecordell/0.2.1
+df7abf39d Release alm 0.2.1
+cec6e9c1f Merge pull request #212 from dcondomitti/test_bash_fix
+7991570bc Fix parameter count comparisons
+542650a3f Merge pull request #211 from ecordell/bump-vault
+3ee73d9a9 Bump vault OCS version
+0549b28a1 Merge pull request #210 from ecordell/remove-alpha
+8075158e9 remove alpha files
+eba63db69 Merge pull request #193 from ecordell/release-packaging
+9eaa5404c Merge pull request #209 from jzelinskie/fix-source-list
+7e3223c1f operators/catalog: only add catalogsources once
+51716139b Add docs for packaging
+e8e0b0c30 Fix catalog resource tests and remove samples
+e1a5b8ebc Add packaging script to generate x-operator manifests
+03a1a9d1c rename chart directory to "chart"
+3bd1252af Merge pull request #208 from ecordell/update-0-2-0
+6814bc295 Update 0.2.0 manifests
+20f6bbc81 Merge pull request #207 from ecordell/update-0-2-0
+d20dbd98a Update etcd-operator
+5a3c2fcaa Merge pull request #206 from ecordell/update-0-2-0
+48485c1c6 Update alm versions in 0.2.0 release
+a644a04e0 Merge pull request #205 from jzelinskie/add-type
+b45efefee Merge pull request #204 from ecordell/ALM-268/latest-catalog-versions
+53d5e230f operators/catalog: add Type field to copied Secret
+99ba86547 Update etcd and prometheus to latest operator versions
+8daa2d8a3 Merge pull request #203 from alecmerdler/update-vault
+9155159a8 update Vault OCS SHA w/ make update-catalog
+1f521ad59 Merge pull request #202 from alecmerdler/update-catalog-resources
+6c3738a54 run 'make update-catalog' for ALM-316
+05d807ab4 Merge pull request #201 from alecmerdler/vault-resources
+044a21808 reorder CRD resources to correctly match ownerrefs
+e4da75fcf Merge pull request #200 from alecmerdler/ALM-316-codegen
+f3f3c8737 run codegen for ALM-316
+d12018e8a Merge pull request #198 from alecmerdler/ALM-316
+7ea21a602 add resources to Operator CSVs to complete the ownerref chain
+ee27f503e add 'resources' block to ClusterServiceVersion types
+6dba184a0 Merge pull request #195 from ecordell/remove-catalogsource-cr
+311e3a139 Merge pull request #197 from jzelinskie/bump-ops
+51042fe05 tectonic-alm-operator: bump operator SHAs
+789ffa735 Merge pull request #196 from jzelinskie/cp-secret
+c7b61f856 operators/catalog: only copy secret data
+39d358c86 Merge pull request #194 from jakedt/ohtwozero
+de5d5b387 Update the OCS to pick up the latest changes
+6cbf8ab64 Fix the defective CSV schema
+4afd9d27e Fix up the alm_resources install directory
+55a0feb65 Update manifests for v0.2.0.
+f8eca24b4 Remove catalogsource cr from helm chart (catalog creates it on start)
+de0e1b25c Copy over the resource for the 0.1.2 release and renumber
+7bfdabbf9 Merge pull request #189 from jzelinskie/ip-secret
+4c0e33bb8 Don't use full apiversion as resource name in CSV client
+e644327b1 Remove incomplete e2e test
+1f9115a39 Fix nil pointer error in CatalogSourceClient
+44e32a2c4 Add catalog source to helm chart
+d1068f851 Merge branch 'ip-secret' of github.com:jzelinskie/alm into jzelinskie-ip-secret
+9b629a516 Merge pull request #175 from alecmerdler/vault-operator-update
+46fb2d0bb Update OCS configmap
+7fd9a5e88 Merge branch 'vault-operator-update' of github.com:alecmerdler/alm into alecmerdler-vault-operator-update
+337723789 update Vault ClusterServiceVersion
+841314c9c helm: add configmap
+d9d9f4553 glide: bump lock file
+bb2b24729 install: add CatalogSource CRD
+503487dbb Merge pull request #191 from alecmerdler/catalogsource-configmap
+66a8e7888 cmd/catalog: bootstrap OCS catalog
+bba0cde5e for posterity
+a1141f55b Merge pull request #178 from ecordell/ALM-308/csv-replaces
+893d5ee01 Refactor install strategy deployment check
+2893e4720 Merge pull request #190 from josephschorr/joseph.schorr/ALM-311/resources
+d98d9c9c5 Add resources blocks for the CRDs defined in the OCS
+ab7464b58 CSV upgrades: look for deployments by name, upgrade any with the same name in the new CSV, delete any that are in the old but not the new, create any that are in the new but not the old.
+58678730b operators/catalog: rename aceClient uiceClient
+ef8d93ee7 feat(*): specify objectmeta for CSV to replace
+7ccbcaa82 test(pkg/client/deployment): add serviceaccount tests
+18f91f980 refactor(pkg/client/deployment): use operator-client service account fns directly
+ad1987618 operators/catalog: fix grammar in comments
+ee7efb253 operators/catalog: support secrets in InstallPlans
+187f38542 Merge pull request #187 from jakedt/renameace
+8e99876c2 Properly label all resources that will be managed by x-operator
+a5c2565eb Prepare test cluster with CatalogSource CRD
+fb4c1bc25 Rename AlphaCatalogEntry to UICatalogEntry
+05a7c746a Fixes for the Catalog configmap generator
+7b3e28dff Merge pull request #185 from jakedt/csclient
+c90fcd264 Add the OCS catalog as a ConfigMap
+a660e8c0e Fix typo in CSV schema
+a505195bd Merge pull request #181 from jzelinskie/catentries
+5bda1381d operators/catalog: return error instead of fatal
+c8746426e Merge pull request #186 from alecmerdler/prometheus-spec-descriptors
+a0cca6078 fix Prometheus specDescriptors
+c34cdf663 operators/catalog: init CatalogSource control loop
+f11cb1ade Merge pull request #183 from jakedt/csclient
+fc5b81ee2 Merge pull request #184 from robszumski/link-to-docs
+4fa118562 Add a config map loader for catalog sources
+ff5b90a13 catalog: link to OCS user docs
+eea8ea28a Merge pull request #182 from robszumski/update-desc
+dca4f406d catalog: beta -> alpha
+69f9a51a1 catalog: update OCS descriptions
+f67cc65cd Merge pull request #179 from alecmerdler/prometheus-spec-descriptors
+37ddb3851 add more spec descriptors for Prometheus CRDs
+a626be6b1 Merge pull request #177 from josephschorr/prom-service-account
+17457cd9e Merge pull request #176 from jakedt/csclient
+1cd9b1ee1 Update prometheusoperator.clusterserviceversion.yaml
+a0b03ff97 Add prometheus role
+51fa6dd49 Add a catalogsource client with create and update function
+797f2c294 Tiny fix to use a const to set the CSV CRD name
+5cd9318e4 Remove URL from catalogsource CRD until we have a remote catalog type
+84bf532c6 Merge pull request #172 from ecordell/e2e-testing-harness
+6b0e966fc Set catalog namespace when deploying for preview
+da41202d1 Fix runtime panic due to client-go changes in new operator-client version
+25d24dad5 Support both kube-1.7 and kube-1.8 in deploy charts
+23a1c50fe Update to tectonic-operators
+8995af638 Throw error when validating resources if asked to validate a kind we don't handle
+8a3303352 Add local e2e testing scripts and an example e2e test
+e8c2a217a chart: Remove unused ClusterRole and make catalog namespace configurable
+36dfc9f08 Refactor installplan name into constant
+2e9649597 Merge pull request #173 from ecordell/fix-catalog-resources
+a7cd4c6b4 Update all catalog resources with the new CSV format
+97dda8d93 Merge pull request #174 from coreos-inc/ericavonb/ALM-307/deployment-compare
+9b80d3fce fix(pkg/install/deployment): compare deps by name/ownerref only
+61aff8f26 Merge pull request #171 from coreos-inc/fix-error-returned
+4ccac1dd8 Merge pull request #170 from coreos-inc/prom-status-spec
+ef71a168c fix(pkg/operators/alm/operator): put correct error in status on install failure
+e6399bab2 Add cluster size status descriptor to prometheus
+237990a9f Merge pull request #162 from coreos-inc/ericavonb/ALM-268/operator-upgrades
+6d4798fcc test(pkg/install/deployment): create suite of table tests
+a42dbf0c8 test(pkg/install/deployment): make more explicit tests
+b4bde65d3 refactor(pkg/install/deployment): break up install function
+df3a5f855 fix(pkg/install): use Create*OrUpdate*Deployment
+12475d0dd style(pkg/install/deployment_test): remove unnecessary struct init
+5f0a9199e refactor(pkg/install/deployment): use semantic comparision
+d05e18b69 fix(pkg/client/deployment): use cascading delete for deployments
+92376d704 style(pkg/client/deployment): add newline b/w functions
+3915349e7 hack(install/deployment): make current tests for dep updates pass
+9a2572b86 fix(install/deployment_test): use correct type in array
+fd15f84da feat(install/deployment): create or update or delete deployments
+650310df4 feat(install/deployment): check deployments installed by name/spec
+217a408cf feat(client/deployment_install): create OR update deployment by name
+011792069 feat(install/deployment): create consistent dep names
+b2d0f201e Merge pull request #168 from jzelinskie/pull-secret
+606dbbc2e catalogsource: add metadata fields
+eadf663db catalogsource: add omitempty tags
+d2e3fc60b installplan: add catalogSources to status
+b6453006c catalog: init ocs catalog source resource
+a998f80f6 catalogsource: add k8s interface codegen
+ccaf36d2a init catalogsource type
+8a8c8903c Merge pull request #167 from alecmerdler/ALM-293
+1297eda32 remove placeholder statusDescriptors
+18862579e Merge pull request #166 from coreos-inc/update-app-version
+6480e9998 Update appversion.yaml
+9e2965186 Merge pull request #165 from jzelinskie/0-1-2
+4207407cd TAO: README w/ tectonic-operators build instructions
+cadcfb152 tectonic-alm-operator: bump operator image SHAs
+8db996403 tectonic-alm-operator: copy v0.1.1 to v0.1.2
+68a58b747 Merge pull request #164 from ecordell/fix-namespaces
+db1469644 Swap namespace/name in annotation so that they match the env vars
+5e399a100 Merge pull request #161 from alecmerdler/ALM-290
+4fd53e65a add version to deployment ownerReference
+165513979 Merge pull request #158 from jzelinskie/alpha
+7bd20e2b5 alpha: explicitly pass manifests directory
+52f2803a0 x-operator: build image based on alpine x-operator
+5b1a33fa6 x-operator: fix CSV CRD schema in v0.1.1 manifests
+d5ad65dd2 Merge pull request #159 from josephschorr/fix-tooling-and-docs
+c46680642 Fix generate-mock-client to generate from/into the pkg directory
+eb7f330c1 Add missing dependency tools to the DEVELOPMENT file
+d65acfda5 alpha: bump v0.1.1
+b8850478f Merge pull request #156 from dgonyeo/master
+9188f4de9 alpha: init
+01cb6b3e2 deploy: cut v0.1.1 tectonic-alm-operator
+ce8d1fd33 deploy: copy v0.1.0 manifests to v0.1.1
+6fb77bedd pkg/catalog/directory_loader.go: skip hidden nodes
+1a34120ff Merge pull request #157 from coreos-inc/ericavonb/ALM-256/annotate-namespaces
+67e4caeeb style(cmd/alm): format usage string on flag better
+c45c3e2b7 Merge pull request #150 from coreos-inc/ericavonb/ALM-256/annotate-namespaces
+f4d1a35af Merge pull request #155 from alecmerdler/empty-csv-icon
+a103f14ab refactor(alm/operator): clarify watched namespaces
+83283061e fix(alm/operator): use non-wrapped client
+76099de61 fix(Makefile): make 'all' the default target
+1720f1573 refactor(alm): pass in annotations from main
+15bdb2549 style(alm/operator): simplify variable name
+6afd3cafb style(alm/operator): rename function args
+25f4ec424 fix(alm/operator): watch all namespaces if none provided
+518f5beb4 fix+refactor(pkg/operators/alm): watch specific namespaces only
+d493055a1 feat(pkg/annotator,pkg/operators/alm): add control loop for annotating namespaces
+9d3c44cd7 rearrange(pkg/annotater->pkg/annotator): spell annotator correctly
+e6ece3fd9 allow icon to be empty in CSV
+dc92a7ec1 Merge pull request #154 from coreos-inc/ericavonb/fixup/codegen-csvs
+3685e3b3f chore(apis/csv): regenerate api objects
+77a4efe7d Merge pull request #153 from ecordell/fix-csv
+c4263dc7e Fixes clusterserviceversion schema
+cb7a85123 Merge pull request #148 from jzelinskie/docs-reboot
+06f528b0d docs/architecture: add control loop details
+389f58ec8 Merge pull request #152 from coreos-inc/rm-pull-secret
+5e27c8a59 docs/install: remove coreos-pull-secret
+fee3b0ddb Merge pull request #151 from josephschorr/console-guide
+220c0342e Update install docs for the cut branch of Console
+96b736d7d Merge pull request #149 from alecmerdler/spec-descriptors
+c8adf0e65 add SpecDescriptors to ClusterServiceVersion
+61c761acf Merge pull request #145 from jakedt/xoperator
+9ffa4c0d1 Add the required resources to let x-operator install ALM in minikube
+3136f0081 Add a specialization of the x-operator for ALM
+3b2758751 Merge pull request #147 from jzelinskie/coverage-badge
+2c91aadf3 docs/design: add manual install stub
+878df9f5d docs/design: add architecture doc and fix readme
+0bd266438 docs/design: delete stale design docs
+f4a9c0061 docs/design: delete old mocks
+66e425a02 README: add quay badge
+ea1f12665 Merge pull request #134 from coreos-inc/ericavonb/ALM-212/installplan-status
+335619cb1 style(*): alias core/v1 import everywhere as corev1
+4fa080932 Merge pull request #146 from ericchiang/readme-link-fix
+e038534b9 README: fix install link and JIRA link
+9952d4569 refactor(installplan): abstract away conditions array in status
+67c247bc0 style(catalog): use consistent import names
+810f34129 test(pkg/apis/installplan/v1alpha1/types): test setting conditions in status
+477bca533 refactor(pkg/operators/catalog): explicitly switch on err to set conditions
+8c0aed101 chore(apis/installplan/v1alpha1/types): use conditions instead of phase in status
+b1d637171 Merge pull request #143 from ecordell/test-catalog-resources
+4a5e04fc8 Test our catalog resources for consistency
+cb1f07b7d Merge pull request #142 from josephschorr/joseph.schorr/ALM-248/vault-csv
+c01f977ea Adjust CSV status descriptors for Vault to reflect new status block
+6dcae0af5 Merge pull request #141 from ecordell/update-package
+55b62a8b7 Update alm/catalog images in install resources
+98c7b0a51 Merge pull request #140 from ecordell/unit-tests
+ac53025c3 Remove commented code
+53e2b814e Fix namespace labelling bug
+92879d724 Move code into /pkg and create coverage report
+987afaed8 Add more unit tests
+462a147e1 Merge pull request #138 from josephschorr/joseph.schorr/ALM-228/short-names
+01583dba0 Add various shortNames to the various CRDs
+dc681f98f Merge pull request #139 from josephschorr/joseph.schorr/ALM-202/proper-contact-info
+ee4d755b9 Change maintainers and add useful links to our CSVs
+df5fb769f Merge pull request #137 from josephschorr/joseph.schorr/ALM-248/fix-csvs
+eb3669ae5 Update etcd Cluster CSV to have it display real status information
+bdc2e42f5 Merge pull request #136 from alecmerdler/wrong-alertmanager-crd
+b460d91d2 Add "coverage" (html) and "cover" (cli) commands, update to exclude mocks
+90204948e spellcheck
+b6c40ce67 Merge pull request #135 from ecordell/fix-catalog
+757a28ae6 Fix catalog resources
+a82cc1d04 Merge pull request #132 from ecordell/unit-test-install-strategy
+58df3f0fb Merge pull request #133 from ecordell/ALM-226/annotate-namespaces
+a9441b778 Refactor deployment strategy client + naming fixes
+04006ca64 Switch to patch for updating namespace
+f55998e70 Annotate namespaces on ALM operator start
+76e2d4f14 Deploy install strategy: Add tests for error cases
+23831465c Add tests for deployment install strategy with role generation
+5f702eb13 Refactor install strategies
+b0d6fb376 Merge pull request #128 from jzelinskie/ip-test2
+811cff1d5 Merge pull request #131 from ecordell/ALM-211/more-crd-info
+2e71fe157 apis/installplan: test JSON manifest on StepRes
+00e457085 operators/catalog: test creation of dependent CRDs
+af1d33f59 csv/customresourcedefinitions: add version and kind
+b7c8fe2ab Merge pull request #127 from coreos-inc/ericavonb/ALM-179/clean-up
+44008212e test(client/alphacatalogentry): refactor tests into table fmt
+3bebeae20 fix(apis/clusterserviceversion): correct json tag
+8dca0c6c4 Merge pull request #130 from ecordell/update-images
+ab1baaa76 wip
+e1260daa4 Update alm and catalog images to latest
+6ad416d9d test(client/alphacatalogclient): more thoroughly test update cases
+c8d3f9b2c test(client/alphacatalogentry): test error case
+62557efb0 test(client/alphacatalogentry): test upsert behavior
+51a7c34bf test(client/alphacatalogentry): add test machinery
+370c10ba4 operators/catalog: s/CreatePlan/ResolvePlan
+143ba6991 apis/csv: fix nondeterminism in GetAllCRDDescs
+85f17ae6b Merge pull request #124 from ecordell/ALM-190/recreate-missing-resources-csv
+7af7f6c30 operators/catalog: refactor and table-testify
+6e9da6a37 apis/installplan: add StepResource constructors
+91debfc17 apis/csv: rename GetAllCrds and table test
+b86464ebb catalog: resources should use correct sha256 image names
+9c9c7097f alm/operator: Add a test for transitioning to pending if component goes unhealthy
+14370a1d6 alm/operator: check if resource has gone missing and replace it if so
+03e41a2da Merge pull request #126 from ecordell/pull-secret-clean
+98891186b remove pull secret from install
+c457adbb6 Merge pull request #125 from coreos-inc/ericavonb/ALM-179/clean-up
+5dec900e0 Merge pull request #123 from ecordell/update-catalog
+b45019ef7 fix(catalog/alphacatalogentries): set sync status correctly
+184d14ff6 test(catalog): test store sync
+9f3579e3a Merge pull request #118 from coreos-inc/robszumski-patch-1
+f95121062 Merge pull request #121 from ecordell/ALM-193/gc-rbac
+0e96b11d9 Update etcd and vault to latest releases
+e68b22415 Merge pull request #120 from ecordell/ALM-196/omittempty
+4cfe1e0f4 Merge pull request #122 from coreos-inc/ericavonb/ALM-176/idempotent-aces
+37af472a0 fix(client/alphacatalogentry): use put not patch
+86fa7cc00 doc(catalog): add debug lines
+23cff0795 style(client/alphaservicecatalog): remove nested ifs
+77780f336 feat(client/alphacatalogentry): patch existing catalogentries
+1bd9c3d6d WIP
+494096e2d refactor(cmd/catalog/main): clean up file
+f36488533 Set ownerreferences on all objects created from install strategy
+273c51929 Add omittempty to fields on CSV
+fb8ae2e4a Update install.md
+2c65697f0 Merge pull request #117 from ecordell/local-install
+8e1cb54b7 Install instructions for ALM + Bridge locally with minikube
+c60fcfe88 Merge pull request #113 from ecordell/update-catalog-labeling
+c1af2910d Add serviceaccount for vault
+b2b23fd11 (temporarily) use dev versions of vault and etcd operator
+77875e693 Update catalog resource labelling
+e5b72c9a9 Merge pull request #115 from jzelinskie/ip-test
+4f244c99d Merge pull request #112 from ecordell/add-coverage
+7712ad1e3 Merge pull request #111 from ecordell/update-install-manifests
+4aa8a32b7 apis/csv: make OwnsCRD a CSV method
+e39f22265 operators/catalog: decouple phases from logic
+872aab831 queueinformer: move MockListWatcher
+1abd54a26 operators/catalog: table-driven csvOwnsCRD test
+5297b6760 Add command for generating coverage report
+2a1f47933 Update install instructions
+b88d29635 Update rendered yamls for installation
+35663cbee Merge pull request #109 from ecordell/prometheus-working
+9d67f083f Update prometheus defintions
+c0f43fcb3 Merge pull request #110 from coreos-inc/ericavonb/quick-doc-fix
+2fc8a8741 doc(control-loops): update CRD name to InstallPlan
+68a1ff41a Merge pull request #108 from ecordell/alpha-catalog-and-bugfixes
+693287b78 Update prometheus
+e9b809b3e Better naming and log levels
+82302814c Update prometheus CSV to 0.14.0
+9ac84d5fa InstallPlanList should be a list of InstallPlans, not InstallPlanSpecs
+aa3b5a71f wait for caches to sync before processing queue
+68379bf2c Prometheus CSV should use the same serviceaccount in permissions and deployment
+81e203cb5 Better log messages on catalog operator
+d4cbbdedd Add entry matcher for alphacatalogentry client tests
+120908d36 Restore alphacatalogentry test
+1e13cf7bf Switch to log.Fatalf
+bf13acc1b Update vault CSV to point to latest version, and use coreos-pull-secret
+5a314066a Fix operator tests
+eb2195549 Ignore if alphacatalogentry exists
+5f755525d If AlphaCatalogEntry exists, update with a put
+a229712a9 re-enable alphacatalogentry generation
+eec650218 Installplan should resolve to objects in the same namespace
+304622e68 Serialize resolved resources as json
+c24aa8381 Fix operator loop
+561a8cb4c Add logging to installplan resolution
+56ebf9d21 Add more logging to queueinformer
+8820c18c1 Add more logging to catalog operator
+a29688d29 Update installplan types
+415567ead don't generate alphacatalogentries for now
+820dde7a6 Ignore if catalog entries exist
+62ab7ff16 Delete/recreate alphacatalog entries
+1d8e60836 Update even if there's a transition error
+9b511d237 Patch don't put
+1d6fc4fd9 Set initial phase to planning on installplan
+bef73f951 Fix alphacatalogentry api calls
+e621d84d3 Install alphacatalogentries into configured namespace
+3aeb6c346 Add logging to alphacatalogclient
+c4654c533 Return early if no error creating resources
+39534c680 create AlphaCatalogEntry if it doesn't exist
+a32cd932b Update catalog resources for self-consistancy
+228c57389 Add more descriptive errors
+df31254be add catalog files to container
+33e26a10a catalog: more logging
+8a5047640 Load catalog resources into cluster as AlphaCatalogEntries
+061616272 Create alphacatalogentry on deploy
+94d474ae2 Merge pull request #103 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-173/alphacatalogentries
+35222264e Fix vet error
+460703c1a test(operators/catalog): add ListServices method to test impl of interface
+dc117bbc2 test(catalog/alphacatalogentries): fix test mocks
+bce5c5c18 fix(catalog/alphacatalogentries): correct pt/receiver types'
+dff6d6db9 test(alphacatalogentries): test catalog sync
+aed9b2f2f chore(mock_alphacatalogentry_client): generate mock
+6a442d511 feat(catalog,client/alphacatalogentry): sync catalog to CRs functionality
+5d11423bd feat(catalog/types,mem): add method on interface for listing all services
+76f465f2b Merge pull request #102 from jzelinskie/installinstallplan
+274fb8d0d operators/catalog: add multi-source TODO
+8363ffae3 operators/catalog: transition to install phase
+92f6103f3 makefile: generate installplan mocks
+9c3317819 Merge pull request #106 from ecordell/load-catalog-from-files
+00320dda1 Load in memory catalog from a directory
+17b7996d9 makefile: add gen-all command and run
+0525e7641 operators/catalog: init installing a plan
+ca44d4b71 Merge pull request #95 from coreos-inc/ALM-158-install-plan
+243b5d009 Add CSV to install plan resolution
+d6752bfe2 Merge pull request #105 from jzelinskie/csv-provider
+3877eb87d apis/csv: add missing provider field
+de6a2c2fe Merge pull request #100 from ecordell/catalog-resources
+aac599c18 Add prometheus and vault catalog resources
+3f1bb5d23 Fix tests
+fc4a46002 feat(operators/catalog/install_plan.go): adding resources to install plan
+a9aa77792 Merge pull request #97 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-173/tests
+f413aa091 test(catalog/mem): sort CSVs returned by version
+c96101ed9 chore(catalog/mem): update data types
+a831e90b6 test(catalog): simplify tests
+9d71d36c9 Add catalog resources directory and test catalog resources
+a4313abea doc(catalog/mem): update comments
+a67cd731b feat(catalog/manifest): add loading manifests from file
+443f46668 test(catalog/mem): test basic catalog fns
+7db6f5327 Merge pull request #99 from ecordell/move-outputs-to-csv
+22b0c9b4c Merge pull request #94 from ecordell/move-outputs-to-csv
+152b0c961 Update regex for resolved etcd cluster
+660523b70 Fix tests
+0d5602740 Update etcd resource permissions
+cf4193b99 Fix sync
+2ec7fcdb2 Remove unused config mount
+efc5b820f Fix rebase
+0538e6375 Dob't create serviceaccount if it already exists
+ad8eef8c3 Fix role creation
+3ee37df6b Log error when install fails
+a472de848 Validate that example CSVs can be parsed into CSV type
+71d896a91 Rename capability -> descriptor
+24369398d Add implementation of permissions generation for CSVs
+10f88384a Add permissions block to install strategy on CSV
+87fe45612 Update CSV types and parsing to match new CRD description design
+d06dd2d37 Move labels -> template/labels for CRDs
+571f1e7be Rename x-alm-capabilities -> x-descriptors
+1383af90c Move output definitions to CSV and move output values to status block
+a3e4a3cf6 Merge pull request #96 from jzelinskie/installplanctrl
+acbb410bf operators/alm: replace config map with flags
+28176c40d ci: add missing pre-step for catalog
+641a1342a helm/gitlab: add new deployment for catalog
+227271de9 operators: init installplan operator
+1486c1b27 Merge pull request #93 from jzelinskie/fix-fuckups
+7168eb11c installplan: fix inconsistent samples
+9ece589c5 Merge pull request #91 from ecordell/fix-etcd-installplan
+53e003cf8 Update etcd installplan to match schema
+84eb3c116 Merge pull request #77 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation
+bece1a043 chore(catalog/mem): update fns for mem catalog
+ba1e3b0fd refactor(catalog/types): shorten interface fn names
+bf09c0426 Merge pull request #90 from jzelinskie/installplan
+7b44fdb0d installplan: add types for Install Plan Status
+84fbe362d temp
+1958ee917 refactor(catalog): embed ClusterServiceVersion spec in AlphaCatalogEntrySpec
+5b26cdbe2 feat(catalog): map CSVs to the versions they replace
+b70208116 Merge master into ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation
+e155e8834 Merge pull request #83 from coreos-inc/req-status
+8f682dd4d Merge pull request #85 from coreos-inc/ericavonb/ALM-124/service-catalog/withentrycrds/ALM-152-catalog-source
+84d7e3f10 Fix rebase
+094624327 doc(vault.alphacatalogentry): fix sample name
+33cd3c848 fix(alphacatalogentry): regen code for alphacatalogentry types
+e2ff74f4b Merge pull request #89 from jzelinskie/fix-ci
+bb886bd69 Fix rebase issues
+5fd058ad0 use return instead of break in switch
+1f883b2e0 Fix icon parsing
+7885cbd6a Add full state transition tests for clusterserviceversion status
+b9cdb834c gitlab: run glide install in test stage
+a418e5c02 Revert "Merge pull request #86 from jzelinskie/ci-uniq-base"
+8c1806f95 Refactor phase transitions for clarity and testability
+4557f6dc9 Update codegen
+67d3ef518 Fix typos
+6af6f45b6 Fix CSV type (deprecated fields)
+123b97514 Add missing return from phase transition caused double install
+baa023f51 Use switch for phases
+b2e45f787 Check if deployment is installed before attempting install
+c27f3404c fix(alphacatalogentry.crd.yaml): add names
+d02d92a39 Update etcd cluster crd to be versioned
+8871532bd Adds a state transition test
+1c864082b Add mock alm operator for testing
+f444c721e towards a mock alm operator
+5988f7a0f Write conditions to status during state transitions
+16b745178 Add conditions as a history of state transitions to csv status
+8fd783fbb Resolve rebase conflicts
+f85814d4a Write requirement status back to status block
+df6e46aa4 Cleanup phase transitions
+8df808b08 Only check for CRD existance
+0ad75fe98 Update gitlab pipeline
+fdcc6c531 sketch out phase transitions
+bfd87540a Check for phase before attempting to install
+46310f300 Add ClusterServiceVersionStatus
+dd119dd51 Add schema for ClusterServiceVersion status
+e069292f2 Look for requirements in same namespace as ClusterServiceVersion is defined
+70a7ce024 Move config handling to its own package
+83d7a4afb Merge pull request #84 from coreos-inc/ALM-142-add-owner-ref
+8e0115169 doc(catalogsource.yaml): remove example catalogsource resource defs
+805c59547 feat(alm,install): adding in owner reference to deployment
+bef5f9d19 doc(vault.alphacatalogentry): add vault catalog entry example
+9ce7e9b4e doc(alphacatalogentry.yaml): create CRD yaml
+f015e7c36 feat(alphacatalogentry): add provider field
+968b0a61f refactor(apis/catalogsource): remove for now
+335cca566 Merge pull request #86 from jzelinskie/ci-uniq-base
+4fb37402d gitlab: base image now unique per git ref
+1efbc9087 doc(catalogsource): remove extraneous comment
+7b8476845 refactor(apptype->alphacatalogentry): rename crd for catalog
+beb9ec957 feat(apis/apptype): add back in apptype crds
+0b2e6bdcf chore(catalogsource): only have one url per src
+f8a33bafc feat(catalogsource): update spec for console to consume
+8b5860f4b feat(apis/catalogsource): add new CRD for catalog
+0d6abe848 style(catalog/mem): use variadic fn arg variable names
+c636f5116 refactor(catalog): rename in-memory golang maps catalog implementation
+83e1fb2ce refactor(catalog): rename fn to remove ambiguity
+2a501322c style(catalog/mem): order import blocks
+ea31478eb style(catalog/mem): use explicit key/vals for struct
+cf8eb296e refactor(catalog/mem): remove sources subpackage, enforce interface
+ae55f856b feat(catalog/sources/mem): add simple catalog implementation
+718ce0946 style(catalog/mem): use variadic fn arg variable names
+10bdbace5 refactor(catalog): rename in-memory golang maps catalog implementation
+3725b942f refactor(catalog): rename fn to remove ambiguity
+eeb1c0adc style(catalog/mem): order import blocks
+00f2c7934 Merge pull request #82 from coreos-inc/validate-objmeta
+cc3096894 style(catalog/mem): use explicit key/vals for struct
+d09ab7670 refactor(catalog/mem): remove sources subpackage, enforce interface
+4dfb5ec5c Merge pull request #81 from jzelinskie/crds-split
+29e645330 csv: add json tags to CRDs
+d3f658b29 Add tests to validate object metadata
+910df1e1b init Required/Owned CRDs for CSVs
+bf53109f0 Merge pull request #80 from coreos-inc/add-minikube
+2ab5d1478 fix(cmd): fixed config parsing
+c4d10078d Merge pull request #79 from alecmerdler/revise-samples
+baa874a32 fix samples to reflect new updates
+5a2346192 Merge pull request #76 from coreos-inc/ci-fix
+dbf5286b3 Merge pull request #70 from jzelinskie/manages-spec
+73ad50bff fix validation of approval types
+4897b538a remove apptype from codegen
+f60510864 add initial ownedCRDs field to CSV
+9839e295e feat(catalog/sources/mem): add simple catalog implementation
+71d4463b9 Merge pull request #71 from jzelinskie/installplan
+189bd5ce6 fix apiVersion for etcd installplan
+e2fd33ace move Approval type into installplan
+377eefbdd add dashes back to apigroups
+8ff1be6ed add install plan validation
+6557ac009 subscription: fix apptype references
+788441dd7 fix inconsistencies
+8c0730238 capitalize approval types
+e83e5940a s/update only/update-only/
+5484737f4 s/desired// && s/cloud/cluster
+d2dab3168 installplan: add approvals
+9b2caac86 installplan: add RequiresReview status
+a50908fd3 samples/installplan: remove inconsistencies
+e50adb0ed installplan: refactor status
+80aacac78 installplan/v1alpha1: add spec
+c2ef80c91 installplan: add status.status field
+3f4e08aa8 samples: add status for installplan
+46a3bed8a init installplan
+4b5a5a1bc Rename InstallDeclaration -> InstallPlan
+554643d36 Merge pull request #72 from coreos-inc/remove-requirement-namespaces
+824832144 Merge pull request #75 from coreos-inc/ericavonb/ALM-124/service-catalog/ALM-152-catalog-implementation
+29b4c4848 Remove AppType and merge its fields with ClusterServiceVersion
+995d56b5b Merge apptype into clusterserviceversion (examples only)
+dbc627a4a refactor(catalog/mock->catalog/sources/mem)): organize catalog types
+2eaf567b0 Remove namespaces from requirements
+a347d1905 Merge pull request #74 from coreos-inc/alm-151-config
+9dd95919f feat(deploy): add in config map
+ac68250e5 Merge pull request #73 from coreos-inc/fix-merge
+5341eaef0 fix merge of namespacing PR
+18f385fc2 Merge pull request #67 from coreos-inc/alm-151-namespaces
+cac055852 feat(alm): adding in namespace list support
+11d5b9810 Merge pull request #54 from coreos-inc/ericavonb/ALM-124-service-catalog
+8ec965353 refactor(client/{opver->clusterserviceversion}_client): rename file
+8dc5d5c43 refactor(catalog->planner): rename component
+97905c574 refactor(appcache): use new crd name ClusterServiceVersion
+b27da0693 refactor(subscriptions): change pkg name and remove unused mock
+c8adad1b7 feat(appcache/mock): add simple implementation of appcache interface
+9e77b6b48 refactor(appcache/types): use simpler name for interface method
+9274c1231 wip(subscriptions): remove logic for now
+51cf9abff refactor(subscriptions): rename to installplan
+79d12996b feat(apis/catalogsource): remove for now
+3b1999f4e rearrange(subscriptions): move out of catalog pkg
+6dfa868fd feat(catalog/types): simplify interface
+a4cc20f11 feat(appcache): add interface for app catalog cache
+e5a50ea3a rearrange(apis): rename installdeclaration as installplan
+e3ec5a360 feat(catalog): use k8s typed objects
+bb5895395 feat(hack|apis): codegen new types
+9c9cc9d20 feat(apis/installdeclaration): add installdeclaration crd types
+5815ccf1d feat(apis): add catalogsource crd type
+9c5666177 feat(apis/subscription): add cdr structs
+03abf3f8f fix(catalog): fix type inconsistencies
+474bcfbf2 test(catalog): finish memCatalog mock implementation
+9db7d6808 fix(catalog): change fn arg to ptr type
+f065705ec doc(catalog): comment on functions
+7437f5f98 doc(catalog): add comment on temporary type decl
+71fc94818 refactor(catalog): move resolve dependencies to catalog interface
+3c8d83236 test(catalog/subscribe): add empty test file
+6a5c25f03 WIP(v2 catalog): update for new control loops pt 1
+85d70e149 WIP(catalog): sketch out loop ops
+da52eccac Merge pull request #68 from coreos-inc/fix-tests
+3561ec0b4 Fix tests
+d64d70023 Merge pull request #66 from coreos-inc/multiresource-example
+63659d78c Fix apiversions and naming
+409c867e1 Add prometheus example (has multiple resources)
+6e9a2ec8f Merge pull request #63 from coreos-inc/install-instructions
+0af3d2bdb Add a newline
+ab9c40f8d Namespaced examples
+997b1663d Merge pull request #65 from alecmerdler/ui-samples
+ea6542f3d update samples for UI testing
+ac04b4e6c WIP namespace samples
+2ff886217 Don't install self-hosted in install instructions
+41a8d455e Namespace alm
+b2c1a9d99 Fix api versions
+87799109e Inline instructions
+6b52a432b Merge pull request #61 from coreos-inc/subscription-yamls
+9052aa31d Merge pull request #64 from coreos-inc/alm-125-opervar
+1d1bb393d feat(alm): added in check for requirements
+6e1785cf3 Update etcd examples
+b86b5cd90 Fix etcd operatorversion sample so that pod starts
+ba273ba2f Add sourceType and secretName to CatalogSource
+64be21184 Add example resources for Subscription and CatalogSource
+3e7e732ef Merge pull request #53 from jzelinskie/refactor-this-shit
+f86da09f4 Fix deployment test
+3f00cc0a1 Merge pull request #60 from coreos-inc/ericavonb-docs-typo-fix
+4a9bd4960 doc(control-loops): fix typo
+34c222b07 Rename operator -> queueinformer Add queueinformer registration function
+acdf784e3 Rename ControlLoop -> QueueInformer
+b71f70bc6 Formatting fixes
+30e0ac48e Merge pull request #59 from coreos-inc/dep-fix
+658eb0247 attempt to fix dependencies
+76b4d377a Merge pull request #56 from coreos-inc/update-control-loops
+8ad00acd9 Update control-loops.md
+485878039 Update control-loops.md
+f4920a914 Add codegen for runtime.Object deepcopy methods
+791506992 Factor out common operator functionality into a parent Operator and ControlLoop object
+c8e425873 Merge pull request #57 from jzelinskie/glide-k8s
+412c04b0e makefile: add -i flag to `go build`
+45f9b2ccf Move opver client to its own package
+a57c5abf4 Merge pull request #41 from coreos-inc/tested-crds
+7dd10d2ba Refactor install strategies
+89f9295cc Add testing framework for testing sample resources
+957333543 Move opver api registration to apis package, rename alm.go to operator.go remove unused interfaces move apptype type declarations to their own api package
+41034b852 init v1alpha package for OperatorVersion
+7617fcb74 Merge pull request #55 from jzelinskie/glide-k8s
+af1aa02ff Update control-loops.md
+210da533d glide: update operator-client
+6cd14fc45 Merge pull request #52 from coreos-inc/ALM-124/operatorversion-install
+a96d160c5 rename operator -> installstrategies
+096a7bdd7 Check for existing managed deployment before installing new one
+8d92fe31d Remove vendor from `make build`
+36b0c52e5 Update gitlab
+0a8faa10c Add hack for GKE plus some formatting fixes
+1e9aa3c14 Fix imports
+dcb67b95a Add logs on successful install
+5fc66483c WIP: can't use unstructured for subtypes
+3ae0678e7 WIP: can't use unstructured for subtypes
+3958a9bed Register ListKind properly
+2cf765eba Add api registration for operatorversion
+e56a54f82 Create a new client for watching OperatorVersions
+0f49f4d32 Fix watching operatorversions
+f35296e14 Fix operatorversion reference
+aada1399d Install OperatorVersion and AppType before ALM
+17f32044f Fix serviceaccount
+43577c7aa Fix merge conflict in operatorversion
+3ebf36b29 Don't create ns if already exists
+c5fea556f Add CRDs and serviceaccount to helm chart
+aac943550 Control loop runs install strategy Also `cmd` will run operator
+08e4bb5b7 Merge pull request #51 from coreos-inc/test_ci
+26ecc9fe9 Gitlab-ci with jsonnet lib
+11047a242 Update helm-chart
+f6c336018 Merge pull request #40 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-operatorversion
+ff8f323b5 Add deepcopy methods to `OperatorVersionResource`
+cab1ac225 Fix glide.yaml
+7dbe9ced3 Add WIP glide
+adbb0f239 Merge pull request #50 from coreos-inc/ALM-76/install
+234334ccd Merge pull request #49 from coreos-inc/update-vault-example
+7cfec9cea Add install strategies
+64b4389a8 Update example.vaultservice.yaml
+81202b135 Merge pull request #48 from jzelinskie/update-walkthru
+bd70740b3 docs: update walkthrough with validated resources
+283adf4e3 Merge pull request #47 from coreos-inc/ALM-73/ALM-117/ALM-116/kubectlable-resources
+ead0dbe8e Change replaces to a direct resource reference instead of a version
+807567382 Add coreosbot credentials
+bf1197a89 Vendor before test
+3aa9bc9b0 Fix dependencies
+5103da1d9 chore(glide.lock): update dependencies
+22c729f35 doc(scheme/loader): comment on function not for prod
+eae2d9856 style(installers): format imports by type
+5aaf1a566 rearrange(installers): organize pkgs better
+3da14fb3a feat(schema/loader): add util to load CRD from file
+ddb3eb88c feat(operatorinstaller): add initial deployment strategy
+ada4e3f6e rearrange(alm/types): remove unnecessary interfaces files
+92f453195 Better formatting for outputs
+3178246f3 Merge pull request #46 from coreos-inc/add_in_operator_skeleton
+74c75b123 feat(alm): adding in basic operator version watch
+3e17b5bf9 Add displayName to outputs
+f9c0b8590 Move outputs to an annotation and add displayName and description
+1901409e2 Add install instructions and make samples kubectlable again
+30f1c784f Merge pull request #43 from coreos-inc/add-labels
+7f43d7fc3 Change to `alm-owner-`
+86fbc3aaf Add labels to propagate in addition to labels to match
+71d629f29 Add labels for AppType
+a235fa27b Add labels and selectors
+3bd6274be Merge pull request #45 from alecmerdler/fix-yamls
+a9cbecba0 Update loops
+69055ccf1 Remove ALM-managed upgrade option
+85285ecaa Fix typo
+08cdef7f2 Split loops by piece of software, and add upgrade and GC loop descriptions
+6b6f50568 Add explicit creation note to `AppType` loop
+2dac16eae Update control loops to match newest design
+0ff3b259b Add reconciliation loop docs
+9ed79d492 add  field to examples
+238ef405e fix apiVersion in samples
+64675e0ce Merge pull request #42 from coreos-inc/fix-examples
+becf1df62 Fix invalid CRDs and CRs
+ec841a262 Merge pull request #39 from jzelinskie/walkthrough
+b2a102c68 Merge pull request #31 from coreos-inc/opver-spec
+d19cb0b04 Remove blocksInstall from examples
+01b0e7c93 Depend on `CRD` not instances of CRD
+97dd80ff2 Fix etcdoperator operatorversion
+ee302662f Merge pull request #32 from coreos-inc/resolved-resources
+cf40e8dad Add UIDs and update apiVersions
+0ee4f1754 docs/design: init walkthrough
+04f80e6e2 Merge pull request #35 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-fix-deps
+72b7fbbf2 doc(DEVELOPMENT.md): outline glide and make usages
+001951b70 Merge pull request #38 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-k8s-utils
+af41f66be style(alm/types): use golang conventional func naming
+67dc684b5 fix(vendor): go back to glide for golang dep mgmt
+4a15dcb4a Merge pull request #37 from coreos-inc/fix_image_deployment_is_pointing_too
+87196f07a fix(.gitlab-ci.yml): pull correct image
+5539cc8fd Merge pull request #36 from coreos-inc/fix_image_deployment_is_pointing_too
+51a0c7776 fix(values.yaml): moved from quay to coreos
+972f0e35c fix almoperatorversion formatting
+227146dfd Fix formatting on etcdoperatorversion
+8130c7d56 Merge pull request #34 from coreos-inc/fix_deploy_staging
+f803740a6 fix(.gitlab-ci): put in sha at wrong place
+12d057ae0 Merge pull request #33 from coreos-inc/fix_deploy_staging
+afee3cbb2 fix(.gitlab-ci.yml): remove except branches
+7d69cee27 Update vault example to use new requirements format
+46df9b6a2 Update etcd operatorversion to match spec
+45e781f6a Update operatorversion spec and alm.operatorversion.yaml
+33adb51dd Merge pull request #26 from coreos-inc/add_in_deploy_staging
+223341c30 chore(.gitlab-ci.yml): add in deploy staging
+10a1b5305 Add status and ownership to etcd sample
+c74b500a9 Move the examples back under their directories
+843f2bac9 Merge pull request #30 from coreos-inc/vault-example
+f728ebd66 Put `example.` prefix on example CRDs
+bf7b87b1c Add vault sample
+4df1ebad5 Move etcd samples into their own directory
+992dfea5f Merge pull request #28 from jzelinskie/cmd
+73b65bc52 Merge pull request #23 from coreos-inc/metrics-and-links
+ff4e242f1 Merge pull request #21 from coreos-inc/cluster-features-proposal
+32f5e718b cmd/alm: init
+0fb977cdc Merge pull request #14 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton
+38d8c12fc Fix merge and add important.link capability
+8f591b5e7 Add sample etcd cluster instance
+95fb64a81 Add sample outputs
+c487cdacd Add sample proposal for metrics and links as outputs
+ae433aaed Fix rebase issues
+a59f67afc Update requirements version
+a290f2013 Model RBAC requirements as requirements
+b41aacf38 Add example for including cluster features as requirements
+a08a1e292 Merge pull request #25 from jzelinskie/move
+e367e4ae6 README: init
+f6954b8b6 docs: move design work into Documentation directory
+881113123 fix(alm): consolidate apptype cr creation
+b72a36edc chore(Gopkg.lock): update dependencies for interface tests
+64d73613f test(alm/interfaces): add basic unit tests
+aefda21d7 feat(alm/interfaces): define alm functionalities in interface
+66f0ef6d3 chore(godep): update dependencies
+8d2a8b440 feat(alm/types): add type schemas
+f3d0a5081 Merge pull request #22 from coreos-inc/ericavonb/ALM-111/alm-code-skeleton-makefile
+1d3b884b5 chore(Makefile): set up Makefile for test, builds
+0489a95cb Merge pull request #20 from coreos-inc/clean_up_gitlab_ci_yml
+e71f65265 fix(.gitlab-ci.yml): stop ci build on master
+0c5733eb3 Merge pull request #19 from jzelinskie/dep
+55f4fc668 dep: init
+d8c9aa0f0 Merge pull request #16 from coreos-inc/add_in_manual_deploy_of_branch
+3ad841650 chorse(.gitlab-ci.yml): add in manual deploy of branch
+58381352f Merge pull request #15 from coreos-inc/schema-examples
+6feb902d1 Add schema examples
+8bca8366b Merge pull request #17 from jakedt/oopsv3
+6d3d91c9a Switch to the proper JSON field name for the schema https://github.com/kubernetes/kubernetes/commit/6133d84835c59f157a8fb4596f98d2d3cf828bef#diff-3029a18192feb70af52de676209da9b6R149
+8e5c40d5b Merge pull request #10 from jakedt/schemata
+7ff047487 Make the icon information embedded and more strict
+0c285d285 Add schemas for the initial resource types that ALM will manage.
+c63b826cd Merge pull request #12 from coreos-inc/add_in_k8_health_check
+120a5aff1 chore(deploy): add in health check for k8s
+ed8399076 Merge pull request #9 from coreos-inc/add_in_cd
+909b43a14 feat(deploy): added in basic helm chart
+177086968 Merge pull request #5 from coreos-inc/add_in_gitlab_ci_yml
+cc371399b fix(misnamed from): adding in golang
+de37d4e61 Merge pull request #4 from coreos-inc/add_in_gitlab_ci_yml
+4da6e660a chore(.gitlab-ci.yml): Adding in basics for ci
+00841adca Merge pull request #3 from coreos-inc/add_in_gitignore
+ae078dd68 chore(.gitignore): Added in a basic gitignore
+08a044242 Merge pull request #1 from coreos-inc/mocks
+b3aff3451 Add ALM mocks
+6bf9e3252 Check in the original propsal README as a straw man.
+f58bb3302 reset staging/operator-lifecycle-manager
+7c7ae56ea staging/olm: Re-generate test fake package(s)
+3cd949ad9 Merge pull request #36 from ankitathomas/operator-registry-sync
+827a137b5 correct top level files and vendoring
+669c5c606 Merge pull request #35 from benluddy/fix-cpb-target-os-arch
+8aeb37773 Merge pull request #608 from ecordell/rm-appr
+660b2c3ac Merge pull request #611 from estroz/feature/opm-registry-add-ca-file
+559e2dd91 Merge pull request #614 from timflannagan/add-symlink-release-dockerfile
+a9961fb4f Dockerfile: Add a symbolically linked release Dockerfile
+483c7bb49 Merge pull request #613 from timflannagan/disable-bundle-unpack-tests
+ae526bbde test/e2e: Disable the bundle unpack opm e2e tests
+3f6dc6c77 opm registry add: add --ca-file to add a PEM to the cert pool used by the command
+1d65a0f48 Merge pull request #596 from timflannagan/add-vendor-check
+923eb37dc .github,Makefile: Add linting check against Golang packages
+39e25f967 *.go: Commit changes after running 'make lint' locally
+ee24b336a Merge pull request #607 from joelanford/go-1.16
+357ec4b69 remove appregistry-related tooling
+6307e6e44 Merge pull request #598 from timflannagan/fix-test-log
+6398cb3a0 bump to Go 1.16
+673a1f8c6 Merge pull request #606 from openshift-bot/art-consistency-openshift-4.8-operator-registry
+67a052d30 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/e3b61ff1dde2bfc2bc7f2b5efdd155d1d3299cd7/images/operator-registry.yml
+5448405d8 Merge pull request #604 from joelanford/go-1-15
+f4de6eaed Remove package msodbcsql17 during e2e tests
+ff1059e92 Bump all Go binary builds to 1.15
+36a5f36f6 Merge pull request #587 from cdjohnson/patch-1
+3140e034a Merge branch 'master' into patch-1
+ff518a977 test/e2e: Capture stderr output when checking for docker and podman
+8dae74b2f Merge pull request #594 from timflannagan/update-readme
+631d37538 test/e2e: Fix output log message when Podman is not found
+b88086999 Merge pull request #590 from timflannagan/update-vendoring
+8c3495efb Merge pull request #591 from timflannagan/deflate-populate-helper-function
+735241176 Merge pull request #593 from timflannagan/update-owners
+10853edb9 README: Address markdown violations
+73bf73d5d OWNERS: Update the owner file
+1bc5b8cee cmd,pkg: Deflate unnecessary conditionals
+2ab0e1b22 go.*,vendor: Update vendorered dependencies
+54ff6e026 Makefile: Add the tidy and verify subcommands to the vendor target
+42f681381 Merge pull request #588 from timflannagan/fix-ci
+e7485d115 Merge branch 'master' into patch-1
+8fb17ef5f test/e2e: Revert disable Podman-related e2e tests
+3318a59c7 .github: Fix Podman installation steps
+9bae995c8 Merge pull request #418 from njhale/unpack-cmd
+2dda35f38 Merge pull request #565 from camilamacedo86/go
+65cf65dc9 test(e2e): add bundle unpack test cases
+e2651a62d chore(lib): reduce log noise from image registry test facet
+c1b89418a refactor(opm): export root cmd
+08e7e4b6c style(logs): reduce info log noise
+5d8cf07ba feat(opm): add alpha bundle unpack command
+044c5b39c Merge pull request #557 from operator-framework/start-server-readme
+028edac2d Merge pull request #564 from camilamacedo86/readme
+cfe3d519e Deprecate initializer and registry-server
+2898223a3 Merge pull request #585 from exdx/fix/apt-get-upgrade
+c347a339f fix: add apt-get-upgrade to ci script, skip podman-based tests until fix is identified
+c29c64eb9 doc: clarifies opm usage and what tool can help with bundles
+cad166898 Merge pull request #570 from rphillips/fixes/closes
+88d9086f0 Merge pull request #576 from openshift-bot/art-consistency-openshift-4.8-operator-registry
+909c9587f Merge pull request #546 from timflannagan/minor-doc-fixes
+20f3cecf1 Merge pull request #580 from bparees/typo
+68a1f2286 Fix typo in deprecate+truncate command help
+16df98322 Merge pull request #579 from timflannagan/fix-e2e-tests
+7c25ac277 .github: Use the pre-installed Podman dependency
+43ec5dbe2 docs/design: Remove all references to the bundle alpha opm commands
+e22c9b4cb docs/design: Minor documentation fixes
+89009c166 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/a74468426e8d0524b2fca64bbbcda77afef25b80/images/operator-registry.yml
+a99d4dd69 Merge pull request #558 from ecordell/fix-upstream-example
+59d29faef Merge pull request #559 from bentito/opm_doc_add_v1.15.3_idx_add
+42bdf021f Merge pull request #571 from njhale/feat/no-sort
+6cd5cf762 fix(index): add build id ordering to channel head selection
+472eceda0 test(e2e): make index add regression test pluggable
+549f2f540 (e2e) regression check with existing catalogs
+75743c103 add missing closes
+68da77d74 Merge pull request #572 from exdx/fix/test-minikube-driver
+f21d1d8c0 fix: use none driver without sudo in upstream minikube e2e tests
+7b1ba928b Various from PR comments
+60dca8c0e Merge pull request #552 from exdx/feat/e2e-registry
+70f687c62 feat: use secure local registry for e2e tests
+86eb95ad7 upgrade to use go 1.15
+a6bd08670 Merge pull request #556 from ecordell/fix-prune
+909c33e06 Fix upstream example dockerfile
+a9d60bb7b Add details for starting a local server to README
+4ad4383b9 remove stranded bundles when packages are pruned
+29f0e43a3 ensure foreign keys are always enabled
+94eb6b533 Merge pull request #548 from exdx/fix/kind-ci
+34f20180b fix: load required docker images for kind cluster in ci e2e test
+3c9314a2f Merge pull request #541 from multi-arch/master
+4a98d6e87 Updating Dockerfile baseimages to match ocp-build-data config
+eb972be40 Fix windows build with golang 1.15
+693a3c359 Merge pull request #537 from awgreene/bump-k8s-1.20
+807704d66 Bump k8s to 1.20
+bb3f14444 Merge pull request #536 from exdx/feat/github-actions
+bbc22b808 feat: move upstream tests from travisCI
+6ce54b83f Merge pull request #531 from benluddy/downstream-image-size
+732c7eac8 Avoid duplicate registry binaries across downstream image layers.
+8c2030987 Merge pull request #530 from benluddy/disable-broken-builds
+3817ecce7 Disable broken ppc64le and s390x release builds.
+c3613a00b Merge pull request #528 from njhale/fix-default-chan
+977e7cbe0 Merge pull request #527 from benluddy/bundle-image-in-related-images
+e78e3c468 fix(index): account for default channel in index add order
+b08b7dfcf Include the bundle image itself as a related image.
+d967a502f Merge pull request #495 from exdx/feat/custom-validation-categories
+df5d89927 feat: bump api dep to v0.3.22; add support for operatorhub and bundle object validation
+86cdd0293 Merge pull request #523 from njhale/fix-permissive
+8177b464a fix(indexing): respect strict mode
+ec3ce9568 Merge pull request #509 from ankitathomas/dockerfile-version
+5af74c792 Merge pull request #503 from njhale/fix-bulk-add
+d44e03791 Merge pull request #480 from dongwenjuan/master
+6b0737fdf Merge pull request #432 from Jamstah/AddConsoleYamlSamples
+59c5eaadd Merge pull request #516 from openshift-bot/art-consistency-openshift-4.7-operator-registry
+82b84c156 fix(indexing): pick channel heads by semver
+2abd6fb2a fix(indexing): order bulk add by version field
+033f76244 Merge pull request #512 from benluddy/listbundles-multiple-incoming-edges
+721acf93b Merge pull request #505 from ankitathomas/skippatch-fix
+2bd47a1b6 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/f82a216a6a3707b80a635bace9367f1a8288b7a7/images/operator-registry.yml
+83e1d90c3 Merge pull request #515 from awgreene/bump-k8s
+400ecd04a Bump k8s dependencies to v0.19.3
+cfd127a18 copy .git directory for build tag info
+dc554f210 add skippatch unit test
+3123bca81 Reconstruct replaces and skips for ListBundles from channel_entry.
+012815148 Merge pull request #508 from benluddy/fix-go-114
+abe2f1304 Fix Go version used by release job to 1.14.z.
+d9e282012 Merge pull request #506 from gallettilance/db-lock-fix
+ba0c22659 (fix) close connection to db
+57c0a0443 Merge pull request #501 from benluddy/upstream-release-go-114
+1bde7883c Build upstream releases with Go 1.14 instead of 1.15.
+dc4dfeaf6 Merge pull request #500 from benluddy/release-ppc64le-s390x
+0f6d85bd1 Produce opm linux release binaries for ppc64le and s390x.
+c562082e6 Merge pull request #496 from benluddy/release-workflow
+092245646 Add Github Actions release workflow.
+fadb6197c Merge pull request #494 from benluddy/server-test-populate-fixtures-before-start
+d6515e28f Merge pull request #493 from benluddy/cruft-file
+2a6b56289 Merge pull request #490 from benluddy/coverage-report
+d1514e4a7 Merge pull request #483 from benluddy/listbundles-channel-entry-replacement
+dfcd0af2c Completely populate test database before executing tests.
+66f559cfd Remove unused file.
+480a3673f Set replaces in ListBundles query result using channel entries.
+8ba0620c9 Merge pull request #491 from benluddy/grpc-server-flakes
+2de9582a8 Start listening on test server port before running tests.
+92e7566d0 Add coverage report job.
+dc637b882 Merge pull request #486 from ankitathomas/skippatch-fix
+7835fff66 Merge pull request #485 from njhale/alias-p
+d9980c427 check prerelease version for semver-skippatch mode
+a4966be2b fix(opm): properly deprecate export flag '-o'
+c4e99ebd3 Merge pull request #481 from benluddy/generated-dockerfile-windows-paths
+605a4d8a1 Fix path separator in generated bundle Dockerfiles on Windows.
+0f63cc756 fix the description of validation "RegistryV1" format
+70ff6f43a Merge pull request #475 from benluddy/configmap-image-workdir
+86daa8928 Merge pull request #477 from benluddy/flaky-aggregate-error-test
+7e7d38f45 Fix test flake based on random aggregate error order.
+74cf2adee Add writable workdir to configmap registry image.
+b3dc8e709 Merge pull request #474 from benluddy/scratch-nsswitch
+b29563395 Make the inability to create /etc/nsswitch.conf non-fatal.
+8f8bb658d Merge pull request #464 from gallettilance/fix-race-condition
+29794a47d Merge pull request #461 from ecordell/clean-tmp
+bff991361 Merge pull request #290 from jianzhangbjz/help
+99df95427 Merge pull request #425 from kramvan1/patch-1
+b6a3567a3 Merge pull request #454 from dongwenjuan/master
+0653a7f3b Merge pull request #469 from estroz/chore/sdk-owners
+ceca05190 OWNERS: add operator-sdk reviewers estroz, joelanford, jmrodri
+ca959c234 Merge pull request #465 from dinhxuanvu/semver-default
+83cef31f1 Enable default channel inference for the first bundle of the package
+a3be6469e Merge pull request #466 from operator-framework/ecordell-patch-1
+ca1ec0333 Update upstream-builder.Dockerfile
+8b94dcd8c set group permissions on /tmp
+467ceb9d2 (fix) concurrent writes during image pulls
+c03b8bca5 fix(dockerfile): clean out tmp directory after binaries are placed
+e0ec3a665 Merge pull request #459 from dinhxuanvu/defaulchan-val
+79492e087 Bundle validation will not fail if default channel is not provided
+0e583eecd Merge pull request #458 from gallettilance/fix-inference
+1f48ea073 (fix) bundle inference should not use skiprange
+9f533519b Merge pull request #451 from dinhxuanvu/default-chan
+2048435cd Merge pull request #455 from gallettilance/fix-add
+92d1a2318 (fix) erroring when replacement not found
+d4ab2fad5 Update index add func to handle optional default channel
+7824b0b6f fix the comments of LabelDependency in the type definition
+5a9d631aa Merge pull request #448 from gallettilance/force-bundle
+cd852bfc5 (fix) index add --overwrite-latest
+62416afbc The default channel info/annotation is optional & not required
+f5ab349f6 Merge pull request #416 from shawn-hurley/add-empty-list
+bf8ea5c89 Merge pull request #446 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config
+62ced6cf6 update the help info of the export subcommand
+a038b83f9 Merge pull request #429 from harishsurf/parallelize-export
+076241e92 Updating Dockerfile baseimages to mach ocp-build-data config
+80e61b0a3 Merge pull request #439 from benluddy/upstream-image-multistage
+0714d171e Merge pull request #443 from ecordell/readd-cross
+809107b8e add cross build back
+4a27170c2 Merge pull request #442 from ecordell/tmp-rm-cross
+f281238bf disable cross compilation while build issues are resolved
+e13b6ac80 Use vanilla Alpine instead of Alpine+go for the registry image base.
+1277aee10 Use multi-stage build for registry image.
+e0ca6f74a Parallelize opm index export
+22aa19a48 Merge pull request #437 from ecordell/fix-workdir
+b31b0463d fix(build): copy bins to a tmp directory first
+66f2ab5d1 add workdir permissions back
+2931c1faf Merge pull request #435 from ecordell/fix-bin
+c479f22a2 fix(bin): don't overwrite /bin
+12b741255 Merge pull request #430 from ecordell/macwin
+6209da7d3 Add ConsoleYamlSamples to the supported resources
+51732abac add mac and windows binaries to the amd64 build
+36d4ae3da Merge pull request #421 from gallettilance/add-deprecated
+82102ef36 [typo] fixing typo in deprecatetruncate command
+2e0d0d22f Merge pull request #427 from operator-framework/add-haseeb-to-OWNERS
+5661e2a12 Update OWNERS
+4f2b54039 Update OWNERS
+4e6392f70 Merge pull request #426 from openshift-bot/updating-dockerfile-baseimages-to-mach-ocp-build-data-config
+ca574edfb Updating Dockerfile baseimages to mach ocp-build-data config
+091b76d56 Add USER for non-root image usage
+02dfed2d4 Merge pull request #402 from ankitathomas/skiptls
+31be09d14 Merge pull request #422 from bandrade/fix-doc-semver-range-example
+caf034e45 fix: add dashes to semver range example
+c7e25eed1 Merge pull request #419 from akram/patch-2
+5a82f1569 set default for flag --skip-tls=false
+37efbea43 Merge pull request #420 from benluddy/undocument-label
+67331c5ea Merge pull request #417 from benluddy/listbundles-zero-dependencies-properties
+ea30dcd9f Remove label dependency from bundle docs.
+4e892fc41 Fix typos
+44c6435a0 Return empty properties and dependencies in ListBundles responses.
+a928124bb Add test to verify empty bundles in addition does not break
+4475a62bd extend skipTLS option to podman
+d06c41526 skip TLS option for pulling indexes
+ce66a306d Merge pull request #413 from kevinrizza/cleanup-command
+4927fe1bb Bug Clean up stranded bundles
+23af6a15d Merge pull request #411 from operator-framework/kevinrizza-patch-2
+437b9c82c Merge pull request #404 from ecordell/graceful
+c3f74412b [docs] Update out of date compile step
+eb88036c5 Merge pull request #410 from ecordell/listbundles-broken
+b5c513244 fix(query): return bundles in all channels
+7b935c8d7 Merge pull request #370 from Jobava/timeout
+17e7b5c5b Merge pull request #406 from dinhxuanvu/add-label-type
+2233f313c Update label property extraction from CSV
+6f22b37f5 feat(registry): Add label dependency constraint and property
+1c65e3611 Merge pull request #397 from gallettilance/deprecate-bundles
+d99911274 Merge pull request #408 from dinhxuanvu/remove-defaultchan-validation
+cf9c51d93 fix(validation): Remove default channel validation from bundle lib
+13acba6d9 Adding deprecated property type to bundles
+b654090f8 Merge pull request #405 from ecordell/fix-prop-listbundle
+fb75b6ca0 fix(query): list bundles would elide all but one property
+bf0be224d feat(registry): add graceful shutdown to grpc server
+4f4102b47 Merge pull request #399 from ecordell/static
+57ef54480 fix(e2e): pass build tags to e2e
+94bd0cf6b fix(dockerfile): remove unneeded static dependencies
+8f78d681e Merge pull request #394 from multi-arch/master
+da8df3a9e Remove nonexistent group from Dockerfile
+829bf2e66 Merge pull request #393 from benluddy/version-from-tag
+4e87d20cf Embed version at link time based on git tags instead of a file.
+50e2ae30b Merge pull request #391 from benluddy/get-package-client
+3c65685ff Merge pull request #392 from operator-framework/kevinrizza-patch-1
+c2c0574a7 Update OPM_VERSION
+9e47bd0b3 Add GetPackage to the client interface.
+9fb26eb48 Merge pull request #384 from gallettilance/check-before-insert
+460123922 Updating based on feedback
+91224f615 Merge pull request #390 from njhale/fix-validate
+4021942ee Merge pull request #388 from Jamstah/s390x-env-fix
+1e196700c fixing up to return exit codes
+c8da54d39 fix(containerd): always [also] pull layers from linux/amd64
+3f8656b55 fix(validate): pull bundle images before unpacking
+2e3df21a4 Use go env to get architecture for building
+d83bc1d42 Remove sanity check from `make all`
+70ae404c3 Merge pull request #382 from ecordell/s390x
+fe2bcd80f fix(build): don't set -race when testing on s390x
+c4ebb4b61 Merge pull request #381 from ecordell/replace-skips-listbundles
+a7dfb043c feat(api): add skips/replaces to listbundles api
+03a5e3343 Adding sanity check and error message for inserting the same bundle
+e9bcdcc11 Updating: adding sanity checks before insert into index
+922bcf4a0 Merge pull request #380 from estroz/chore/add-annotations-json-tags
+1160ce889 pkg/lib/bundle/generate.go: add JSON tag to AnnotationMetadata
+6eb5e9dc0 Merge pull request #379 from Jamstah/patch-1
+d9e3aba11 Merge pull request #378 from operator-framework/arch
+4489dbbff Merge pull request #300 from ecordell/refactor-indexer
+f1bb81504 Merge pull request #361 from Jamstah/cp-dir
+c63c9d0ec Merge pull request #363 from ecordell/generic-props
+77f795e59 Bump GRPC version
+ba0313684 feat(release): add builds for s390x and ppc64le
+35a47a4d4 fix(opm): refactor indexer
+454b702b9 feat(deps): nest dependency values
+9d88ef4a7 Merge pull request #377 from njhale/vendor-grpc
+4d850e57e feat(store): store provided apis and package info as generic properties
+3fccb235d Merge pull request #375 from operator-framework/1.12.7-version-bump
+ee8997d1e Merge pull request #374 from kevinrizza/separate-rm
+a913943f8 Merge pull request #346 from exdx/feat/add-gardener-objects
+7f9fc5ef2 chore(modules): update vendored deps
+574eff086 fix(docker): build grpc probe outside of gopath
+b5860c7e8 Update OPM_VERSION
+9eb4fe709 Add sanity test for opm registry serve
+d2187785c Add timeout to opm serve
+d3651599b Separate build/pull tool for index rm
+15092bb8d Merge pull request #373 from kevinrizza/go-1.14
+5c9e80ef5 (fix) Update to go 1.14
+4eea45df5 Merge pull request #372 from operator-framework/1.12.6
+547be0859 Merge pull request #371 from ecordell/403fix
+4b4094843 Update OPM version to 1.12.6
+7ca5b1d28 chore(deps): bump containerd
+52c605e30 Merge pull request #270 from dinhxuanvu/bz-component
+9e79ddbba Merge pull request #119 from ecordell/fix-test-flake
+1b88b94da Merge pull request #360 from Jamstah/pull-template-broken-link
+990cd1095 Use /. as the directory root to copy from.
+ee21f88d0 Fix broken link to CONTRIBUTING.md
+9fbe617e6 Merge pull request #358 from estroz/bugfix/annotation-compare-validation
+99717e015 pkg/lib/bundle/generate.go: ValidateAnnotations does not compare number of annotations in existing vs expected so arbitrary annotations can be added to annotations.yaml
+3ba5b6ff8 Merge pull request #353 from ecordell/tmpdir
+c3bedd910 fix(copy): make tmpdir relative to current directory
+453c23114 Merge pull request #351 from njhale/fix-unpack
+566a79cd5 fix(images): use docker/podman create and cp for exec unpacking
+b3cb795e8 Merge pull request #350 from operator-framework/kevinrizza-update-owners
+15d753d8e Merge pull request #349 from estroz/bugfix/bump-api-version
+5a79c33ea Update OWNERS
+7b1c617c3 The api repo is now pinned to the latest commit which contains bugfix https://github.com/operator-framework/api/pull/39. This update also removes the bou.ke/monkey dependency that has a very restrictive license.
+6907c1b19 Merge pull request #210 from multi-arch/master
+cf50e86ba Merge pull request #347 from anik120/fix-opm-test
+e55ef70ab [e2e] Fix opm test
+1c609e7d1 feat: add pdb, vpa, and priorityclass object support to registry
+aac52ee04 Merge pull request #296 from camilamacedo86/add-info-bundle-files-gen
+23803afdb Merge pull request #319 from beautytiger/fix/nil_check_before_defer
+cf3061ca5 Merge pull request #333 from kpiwko/patch-1
+42a4d3f9b Merge pull request #335 from bandrade/fix_bundle_doc
+4986d43ad add info over where the bundle files are or will be written
+3dcc91a1f Merge pull request #341 from exdx/feat/add-release-doc
+82953e6e3 feat: add OPM_VERSION notes to release docs
+bb9cbaff0 Merge pull request #340 from ecordell/ro
+afdf9e442 fix(unpack): support unpacking readonly folders
+c3a9acaf0 Merge pull request #337 from benluddy/podman-index-docker-format
+cbcb220da Merge pull request #338 from kevinrizza/bug-1835884
+6896dbd8d Configure "podman build" to produce images with Docker manifests.
+de8db4d45 opm bundle extract shouldn't validate annotations
+efe955d6a Merge pull request #332 from ecordell/opm-server
+d9bc32851 Merge pull request #334 from dinhxuanvu/fix-unstructured
+3790d9de4 fix(server): make a copy of the db before migrating it
+a2e8354a5 docs: remove typo from dependencies example
+bb3445833 fix(validation): Fix CRD v1beta int-float conversion error
+d2a3a95c5 chore: fixed a typo in bundle manifest format
+3582f1cd2 Merge pull request #320 from joelanford/dynamic-upstream-olm-builder
+a71b8afe4 upstream-opm-builder.Dockerfile: don't install bash; sh is sufficient
+c48e67749 Merge pull request #321 from exdx/fix/update-opm-buildflags
+110a4dedc Merge pull request #324 from Bowenislandsong/bug/understandsingBundles1827723
+2752dba53 Adding error message for more than one CSV in bundle dir
+efb4d5323 feat: add build flags to opm to show version information
+225ad1155 Merge pull request #306 from djzager/version
+80878b5b9 Merge pull request #318 from Bowenislandsong/bug/understandsingBundles1827723
+a2f721b94 Make default channel optional
+a9b107b2a Make default channel optional
+e73a50a28 Merge pull request #316 from ecordell/containerd-authorizer
+a82af2d0e Merge pull request #295 from exdx/feat/support-v1-crds-in-index
+5d15c662a fix: add err check before defer
+f14e6d543 Move bundle validator back to registry under validation package
+44ca66553 fix: use runtime.Object instead of interface for CRD return type
+b7b281be7 Merge pull request #314 from kevinrizza/index-generate-dameonless
+7b08c9e45 fix(auth): use fixed containerd authorizer
+57c46da8e Split build and push command runners
+46d9cbfba (bug) Always overwrite local db when copying
+ec16c49cb upstream-opm-builder.Dockerfile: add bash and ca-certificates to runtime index image
+18f74c7c1 Merge pull request #312 from benluddy/deps-not-found-optional
+8852286a2 Clarify log message to indicate that dependencies.yaml is optional.
+e3a7f4e9e feat: add test for v1 CRDs in registry bundle
+16a388a86 feat: Enable v1 CRD validation in bundle library
+c6c8d8123 feat: support loading v1 CRDs into index from a bundle
+41d933e9f feat(opm): add version command
+1616423d2 Merge pull request #289 from dinhxuanvu/fix-dep-types
+d13cc864d fix(types): Fix GetDependencies func that returns duplicate items
+9b7365d85 Merge pull request #243 from djzager/filtercmd
+a6f3b3344 Merge pull request #299 from kevinrizza/bug-1820438
+7998e2115 (fix) Use opm builder image for opm indexes
+b0b2270c4 Merge pull request #298 from kevinrizza/bug-1820438
+378699c46 Bug 1820438: Slim down upstream builder
+e3d6a223b feature: opm (index|registry) prune command
+f028701f9 Merge pull request #283 from ecordell/index-separate-dirs
+d0615a8b2 Merge pull request #277 from dinhxuanvu/opm-dep
+65fed64c2 Address the metadata read files loop to work regardless files order
+8355a08d3 Add unit test cases
+63e952637 Add Validate() for each dependency type
+8aa3d3a63 Add dependencies validation
+8572f569e Add dependencies.yaml validation to opm
+e00cf4182 Merge pull request #285 from kevinrizza/bundle-add-commutativity
+61b200175 feat(opm): add unprivileged index extract
+181ea3a2c (feat): Bundle commutativity
+2662ffbf8 fix(indexcmd): use a separate directory for unpacking a previous index
+b7641c508 Merge pull request #284 from benluddy/fix-podman-panic
+b701022ba Fix panic in AddToRegistry when using podman.
+df99b2ccf Merge pull request #281 from ecordell/fix-docker-add
+c17db7979 fix(index-add): docker index add failing
+95585c745 Merge pull request #280 from dinhxuanvu/dep-registry-comb
+bcef6fddd Add ListBundles to the client interface.
+191a85e47 fix(query): ListBundles returns all bundles even without dependencies
+7f19d5f13 fix(registry) Update the addDependencies to add requiredAPIs
+55fa9c787 Merge pull request #279 from ecordell/demonless-index-cmds
+8541af595 fix(add): allow containertool to be specified for registry add
+4807c9a1d Merge pull request #244 from djzager/indexadd
+ed32d7a12 Merge pull request #254 from dinhxuanvu/dep-yaml
+e501f66c8 Address feedbacks (second round)
+aa3432879 bug(opm): use db dir when modifying existing index
+30bc8aa25 Add BugZilla component to OWNERS file
+95fede4af Address feedbacks and fix test cases
+09d650c2a Merge pull request #265 from ecordell/fix-channel-heads
+eb11ce644 fix(load): shouldn't clear bundle/csv field from non-default heads
+06e7733f5 Codegen for registry API changes
+0024d5cfb Merge pull request #262 from njhale/docker-login
+00af1da53 Add bundle dependencies specification documentation
+41f1c55e8 feat(registry): Add operator version dependency metadata
+9b65effe4 test(e2e): login w/ docker first to prevent failures
+b82634749 Merge pull request #256 from exdx/feat/add-bundle-objects
+a4467d99c Merge pull request #251 from djzager/registryrm
+1d855e13b Merge pull request #260 from ecordell/fix-imgload
+e3a98c3d3 fix(imageloader): image loader should consider existing channels when adding to an index
+f01d6ddcd Merge pull request #247 from kevinrizza/semver-mode
+8db3160ee (feat) Add semver insert mode
+1f9153736 feat: add support for configmap and secret objects when generating a bundle
+27d4e6e44 Merge pull request #246 from ecordell/k18
+c65e46b34 chore(deps): bump to kube 1.18
+371e1406b Merge pull request #253 from operator-framework/add-conntrack
+8674af077 chore(travis): add conntrack package
+56f5b0e4c bug(opm): packages flag on registry rm required
+36b92b67f Merge pull request #248 from njhale/fix-panic
+55fe6819d fix(populator): set bundle name
+a1573df44 fix(populator): put correct argument in decode call
+1e32c8581 Merge pull request #213 from njhale/daemonless
+393f32379 refactor(populator): ensure file descriptors are closed
+9b456bc5c chore(modules): update vendor directory
+f048fc0e6 refactor(image): add image reference interface
+5d26cce45 feat(deamonless): add buildah-based deamonless image puller
+9e88099f3 docs(opm): add self-contained container-tools section
+1af9bf96f feat(opm): add unprivileged registry add
+19a8c1890 Merge pull request #242 from dongwenjuan/master
+9762ed555 Merge pull request #236 from ecordell/fix-add-err
+d838b9a47 Merge pull request #241 from Bowenislandsong/understand-packages
+177fef741 [feature] Understanding packages from directory
+16f389279 test(migrations): add tests for api provider and requires migrations
+5b102d2a6 fix(load): add synthetic nodes in every channel that a replacement is in
+a48b4c6fe feat(bundle): extract replaces/skips data on load
+8ac8863ca fix the `validate` command in the docs
+37eb42d99 Merge pull request #227 from ecordell/nsswitch
+5902db2c5 Merge pull request #237 from estroz/bugfix/manifest-copy
+9e5cd742f refactor(db): remove denormalization that associated provided and required apis with channel entries, rather than bundles.
+04a8234ec Merge pull request #234 from Bowenislandsong/fixtests
+768692da1 [travis] pinning minikube version
+3e2816947 Merge pull request #239 from operator-framework/revert-229-understand-packages
+4f35231af Revert "[feature] Understanding packages from directory"
+29df24750 [dockerfile] removing dev directory permission change
+3be8cbf3f pkg/lib/bundle: fix copyManifestDir so it actually copies file contents
+fff4eefbc Merge pull request #229 from Bowenislandsong/understand-packages
+44ee96d39 [feature] Understanding packages from directory
+cc093ebfe fix(dns): fix slow dns resolution of localhost for grpc health probe
+ad7470387 Merge pull request #224 from kevinrizza/graph-loader
+b712cbbc0 Update graphFromEntries to be a private function
+3542b5484 use query interface in sql graph loader
+843ec70a0 address pr feedback
+3dc50c479 Update graph format for runtime concerns
+4ed3d3db7 Graph Loader initial implementation
+81a48979f Merge pull request #196 from operator-framework/opm-test
+5bb2104be Add opm E2E test.
+994ab606f Merge pull request #212 from anik120/bump-k8s-version
+66f6f5efb chore(deps): Bump to kube 1.17
+262153399 Update grpc-health-probe version
+44dacd0bf Merge pull request #209 from kevinrizza/opm-bundle-generate-dir-structure
+5b73e0c91 Generalize manifest copy
+b583b6fcb Merge pull request #193 from ecordell/adrian555-master
+b57e48c37 Merge pull request #164 from dinhxuanvu/update-owners
+e737486be Merge pull request #206 from kevinrizza/opm-bundle-generate-dir-structure
+db0661a28 Match bundle image directory structure
+7a06d84c3 update go.mod to remove unneeded license dependency
+72c38400c Merge pull request #198 from Bowenislandsong/resolvingCycDependency
+ac4ee7eaa Removing olm dependency
+dd02edcfb Merge pull request #197 from njhale/fix-dockerfile-gen
+f3796dfb0 fix(index): gen index dockerfiles from opm image
+d1f8f4958 Merge pull request #194 from Bowenislandsong/stalebot
+3af90d238 Merge pull request #195 from njhale/fix-meta-prune
+538352136 test(meta-pruning): ensure pathless nodes keep data
+2683308c8 Add stale bot
+1f1a704a0 Merge pull request #189 from benluddy/sorry-amd64
+25a9e5332 Produce binaries without target platform prefixes by default.
+87718aab2 Merge pull request #186 from ecordell/rm-rf-helm
+d097f9a4d chore(deps): remove helm as a dependency
+702ab31fe Merge pull request #183 from ecordell/opreg-entrypoint
+38e875be6 fix(docker): add entrypoint
+f6df4f430 Merge pull request #173 from njhale/fix-opm-cp
+2aa7ca414 Merge pull request #172 from dinhxuanvu/bundle-docs-update
+640075070 Merge pull request #167 from benluddy/delete-sqlite-junk
+1746ac0aa fix(index): copy correct opm bin builder path
+0463ddcad Update operator-bundle to clarify the bundle format directories
+6f049490b Merge pull request #148 from ecordell/failfast-builder
+4a8424920 feat(appr): exit build early if no manifests were downloaded
+f6db5f3ed Delete junk SQLite journal files.
+8702bface Merge pull request #166 from dinhxuanvu/validate-bundle-test-2
+6f1ce0f43 Add validate bundle test cases
+15d92f2d5 Merge pull request #161 from benluddy/remove-sqlite-dep-from-configmap
+2669b49c6 Update operator-registry OWNERS file
+11c61f83f Merge pull request #163 from gallettilance/export-bug-fix
+ca1603789 Fixing wrong database loaded in memory for export cmd
+414d8b637 Merge pull request #162 from operator-framework/revert-160-static-ci
+5998143c4 Revert "fix(ci): build opm statically in CI"
+594ba2e20 Merge pull request #154 from gallettilance/index-to-appreg
+5c08cdb24 Remove dependency on sqlite from pkg/configmap.
+8d4cc3b79 Adding ability to export package from index
+c97191ab1 Merge pull request #160 from ecordell/static-ci
+ea6a48f80 fix(ci): build opm statically in CI
+c9e2f548e Merge pull request #149 from kevinrizza/opm-docs
+185b4a8c7 Merge pull request #153 from simrandhaliw/patch-1
+9622e938b Merge pull request #141 from gbenhaim/add_support_for_choosing_a_version
+9fe0a1ace Merge pull request #158 from operator-framework/mkrelease
+5fa39be6c chore(release): use robot for deploys
+d760749f3 Bug 1784028: Updating summary for 'Operator Registry ' containers
+759dd0b18 Merge pull request #156 from dinhxuanvu/fix/docker-error-output
+fe3c7d07d Fix issue with empty docker error output
+bae1e9ad6 Merge pull request #155 from ecordell/bins
+fd4ded680 chore(release): add a travis.yml to build and release opm
+c7fc4dc57 Merge pull request #146 from exdx/feat/validate-bundle-files
+07496ed07 Address feedbacks from comments/reviews
+4444617ad Update README.md
+80f7dd11d Add support for choosing the package's release
+c1f18051e Update docs to reflect index/bundle image changes
+bb10148e4 Refactor bundle validation code to seperate format and contend validation
+618c93e38 Add validate bundle contents
+56d0ebd99 Merge pull request #139 from gbenhaim/make_downloader_testable
+27c2ca979 Merge pull request #147 from ecordell/fix-build
+43cb58a95 fix(build): grpc-health-probe was not building properly in 1.13
+2c6a866f3 Make downloader.go testable
+163605a1d Merge pull request #145 from njhale/load-csv-name
+5d8d1f968 fix(bundle): set csv name field on configmap loading
+117fde9d0 Merge pull request #143 from kevinrizza/bundle-validate
+24edbb8e4 Vendor helm library to enable helm chart validation
+c746b8219 Fix a few minor issues
+2654fe103 Update bundle validation lib for sdk consumption
+5de9853d7 add tests
+f6b5f0797 Add bundle image validation feature to bundle library and bundle cli
+b93aee167 Merge pull request #63 from tmckayus/replacecircuit
+d68a99b4b Merge pull request #135 from vincent-pli/tiny-typo
+3c68d0ca6 Merge pull request #137 from jpeeler/switch-bundle
+713a21faa Merge pull request #144 from jpeeler/add-cp
+6c5d3d004 add cp to configmap-registry image
+fd50b98ac Merge pull request #142 from operator-framework/opm-to-configmap
+19d0971af Add opm to configmap-registry image
+d62d52a4c Merge pull request #140 from njhale/index-docs
+1f109438f chore(modules): update vendor
+6ea1b04cd refactor(opm): add examples to index add subcommand
+7223d41d6 fix(configmap): remove packagemanifest parsing
+e92c3c15a chore(makefile): add selective unit test execution
+0657f62c1 Fix tiny typo
+09d7e1c1b Merge pull request #130 from njhale/fix-ignored-cachedir
+e8805a66b chore(mocks): use new counterfeiter directives
+23777e0a3 fix(appr): use given cache dir for image builds
+9ebe14ad0 Merge pull request #129 from anik120/bug-rearrange-dir
+4389019fa Bug 1774630: relocate test data
+d0cde7e52 Merge pull request #128 from anik120/bug-fix-incorrect-bundledata-panic
+92bc45361 Bug 1774630: Fix panic caused by incorrect bundle data
+4998a0e7f Merge pull request #125 from anik120/opm-bundle-extract-bug
+7b3da5830 Bug 1771850: Error logging for opm alpha bundle extract command
+97a63dc5e vendor in github.com/pkg/errors
+abc8771ee Merge pull request #127 from dinhxuanvu/bundle-build-fix-2
+a60ea60c9 Detect replacement cycles while adding package channels
+feefcd953 Clarify the directory requirement in docs and help menu
+96a395048 Ensure provided directory has at least one yaml manifest file
+0233cfc8f Merge pull request #124 from dinhxuanvu/bundle-build-fix
+4133a9d0a Merge pull request #126 from jpeeler/update-ginkgo-test
+ae6601658 Add directory check to ensure the directory exists
+215d838e2 fix(e2e): update ginkgo configmap test
+eb9a1ebe4 Fix bundle build command with Docker and update documentation
+d78058642 Merge pull request #122 from gallettilance/bundle-table-insert
+d9a6dc84d [bug] - add version and skiprange to operatorbundle table
+47f48e5c7 Merge pull request #121 from kevinrizza/fix-docker-image-unpack
+80164bf87 Make imagereader work for all layer paths
+a37bc867c Merge pull request #118 from ecordell/fix-upstream-configmap
+3bedcfebe test(server): wait for connection to go healthy before running tests
+6221359f7 fix(configmap): bump base image for configmap registry image
+abb24c012 Merge pull request #106 from kevinrizza/index-command
+12b62c11f Add `opm index` commands
+2fb07b855 Merge pull request #113 from ecordell/rest-of-it
+214fca47e fix(mirror): canonicalize names before swapping domain
+c0a1e66c7 feat(api): return version and skiprange in bundle
+380d944c4 Merge pull request #89 from gallettilance/operator-registry-cli
+5e4ed7104 Merge pull request #115 from ecordell/fix-to-option
+669be0cd3 [opm] - Add registry add and rm bundle commands
+596134f3c fix(builder): Add AppRegistry org to `ToOption`
+cbda71412 Merge pull request #114 from jpeeler/fix-launch-bundle-image
+4a41a4273 fix(configmap): make launch bundle work
+c62af6239 Merge pull request #112 from ecordell/api-bundle-client
+f5bd7b31b feat(client): return api bundles in client
+cf19596a5 Merge pull request #111 from ecordell/required-apis
+1fff59226 feat(sql): extract required apis when loading
+143bee961 Merge pull request #110 from jpeeler/add-opm-binary-into-container
+4f5fca9f9 feat(imagebuild): add opm binary to registry image build
+1c48ed8f4 Merge pull request #109 from dinhxuanvu/bundle-order-fix
+4b97e6fe6 Merge pull request #105 from ecordell/opm-catalog
+498228060 Merge pull request #92 from tkashem/configmap-bundle
+4a7e3c320 Merge pull request #108 from dinhxuanvu/mac-gitignore
+f403531ee Merge pull request #107 from dinhxuanvu/fix-bundle-dockerfile
+1ecae6b15 Merge pull request #94 from jpeeler/expose-bundle-data
+801d2e396 test(mirror): add tests for mirroring
+1b6105ec6 feat(opm): add registry mirror command to mirror the contents of a catalog
+0d0f4201e fix(bundle): Fix the build paramater order mix-up
+bee08a723 fix(bundle): Fix manifest directory issue in generated Dockerfile
+12b622668 Update registry gitignore to be consistent with OLM
+9de195760 feat(opm): add registry build command to build a catalog from an appregistry namespace
+8c7c3f498 test(e2e): add bundle data image extraction test
+652e8a396 test(e2e): add initial test bootstrap
+92568f12b feat(cli): add bundle extractor binary
+98e9b709d feat(configmap): add configmap writer
+f5444e285 chore(client): move k8s clientset generation
+ed733cf96 chore(configmap): load packagemanifest data from annotations
+5c4a88e77 test(unit): add test case from generated configmap
+9519e7973 (feat) Load operator registry bundle from ConfigMap
+1e3a9a685 Merge pull request #97 from dinhxuanvu/bundle-lib
+b1aaf2526 Change const to upper case so it can be used
+e42de32db Merge pull request #103 from anik120/image-digests2
+c62fdb4bb Image digests for referencing bundles
+dbca245b1 Clean up minor issues with command-line code and documentation
+d84454578 Merge pull request #101 from ecordell/relatedimages
+1600fab9c feat(migrate): migrate from current version up to the latest
+f7f554b3e feat(images): add support for storing and querying related images
+9f0f125e7 feat(migrations): switch to go-based migrator
+93f2f687e Fix bundle library doc to reflect new changes/features
+2434e337b Fix bundle library unit tests to cover new code
+1c113bcb6 Fix bundle library to add package and channels info to annotations
+e061d9a36 Clean up library code, unit tests and documentation details
+4dc452ba0 Add CLI tool to build Operator Bundle image
+c649037aa Merge pull request #102 from operator-framework/update-owners
+7d088609b Update OWNERS
+47f4e56cf Merge pull request #77 from njhale/remove-schema
+325e8ee89 Merge pull request #96 from gallettilance/opm-cli
+bd347d3a6 Adding opm cli
+e679e0049 Merge pull request #90 from kevinrizza/db-migration-scaffold
+d64ca7d77 Bundle migrations in binary
+8f1e20a6d Database migration initialization
+4df186f63 Merge pull request #98 from ecordell/foreign-keys
+adfbcbe98 Merge pull request #86 from estroz/fix-crd-encoding
+50b725a67 fix(sqlite): enable foreign keys for sqlite
+dddf15793 Merge pull request #88 from kevinrizza/migrations-proposal
+01461dce2 Add migration proposal
+15f725527 Merge pull request #87 from ecordell/kube-1.16
+bacb60372 chore(deps): refactor load_test so that OLM is no longer imported at all
+3f9f3d83c chore(schema): remove schema
+5d8bf321e feat(csv): support extracting version from bundle's csv
+bc107ecac chore(deps): bump to kube 1.16
+85ae208e9 Create PULL_REQUEST_TEMPLATE.md
+28f99b0ac pkg/registry/bundle.go: use v1beta1.CustomResourceDefinition, as the apiextensions type is internal
+709cb007b Merge pull request #84 from njhale/fix-transactions
+6ca85bf52 fix(sqlite): defer rollbacks to prevent db lock
+4e83e7e01 Merge pull request #82 from ecordell/grpc-update
+3b6857c91 chore(deps): update grpc to latest
+f0509fa8f chore(schema): remove unused upgrade path code
+4633997c6 Merge pull request #75 from dinhxuanvu/error-fix
+f1e0e88c1 Merge pull request #74 from njhale/permissive
+851783377 fix(registry) Fix incorrect error return and handle
+284be6981 refactor(cmd): change command scope to make testing easier
+b9e346e81 feat(configmap-server): tolerate load errors
+a89b379b4 feat(registry-server): tolerate load errors
+2414acd71 feat(appregistry-server): add strict load option
+72e0be383 feat(configmap-server): add permissive load option
+4d40a2042 feat(initializer): add permissive load option
+ba3de1f89 feat(log): make termination-log setup failure non-fatal
+efb96a667 Merge pull request #72 from njhale/fix-best-effort
+a0e1c4248 test(load): add test of unpacked appregistry format
+6b11844a7 fix(sqlite): correct directory load error collection
+2788358a7 Merge pull request #69 from njhale/best-effort
+0547f57aa feat(appregistry-server): use empty querier on fatal load error
+3ba8eb920 feat(sqlite): make configmap loading best-effort
+b7830a9e7 feat(sqlite): make directory loading best-effort
+6ca59e3a4 feat(sqlite): make package loading best-effort
+e230b9411 Merge pull request #65 from ecordell/catalog-cmd
+dbafcc040 Merge pull request #65 from ecordell/catalog-cmd
+b0a4454d9 feat(appregistry): avoid panics in flattened processor
+82ee13e48 chore(git): keep testdata/download
+aeeca6db6 chore(deps): add glide.yaml for importing to oc
+c9c256967 feat(appregistry): have appregistry transform configmap bundles into directories
+fb38816aa chore(deps): remove dependency on marketplace
+f4d156a44 chore(deps): remove dependency on openapi and go-appr
+8cb5471f6 Merge pull request #61 from ecordell/fix-registry-dockerfile
+13a6a429b fix(dockerfile): missing image alias
+3a731e5ce Merge pull request #60 from ecordell/registry-dockerfile
+178706333 Merge pull request #59 from ecordell/remove-olm-and-json
+283f75108 add dockerfile that just contains the registry server
+4326318c1 refactor(load, query): don't rely on json extensions to sqlite, and don't rely on types imported from OLM
+da787d605 feat(load): allow multiple csvs in the same directory
+2676630d6 Merge pull request #56 from ecordell/dynlib
+ff2a93259 fix(build): don't build static in downstream images
+f73badbf8 Merge pull request #55 from ecordell/go-1.12
+1256393b1 chore(image): change base image to go 1.12
+b52e8d312 chore(dockerfile): switch to go 1.11
+9297dc4c9 Merge pull request #54 from ecordell/fix-channel-count
+a34303066 fix(query): return all channels when querying
+d622bca51 Merge pull request #52 from awgreene/fix-duplicate-package-bug
+e778e13fe [bug] Remove duplicate packages from list
+e005bc432 Merge pull request #48 from dinhxuanvu/validate-examples
+c71e1ba4a Merge pull request #51 from marcoderama/smallfixes
+207fb0de8 Documentation: Small typo fixes to README.md
+6380d8970 Remove pragma lines that reference the files that can’t be found
+9f43f541d fix(registry): Validate alm-examples in operator registry
+d3b9026e9 Merge pull request #49 from ecordell/healthcheck
+0f2a31d2a feat(client): add health check to high-level client interface
+a7b02d504 Merge pull request #46 from ecordell/default-channel
+e57914eb3 feat(load): validate that packages have a default channel when loading
+dcbbdf28e Merge pull request #45 from ecordell/permissive-files
+e7d87768d feat(loader): don't require file suffixes
+2552478be Merge pull request #43 from tkashem/bundle
+9685d18c6 Add unit test(s)
+33a7fd259 Support nested operator bundle format
+3420338ca Merge pull request #41 from ecordell/z-stream
+66f5d27ad feat(load): use a new "skips" field to specify additional operators that
+dedae1c2f Merge pull request #40 from tkashem/no-opsrc-dependency
+2320552a5 Remove OperatorSource dependency
+0739cde3f Merge pull request #39 from ecordell/update-cm-reg
+df9fbe258 update upstream configmap-registry image to use the builder image
+28784f8cf Merge pull request #34 from dmesser/readme-docs
+882430eb1 Merge pull request #38 from dmesser/build-fixes
+8457a4339 add instructions how to use grpc catalog
+8e058560d fix reference to Dockerfile
+eeb5b814b Merge pull request #35 from mhrivnak/typos
+67c9f7285 Merge pull request #36 from ecordell/upstream-builder
+a0ac5c83d feat(builder): add builder dockerfile (contains tools for building a registry image)
+f2088a8b3 fixes typos in README.md
+f2b220be7 Merge pull request #32 from ecordell/detect-bad-replaces
+e91301562 fix(load): return an error if a CSV specifies a replacement that doesn't exist
+55f857fe2 Merge pull request #29 from operator-framework/upstream-readme
+a41f89491 Update README.md
+342439fe1 Rename upstream.Dockerfile to upstream-example.Dockerfile
+e8fc5840e Update docker commands in example to use upstream
+b37da018a Merge pull request #28 from kevinrizza/auth-in-appregistry
+6905544c3 Add authentication to apprclient
+2a5bf4eda Merge pull request #27 from tkashem/remote-registry
+7dc5913be Incorporate new binary into docker images
+d3a852d1f Add appregistry-server binary
+91668083b Add apprclient package that talks to app registry
+ba5b82ace Refactor configMap loader to work with appregistry
+1ee61e256 Merge pull request #26 from jpeeler/remove-dep
+851dba318 fix(build): remove dep usage
+67841cfe8 chore(build): make vendor
+40396880c fix(build): update grpc-health-probe for module support
+6c51b6c05 Merge pull request #25 from jpeeler/static-build
+cefbc8e00 fix(build): make static build work
+88d15100f Merge pull request #24 from ecordell/root-downstream
+2bdc5a8e3 fix(dockerfile): user needs enough access to read from the filesystem
+353808d71 Merge pull request #23 from njhale/revendor-olm
+8b4b1703f chore(modules): update version of OLM module and revendor
+f30dd21db Merge pull request #21 from operator-framework/configmap-server-path
+f272de540 fix(dockerfile): move configmap-server into path
+59cf23fa1 Merge pull request #20 from njhale/get-bundle
+3c6870896 feat(bundles): add GetBundle request
+85923f676 Merge pull request #19 from njhale/fix-minimum
+880995e47 fix(bundle): fix CRD conversion with minimum validation field
+973e2f25f Merge pull request #18 from ecordell/update-olm-types
+e7d02c2b3 fix(dep): bump olm types so that registry can serve new CSVs
+2875581ae Merge pull request #17 from ecordell/expose-clients
+e82f243eb feat(client): expose underlying clients
+a121b5d37 fix(configmap-server): switch dockerfile to go 1.10
+45f0a61bf Merge pull request #16 from ecordell/fix-configmap-bundle-parsing
+3175ccbb1 fix(configmap-server): gvk parsed for owned CRDs incorrectly, so bundles were omitting CRDs
+3dd0bd6a8 Merge pull request #14 from njhale/group-and-plural
+c43c54102 refactor(schema): split groupOrName into group and plural fields
+43b9be2b7 Merge pull request #13 from njhale/container-codegen
+d898e2cd8 chore(codegen): run codegen
+14b04ed4d chore(tools): add golang/protobuf as a tool dep
+ca3334dea feat(codegen): add container-codegen make rule
+4c5211261 Merge pull request #12 from njhale/add-owners
+1a19641b8 chore(ci): add OWNERS file
+6f84a5529 Merge pull request #11 from njhale/okd-dockerfile
+5753cb475 refactor(Makefile): rename test rule to unit
+9af6a9ffe chore(Dockerfile): remove directory check
+f4b787383 fix(build): enable cgo
+e33c1c0a7 chore(go.sum): regenerate go.sum
+584c8197c feat(make): prevent test caching
+fc5eefe70 fix(test): add missing fields to expected bundle
+c226b2f21 fix(client): correct package used for healthcheck client
+42d57e1fd feat(image): add CI compatible Dockerfile
+156c40986 Merge pull request #10 from ecordell/move-health
+b05b41925 fix(health): move health to its own package with the right package name
+acb1e805a Merge pull request #9 from njhale/grpc-health-probe
+561ba55fd feat(health): add gRPC health probe tool to docker images
+f01b157c3 Merge pull request #8 from njhale/termination-log
+755bba780 refactor(logs): factor out default writer hook setup
+217e9fde5 feat(configmap-server): write panic and fatal log levels to a termination log - adds `termination-log` flag to `configmap-server` binary to specify termination log path - writes panic and fatal log levels to a termination log
+0e5829177 feat(registry-server): write panic and fatal log levels to a termination log
+b02598f48 feat(logs): add WriterHook type for splitting log levels between writers
+bd9135471 fix(go-mod): fix checksum issue with client-go go module
+4a95f4762 Merge pull request #7 from ecordell/fix-crd-parsing
+344e126b5 fix(bundle): fix CRD <plural>.<group> parsing
+eed1e3c20 Merge pull request #6 from ecordell/readme
+a22de90bd chore(docs): update readme with configmap-sever and pkg/client
+7a2481a19 feat(health): add healthcheck endpoint
+07842f742 feat(schema): add validators to directory loader
+4e431bcd2 feat(client): add grpc client interface
+f2e497cc8 feat(bundle): add package/channel name to bundle
+106a8d98d chore(deps): switch to go modules
+0e5cda08f Merge pull request #5 from ecordell/reflection
+c66a4d03a feat(grpc): enable reflection on grpc endpoints
+02055cf87 Merge pull request #4 from ecordell/grpc
+3f59e9f6d feat(configmap-server): add dockerfile which builds and runs configmap-server
+1a0cf5eb7 feat(configmap-server): add configmap-server binary
+59c175ed3 chore(deps): update dependencies for version-config
+e003bf393 feat(registry-server): add server binary that speaks grpc
+f3c8394a7 chore(deps): add proto dependencies
+948c18dfc feat(grpc): adds basic gRPC interface to querier
+527540792 Merge pull request #3 from ecordell/configmap
+2fe122016 feat(load/query): support provided APIs that are apiservices
+083292293 chore(deps): depend on latest OLM
+fe5fc0213 feat(configmap): add configmap loader
+256f3223e Merge pull request #2 from ecordell/basic-registry
+fbe246ab0 Merge pull request #1 from ecordell/basic-registry
+15b0a40f3 chore(deps): remove unneeded dependencies
+5aa6d970e chore(pkg): make more like a kube-style go package
+a52c3e1a6 feat(query): open db as immutable for querying
+87a57dc25 feat(query): add query interface and refactor tables
+8aafbd49f feat(load): add package and channel loading
+0bacbf2b0 refactor(store): add storage abstraction
+199af66f3 feat(loader): create basic loader that puts csvs and bundles into a sqllite db
+b4f844f65 Remove overrides for GOOS and GOARCH in cpb Makefile recipe.
+076370a4a reset staging/operator-registry
+b2c0188f2 Merge pull request #33 from timflannagan/fix-version
+eb653bcaa Makefile: Use the full git commit hash when building binaries
+fc8fceebf Merge pull request #32 from timflannagan/cleanup
+5674d1a72 base.Dockerfile: Bump the Go base image to use a 1.16 tag
+a1dd03100 Remove root OLM_VERSION file
+9dd58651d Merge pull request #31 from openshift-bot/art-consistency-openshift-4.8-operator-lifecycle-manager
+5cf062295 Merge pull request #30 from openshift-bot/art-consistency-openshift-4.8-operator-registry
+fe8af7ba1 Merge pull request #29 from timflannagan/build-opm-binary
+ae248a830 Dockerfile,Makefile: Add opm binary and cross compilation target(s)
+d1cbee907 Updating operator-lifecycle-manager builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-lifecycle-manager.yml
+0a0c4e3f2 Updating operator-registry builder & base images to be consistent with ART Reconciling with https://github.com/openshift/ocp-build-data/tree/b7ea3c7f495e67d5b790e3698b5c319b67e98b35/images/operator-registry.yml
+6cc52b3f7 Merge pull request #27 from ankitathomas/manifest-crd-gen
+637012048 remove top level deploy, crds directories
+efd971ec8 add crd and manifest generation
+30836f7ae Merge pull request #26 from timflannagan/updates
+416ae4117 Makefile,Dockerfile: Add additional registry and OLM build targets
+138cb4289 scripts: Address markdown violations in the README.md
+a137de7eb cmds.go,vendor: Introduce the non-opm registry binary packages
+1c46643a1 scripts: Check if the vendor directory needs to be populated first before running e2e packages
+9869d83fb scripts: Avoid hardcoding the test e2e function called
+4979ef16a Makefile: Update the e2e-related targets
+f3f041098 staging: Update OLM modules after recent changes
+3e7d2256f Merge pull request #25 from ankitathomas/release-4.8
+e15c0d7c5 go mod tidy and vendor
+c45c5ddd4 Sync upstream operator-lifecycle-manager release-4.8
+d4db74a7a Sync upstream operator-registry v1.13.6
+6c922ea8c Sync upstream api v0.7.0
+7687486a0 README.md
+0bbcb6c43 Use staged tests
+7b32e4e3d Update scripts to track specific commit
+f9bb28356 Merge pull request #21 from timflannagan/fix-unit-script
+c5b021539 scripts: Update the unit.sh helper script and populate the nested staging directory
+b3559db98 Merge pull request #20 from timflannagan/minor-updates
+6b9b9d6b8 Makefile: Introduce additional test targets
+0b2acc7a7 scripts: Introduce an e2e helper script
+a2b4d716f Dockerfile: Copy the entire repository while building binaries
+e057b1cba vendor: Re-sync vendor after adding debug statement to staging package
+f712e45d9 Merge pull request #19 from timflannagan/update-root-registry-tag
+ca2f7cdae Merge pull request #18 from timflannagan/single-go-mod
+2a481b8da Update the base image for the operator-registry image
+62a5ee560 WIP: Update root Dockerfile(s)/Makefile to build downstream images
+ad38f168b .gitignore: Ignore nested staging vendor directories
+90d992bde go.sum,vendor: Update vendor directory after adding package-server
+09e96f17d Add the package-server to the list of local command packages
+02af3f211 Makefile: Add build and basic test targets
+1e76453fa Introduce cmds package that tracks the staging operator-framework directories
+84711e296 go.sum,vendor: Update root vendorered dependencies
+feff05e7c Remove any mirrored cmd,pkg staging packages
+31e2e318c staging: Remove nested vendor directories
+10fdf0150 Merge pull request #12 from timflannagan/update-root-makefile
+aa3ed9f55 Makefile: Reduce the number of targets
+be45d688a scripts: Add unit test helper scripts
+8e343401b Dockerfile: Avoid hardcoding the kubebuilder version in multiple places
+671db25a8 Merge pull request #10 from timflannagan/minor-updates
+cef149683 Dockerfile: Avoid using the registry.svc.ci container registry
+918821840 Copy OLM_VERSION from staging/operator-lifecycle-manager to root
+55b5b469c Merge pull request #6 from timflannagan/bump-image-tags
+543265256 Merge pull request #9 from timflannagan/sync-vendor-prow
+13041aa9f staging/olm: Remove invalid trailing slash in the go-bindata dependency
+6ba5fb361 staging: Ensure staging modules are synced
+ee542782b Merge pull request #7 from timflannagan/add-minimal-gitignore
+e18eb1b0f Add root .gitignore
+1c679d74f *.Dockerfile: Manually bump the image tags to 4.8
+4694b1d65 Merge pull request #5 from timflannagan/ankitathomas/master
+3f9b44835 staging: Remove the OWNERS files from the OLM-related staging repositories
+a65e8778e Initial commit
+584696e84 Merge pull request #1 from timflannagan/patch-2
+8ce5a0f97 Create OWNERS
+1f6ab6366 Initial commit
diff --git a/go.sum b/go.sum
index b5edf65a15..344e105578 100644
--- a/go.sum
+++ b/go.sum
@@ -193,6 +193,7 @@ github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGX
 github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
 github.com/cockroachdb/cockroach-go v0.0.0-20181001143604-e0a95dfd547c/go.mod h1:XGLbWH/ujMcbPbhZq52Nv6UrCghb1yGn//133kEsvDk=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
@@ -319,6 +320,7 @@ github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5y
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ=
 github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
@@ -775,8 +777,9 @@ github.com/mattn/go-shellwords v1.0.11 h1:vCoR9VPpsk/TZFW2JwK5I9S0xdrtUq2bph6/Yj
 github.com/mattn/go-shellwords v1.0.11/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
-github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg=
 github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/mattn/go-sqlite3 v1.14.10 h1:MLn+5bFRlWMGoSRmJour3CL1w/qL96mvipqpwQW/Sfk=
+github.com/mattn/go-sqlite3 v1.14.10/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI=
 github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
@@ -1660,8 +1663,9 @@ google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG
 google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.40.0 h1:AGJ0Ih4mHjSeibYkFGh1dD9KJ/eOtZ93I6hoHhukQ5Q=
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.41.0 h1:f+PlOh7QV4iIJkPrx5NQ7qaNGFQ3OTse67yaDHfju4E=
+google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v0.0.0-20200709232328-d8193ee9cc3e/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0 h1:M1YKkFIboKNieVO5DLUEVzQfGwJD30Nv2jfUgzb5UcE=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
diff --git a/staging/operator-lifecycle-manager/.github/workflows/build.yml b/staging/operator-lifecycle-manager/.github/workflows/build.yml
index c7fa0fc9b0..738064565b 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/build.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/build.yml
@@ -1,12 +1,13 @@
 name: build
 on:
   pull_request:
+  workflow_dispatch:
 jobs:
   image:
     runs-on: ubuntu-latest
     steps:
     - name: Check out the repo
-      uses: actions/checkout@v2
+      uses: actions/checkout@v1
     - name: Build the container image
       uses: docker/build-push-action@v2
       with:
diff --git a/staging/operator-lifecycle-manager/.github/workflows/e2e-tests.yml b/staging/operator-lifecycle-manager/.github/workflows/e2e-tests.yml
index 6745d785d8..45a73af8aa 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/e2e-tests.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/e2e-tests.yml
@@ -1,14 +1,17 @@
 name: e2e
 on:
+  schedule:
+    - cron: '30 5,17 * * *' # run this every day at 5:30 and 17:30 UTC (00:30 and 12:30 ET)
   push:
     branches:
       - master
   pull_request:
+  workflow_dispatch:
 jobs:
   e2e-tests:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v1
       - uses: actions/setup-go@v2
         with:
           go-version: '~1.16'
diff --git a/staging/operator-lifecycle-manager/.github/workflows/goreleaser.yaml b/staging/operator-lifecycle-manager/.github/workflows/goreleaser.yaml
index 536a2b1e52..7625349126 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/goreleaser.yaml
+++ b/staging/operator-lifecycle-manager/.github/workflows/goreleaser.yaml
@@ -4,13 +4,13 @@ on:
   push:
     tags:
       - 'v*'
-
+  workflow_dispatch:
 jobs:
   release:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v1
         with:
           fetch-depth: 0
       - name: Set up Go
diff --git a/staging/operator-lifecycle-manager/.github/workflows/quickstart.yml b/staging/operator-lifecycle-manager/.github/workflows/quickstart.yml
index 9e6f6bf167..9df3656a97 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/quickstart.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/quickstart.yml
@@ -3,11 +3,12 @@ on:
   pull_request:
     paths:
     - 'deploy/upstream/quickstart/**'
+  workflow_dispatch:
 jobs:
   install-quickstart:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1
     - run: |
         curl -sLo kind "$(curl -sL https://api.github.com/repos/kubernetes-sigs/kind/releases/latest | jq -r '[.assets[] | select(.name == "kind-linux-amd64")] | first | .browser_download_url')"
         chmod +x kind
diff --git a/staging/operator-lifecycle-manager/.github/workflows/run-kind-local.yml b/staging/operator-lifecycle-manager/.github/workflows/run-kind-local.yml
index 2eaa7c6a44..920d19218e 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/run-kind-local.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/run-kind-local.yml
@@ -3,11 +3,12 @@ on:
   pull_request:
   schedule:
   - cron: '0 0 * * *' # daily to pick up releases
+  workflow_dispatch:
 jobs:
   e2e-kind:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1
     - uses: actions/setup-go@v2
       with:
         go-version: '~1.16'
diff --git a/staging/operator-lifecycle-manager/.github/workflows/run-minikube-local.yml b/staging/operator-lifecycle-manager/.github/workflows/run-minikube-local.yml
index e2fedf48ac..19cbfaa84a 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/run-minikube-local.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/run-minikube-local.yml
@@ -3,11 +3,12 @@ on:
   pull_request:
   schedule:
   - cron: '0 0 * * *' # daily to pick up releases
+  workflow_dispatch:
 jobs:
   e2e-minikube:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v1
     - uses: actions/setup-go@v2
       with:
         go-version: '~1.16'
diff --git a/staging/operator-lifecycle-manager/.github/workflows/sanity.yaml b/staging/operator-lifecycle-manager/.github/workflows/sanity.yaml
index 3ef7943f8c..9aaa52c638 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/sanity.yaml
+++ b/staging/operator-lifecycle-manager/.github/workflows/sanity.yaml
@@ -4,15 +4,20 @@ on:
     branches:
       - '**'
   pull_request:
+  workflow_dispatch:
 jobs:
   sanity:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v1
       - uses: actions/setup-go@v2
         with:
           go-version: '~1.16'
-      - name: Install goimports
-        run: go install golang.org/x/tools/cmd/goimports@latest
       - name: Run sanity checks
-        run: make vendor && make lint && make diff
+        run: make vendor && make diff
+      - name: Run linting checks
+        uses: "golangci/golangci-lint-action@v2"
+        with:
+          version: "v1.43"
+          skip-go-installation: true
+          skip-pkg-cache: true
diff --git a/staging/operator-lifecycle-manager/.github/workflows/unit.yml b/staging/operator-lifecycle-manager/.github/workflows/unit.yml
index 33b7f3f9ce..7f1fe801ad 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/unit.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/unit.yml
@@ -4,11 +4,12 @@ on:
     branches:
       - master
   pull_request:
+  workflow_dispatch:
 jobs:
   unit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v1
       - uses: actions/setup-go@v2
         with:
           go-version: '~1.16'
diff --git a/staging/operator-lifecycle-manager/.github/workflows/verify.yml b/staging/operator-lifecycle-manager/.github/workflows/verify.yml
index ea69dd344f..8cab62adae 100644
--- a/staging/operator-lifecycle-manager/.github/workflows/verify.yml
+++ b/staging/operator-lifecycle-manager/.github/workflows/verify.yml
@@ -4,11 +4,12 @@ on:
     branches:
       - master
   pull_request:
+  workflow_dispatch:
 jobs:
   verify:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v1
       - uses: actions/setup-go@v2
         with:
           go-version: '~1.16'
diff --git a/staging/operator-lifecycle-manager/.golangci.yaml b/staging/operator-lifecycle-manager/.golangci.yaml
new file mode 100644
index 0000000000..b0b322a52f
--- /dev/null
+++ b/staging/operator-lifecycle-manager/.golangci.yaml
@@ -0,0 +1,30 @@
+run:
+  timeout: 5m
+  skip-dirs:
+  - pkg/lib
+  - pkg/api
+  - pkg/fakes
+  - pkg/package-server/apis
+  - test/e2e
+
+linters:
+  enable:
+  - depguard
+  - gofmt
+  - goimports
+  - importas
+  - misspell
+  - stylecheck
+  - tparallel
+  - unconvert
+  - whitespace
+  disable:
+  - errcheck
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+output:
+  format: tab
+  sort-results: true
diff --git a/staging/operator-lifecycle-manager/MAINTAINERS.md b/staging/operator-lifecycle-manager/MAINTAINERS.md
index 84221e2ead..15c0a9fc9c 100644
--- a/staging/operator-lifecycle-manager/MAINTAINERS.md
+++ b/staging/operator-lifecycle-manager/MAINTAINERS.md
@@ -5,8 +5,8 @@ for general contribution guidelines.
 
 ## Maintainers (in alphabetical order)
 
-- [Alexander Greene](github.com/awgreene), Red Hat
-- [Evan Cordell](github.com/ecordell), Authzed
-- [Kevin Rizza](github.com/kevinrizza), Red Hat
-- [Nick Hale](github.com/njhale), Red Hat
-- [Vu Dinh](github.com/dinhxuanvu), Red Hat
+- [Alexander Greene](https://github.com/awgreene), Red Hat
+- [Evan Cordell](https://github.com/ecordell), Authzed
+- [Kevin Rizza](https://github.com/kevinrizza), Red Hat
+- [Nick Hale](https://github.com/njhale), Red Hat
+- [Vu Dinh](https://github.com/dinhxuanvu), Red Hat
diff --git a/staging/operator-lifecycle-manager/bill-of-materials.json b/staging/operator-lifecycle-manager/bill-of-materials.json
deleted file mode 100644
index 9574c09fd9..0000000000
--- a/staging/operator-lifecycle-manager/bill-of-materials.json
+++ /dev/null
@@ -1,388 +0,0 @@
-[
-	{
-		"project": "github.com/PuerkitoBio/purell",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9916666666666667
-			}
-		]
-	},
-	{
-		"project": "github.com/PuerkitoBio/urlesc",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "github.com/coreos/go-semver/semver",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/davecgh/go-spew/spew",
-		"licenses": [
-			{
-				"type": "ISC License",
-				"confidence": 0.9850746268656716
-			}
-		]
-	},
-	{
-		"project": "github.com/emicklei/go-restful",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/ghodss/yaml",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.8357142857142857
-			}
-		]
-	},
-	{
-		"project": "github.com/go-openapi/jsonpointer",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/go-openapi/jsonreference",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/go-openapi/spec",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			},
-			{
-				"type": "The Unlicense",
-				"confidence": 0.3422459893048128
-			}
-		]
-	},
-	{
-		"project": "github.com/go-openapi/swag",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/gogo/protobuf",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9090909090909091
-			}
-		]
-	},
-	{
-		"project": "github.com/golang/glog",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 0.9966703662597114
-			}
-		]
-	},
-	{
-		"project": "github.com/golang/groupcache/lru",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 0.9966703662597114
-			}
-		]
-	},
-	{
-		"project": "github.com/golang/mock/gomock",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/golang/protobuf",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.92
-			}
-		]
-	},
-	{
-		"project": "github.com/google/btree",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/google/gofuzz",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/googleapis/gnostic",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/gregjones/httpcache",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 0.9891304347826086
-			}
-		]
-	},
-	{
-		"project": "github.com/hashicorp/golang-lru",
-		"licenses": [
-			{
-				"type": "Mozilla Public License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/howeyc/gopass",
-		"licenses": [
-			{
-				"type": "ISC License",
-				"confidence": 0.9850746268656716
-			}
-		]
-	},
-	{
-		"project": "github.com/imdario/mergo",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "github.com/json-iterator/go",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/juju/ratelimit",
-		"licenses": [
-			{
-				"type": "GNU Lesser General Public License v3.0",
-				"confidence": 0.9409937888198758
-			}
-		]
-	},
-	{
-		"project": "github.com/mailru/easyjson",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 0.9891304347826086
-			}
-		]
-	},
-	{
-		"project": "github.com/peterbourgon/diskv",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 0.9891304347826086
-			}
-		]
-	},
-	{
-		"project": "github.com/pkg/errors",
-		"licenses": [
-			{
-				"type": "BSD 2-clause \"Simplified\" License",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/sirupsen/logrus",
-		"licenses": [
-			{
-				"type": "MIT License",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "github.com/spf13/pflag",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "github.com/v2pro/plz",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "golang.org/x/crypto/ssh/terminal",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "golang.org/x/net",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "golang.org/x/oauth2",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "golang.org/x/sys/unix",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "golang.org/x/text",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9663865546218487
-			}
-		]
-	},
-	{
-		"project": "gopkg.in/inf.v0",
-		"licenses": [
-			{
-				"type": "BSD 3-clause \"New\" or \"Revised\" License",
-				"confidence": 0.9752066115702479
-			}
-		]
-	},
-	{
-		"project": "gopkg.in/yaml.v2",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			},
-			{
-				"type": "MIT License",
-				"confidence": 0.8975609756097561
-			}
-		]
-	},
-	{
-		"project": "k8s.io/api",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "k8s.io/apiextensions-apiserver/pkg",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "k8s.io/apimachinery",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "k8s.io/client-go",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	},
-	{
-		"project": "k8s.io/kube-openapi/pkg",
-		"licenses": [
-			{
-				"type": "Apache License 2.0",
-				"confidence": 1
-			}
-		]
-	}
-]
diff --git a/staging/operator-lifecycle-manager/cmd/catalog/main.go b/staging/operator-lifecycle-manager/cmd/catalog/main.go
index 78f0acc70c..04e87771d4 100644
--- a/staging/operator-lifecycle-manager/cmd/catalog/main.go
+++ b/staging/operator-lifecycle-manager/cmd/catalog/main.go
@@ -69,7 +69,7 @@ var (
 	tlsCertPath = flag.String(
 		"tls-cert", "", "Path to use for certificate key (requires tls-key)")
 
-	profiling = flag.Bool("profiling", false, "deprecated")
+	_ = flag.Bool("profiling", false, "deprecated")
 
 	clientCAPath = flag.String("client-ca", "", "path to watch for client ca bundle")
 
diff --git a/staging/operator-lifecycle-manager/cmd/olm/main.go b/staging/operator-lifecycle-manager/cmd/olm/main.go
index dd67a27a79..c3b73728f0 100644
--- a/staging/operator-lifecycle-manager/cmd/olm/main.go
+++ b/staging/operator-lifecycle-manager/cmd/olm/main.go
@@ -63,7 +63,7 @@ var (
 	tlsCertPath = pflag.String(
 		"tls-cert", "", "Path to use for certificate key (requires tls-key)")
 
-	profiling = pflag.Bool("profiling", false, "deprecated")
+	_ = pflag.Bool("profiling", false, "deprecated")
 
 	clientCAPath = pflag.String("client-ca", "", "path to watch for client ca bundle")
 
diff --git a/staging/operator-lifecycle-manager/cmd/olm/manager.go b/staging/operator-lifecycle-manager/cmd/olm/manager.go
index 5e8e33ab73..36b0d6b8f9 100644
--- a/staging/operator-lifecycle-manager/cmd/olm/manager.go
+++ b/staging/operator-lifecycle-manager/cmd/olm/manager.go
@@ -118,7 +118,6 @@ func Manager(ctx context.Context, debug bool) (ctrl.Manager, error) {
 		if err = adoptionReconciler.SetupWithManager(mgr); err != nil {
 			return nil, err
 		}
-
 	}
 	setupLog.Info("manager configured")
 
diff --git a/staging/operator-lifecycle-manager/go.sum b/staging/operator-lifecycle-manager/go.sum
index 3748e2a012..402c302855 100644
--- a/staging/operator-lifecycle-manager/go.sum
+++ b/staging/operator-lifecycle-manager/go.sum
@@ -1785,7 +1785,6 @@ k8s.io/api v0.22.1/go.mod h1:bh13rkTp3F1XEaLGykbyRD2QaTTzPm0e/BMd8ptFONY=
 k8s.io/api v0.22.2 h1:M8ZzAD0V6725Fjg53fKeTJxGsJvRbk4TEm/fexHMtfw=
 k8s.io/api v0.22.2/go.mod h1:y3ydYpLJAaDI+BbSe2xmGcqxiWHmWjkEeIbiwHvnPR8=
 k8s.io/apiextensions-apiserver v0.18.2/go.mod h1:q3faSnRGmYimiocj6cHQ1I3WpLqmDgJFlKL37fC4ZvY=
-k8s.io/apiextensions-apiserver v0.18.2/go.mod h1:q3faSnRGmYimiocj6cHQ1I3WpLqmDgJFlKL37fC4ZvY=
 k8s.io/apiextensions-apiserver v0.20.1/go.mod h1:ntnrZV+6a3dB504qwC5PN/Yg9PBiDNt1EVqbW2kORVk=
 k8s.io/apiextensions-apiserver v0.20.6/go.mod h1:qO8YMqeMmZH+lV21LUNzV41vfpoE9QVAJRA+MNqj0mo=
 k8s.io/apiextensions-apiserver v0.21.0/go.mod h1:gsQGNtGkc/YoDG9loKI0V+oLZM4ljRPjc/sql5tmvzc=
@@ -1805,7 +1804,6 @@ k8s.io/apimachinery v0.22.1/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ
 k8s.io/apimachinery v0.22.2 h1:ejz6y/zNma8clPVfNDLnPbleBo6MpoFy/HBiBqCouVk=
 k8s.io/apimachinery v0.22.2/go.mod h1:O3oNtNadZdeOMxHFVxOreoznohCpy0z6mocxbZr7oJ0=
 k8s.io/apiserver v0.18.2/go.mod h1:Xbh066NqrZO8cbsoenCwyDJ1OSi8Ag8I2lezeHxzwzw=
-k8s.io/apiserver v0.18.2/go.mod h1:Xbh066NqrZO8cbsoenCwyDJ1OSi8Ag8I2lezeHxzwzw=
 k8s.io/apiserver v0.20.1/go.mod h1:ro5QHeQkgMS7ZGpvf4tSMx6bBOgPfE+f52KwvXfScaU=
 k8s.io/apiserver v0.20.6/go.mod h1:QIJXNt6i6JB+0YQRNcS0hdRHJlMhflFmsBDeSgT1r8Q=
 k8s.io/apiserver v0.21.0/go.mod h1:w2YSn4/WIwYuxG5zJmcqtRdtqgW/J2JRgFAqps3bBpg=
@@ -1838,7 +1836,6 @@ k8s.io/code-generator v0.22.1/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpx
 k8s.io/code-generator v0.22.2 h1:+bUv9lpTnAWABtPkvO4x0kfz7j/kDEchVt0P/wXU3jQ=
 k8s.io/code-generator v0.22.2/go.mod h1:eV77Y09IopzeXOJzndrDyCI88UBok2h6WxAlBwpxa+o=
 k8s.io/component-base v0.18.2/go.mod h1:kqLlMuhJNHQ9lz8Z7V5bxUUtjFZnrypArGl58gmDfUM=
-k8s.io/component-base v0.18.2/go.mod h1:kqLlMuhJNHQ9lz8Z7V5bxUUtjFZnrypArGl58gmDfUM=
 k8s.io/component-base v0.20.1/go.mod h1:guxkoJnNoh8LNrbtiQOlyp2Y2XFCZQmrcg2n/DeYNLk=
 k8s.io/component-base v0.20.6/go.mod h1:6f1MPBAeI+mvuts3sIdtpjljHWBQ2cIy38oBIWMYnrM=
 k8s.io/component-base v0.21.0/go.mod h1:qvtjz6X0USWXbgmbfXR+Agik4RZ3jv2Bgr5QnZzdPYw=
diff --git a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
index f30f610c61..55665aada6 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
@@ -384,7 +384,6 @@ const (
 )
 
 func (c *ConfigMapUnpacker) UnpackBundle(lookup *operatorsv1alpha1.BundleLookup, timeout time.Duration) (result *BundleUnpackResult, err error) {
-
 	result = newBundleUnpackResult(lookup)
 
 	// if bundle lookup failed condition already present, then there is nothing more to do
@@ -523,8 +522,8 @@ func (c *ConfigMapUnpacker) pendingContainerStatusMessages(job *batchv1.Job) (st
 	podLabel := map[string]string{BundleUnpackPodLabel: job.GetName()}
 	pods, listErr := c.podLister.Pods(job.GetNamespace()).List(k8slabels.SelectorFromValidatedSet(podLabel))
 	if listErr != nil {
-		c.logger.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr)
-		return "", fmt.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr)
+		c.logger.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr)
+		return "", fmt.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr)
 	}
 
 	// Ideally there should be just 1 pod running but inspect all pods in the pending phase
@@ -570,14 +569,14 @@ func (c *ConfigMapUnpacker) ensureConfigmap(csRef *corev1.ObjectReference, name
 		if err != nil && apierrors.IsAlreadyExists(err) {
 			cm, err = c.client.CoreV1().ConfigMaps(fresh.GetNamespace()).Get(context.TODO(), fresh.GetName(), metav1.GetOptions{})
 			if err != nil {
-				return nil, fmt.Errorf("Failed to retrieve configmap %s: %v", fresh.GetName(), err)
+				return nil, fmt.Errorf("failed to retrieve configmap %s: %v", fresh.GetName(), err)
 			}
 			cm.SetLabels(map[string]string{
 				install.OLMManagedLabelKey: install.OLMManagedLabelValue,
 			})
 			cm, err = c.client.CoreV1().ConfigMaps(cm.GetNamespace()).Update(context.TODO(), cm, metav1.UpdateOptions{})
 			if err != nil {
-				return nil, fmt.Errorf("Failed to update configmap %s: %v", cm.GetName(), err)
+				return nil, fmt.Errorf("failed to update configmap %s: %v", cm.GetName(), err)
 			}
 		}
 	}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go
index ec4dd672ba..4e580ffc36 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker_test.go
@@ -25,7 +25,7 @@ import (
 )
 
 const (
-	csvJson     = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"annotations\":{\"olm.skipRange\":\"\\u003c 0.6.0\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}],\"required\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"relatedImages\":[{\"image\":\"quay.io/coreos/etcd@sha256:3816b6daf9b66d6ced6f0f966314e2d4f894982c6b1493061502f8c2bf86ac84\",\"name\":\"etcd-v3.4.0\"},{\"image\":\"quay.io/coreos/etcd@sha256:49d3d4a81e0d030d3f689e7167f23e120abf955f7d08dbedf3ea246485acee9f\",\"name\":\"etcd-3.4.1\"}],\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"skips\":[\"etcdoperator.v0.9.1\"],\"version\":\"0.9.2\"}}"
+	csvJSON     = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"annotations\":{\"olm.skipRange\":\"\\u003c 0.6.0\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}],\"required\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"relatedImages\":[{\"image\":\"quay.io/coreos/etcd@sha256:3816b6daf9b66d6ced6f0f966314e2d4f894982c6b1493061502f8c2bf86ac84\",\"name\":\"etcd-v3.4.0\"},{\"image\":\"quay.io/coreos/etcd@sha256:49d3d4a81e0d030d3f689e7167f23e120abf955f7d08dbedf3ea246485acee9f\",\"name\":\"etcd-3.4.1\"}],\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"skips\":[\"etcdoperator.v0.9.1\"],\"version\":\"0.9.2\"}}"
 	etcdBackup  = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdbackups.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdBackup\",\"listKind\":\"EtcdBackupList\",\"plural\":\"etcdbackups\",\"singular\":\"etcdbackup\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
 	etcdCluster = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdclusters.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdCluster\",\"listKind\":\"EtcdClusterList\",\"plural\":\"etcdclusters\",\"shortNames\":[\"etcdclus\",\"etcd\"],\"singular\":\"etcdcluster\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
 	etcdRestore = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdrestores.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdRestore\",\"listKind\":\"EtcdRestoreList\",\"plural\":\"etcdrestores\",\"singular\":\"etcdrestore\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
@@ -511,7 +511,7 @@ func TestConfigMapUnpacker(t *testing.T) {
 						Data: map[string]string{
 							"etcdbackups.crd.json":  etcdBackup,
 							"etcdclusters.crd.json": etcdCluster,
-							"csv.json":              csvJson,
+							"csv.json":              csvJSON,
 							"etcdrestores.crd.json": etcdRestore,
 						},
 					},
@@ -558,11 +558,11 @@ func TestConfigMapUnpacker(t *testing.T) {
 					name: pathHash,
 					bundle: &api.Bundle{
 						CsvName: "etcdoperator.v0.9.2",
-						CsvJson: csvJson + "\n",
+						CsvJson: csvJSON + "\n",
 						Object: []string{
 							etcdBackup,
 							etcdCluster,
-							csvJson,
+							csvJSON,
 							etcdRestore,
 						},
 					},
@@ -586,7 +586,7 @@ func TestConfigMapUnpacker(t *testing.T) {
 						Data: map[string]string{
 							"etcdbackups.crd.json":  etcdBackup,
 							"etcdclusters.crd.json": etcdCluster,
-							"csv.json":              csvJson,
+							"csv.json":              csvJSON,
 							"etcdrestores.crd.json": etcdRestore,
 						},
 					},
@@ -1397,5 +1397,4 @@ func TestConfigMapUnpacker(t *testing.T) {
 			}
 		})
 	}
-
 }
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/apiservice.go b/staging/operator-lifecycle-manager/pkg/controller/install/apiservice.go
index c54a1f8ed6..1f1061c43b 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/apiservice.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/apiservice.go
@@ -44,7 +44,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateAPIService(caPEM []byte, des
 		apiService = apiService.DeepCopy()
 		csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 		if !ok {
-			return fmt.Errorf("APIServices require a CSV Owner.")
+			return fmt.Errorf("failed to typecast the APIService owner: APIServices require a CSV owner")
 		}
 
 		adoptable, err := IsAPIServiceAdoptable(i.strategyClient.GetOpLister(), csv, apiService)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/certresources.go b/staging/operator-lifecycle-manager/pkg/controller/install/certresources.go
index 49fd37f97f..9f368809c2 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/certresources.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/certresources.go
@@ -315,7 +315,6 @@ func (i *StrategyDeploymentInstaller) installCertRequirementsForDeployment(deplo
 			logger.Warnf("could not update secret %s", secret.GetName())
 			return nil, nil, err
 		}
-
 	} else if k8serrors.IsNotFound(err) {
 		// Create the secret
 		ownerutil.AddNonBlockingOwner(secret, i.owner)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/certresources_test.go b/staging/operator-lifecycle-manager/pkg/controller/install/certresources_test.go
index 7dadf00161..3823f29f37 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/certresources_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/certresources_test.go
@@ -37,7 +37,7 @@ func selector(t *testing.T, selector string) *metav1.LabelSelector {
 	return s
 }
 
-var staticCerts *certs.KeyPair = nil
+var staticCerts *certs.KeyPair
 
 // staticCertGenerator replaces the CertGenerator to get consistent keys for testing
 func staticCertGenerator(notAfter time.Time, organization string, ca *certs.KeyPair, hosts []string) (*certs.KeyPair, error) {
@@ -124,7 +124,6 @@ func TestInstallCertRequirementsForDeployment(t *testing.T) {
 	assert.NoError(t, err)
 	caHash := certs.PEMSHA256(caPEM)
 	type fields struct {
-		strategyClient         wrappers.InstallStrategyDeploymentInterface
 		owner                  ownerutil.Owner
 		previousStrategy       Strategy
 		templateAnnotations    map[string]string
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/deployment.go b/staging/operator-lifecycle-manager/pkg/controller/install/deployment.go
index d458bf3469..61adbb623b 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/deployment.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/deployment.go
@@ -179,23 +179,6 @@ func (i *StrategyDeploymentInstaller) deploymentForSpec(name string, spec appsv1
 	return
 }
 
-func (i *StrategyDeploymentInstaller) cleanupPrevious(current *v1alpha1.StrategyDetailsDeployment, previous *v1alpha1.StrategyDetailsDeployment) error {
-	previousDeploymentsMap := map[string]struct{}{}
-	for _, d := range previous.DeploymentSpecs {
-		previousDeploymentsMap[d.Name] = struct{}{}
-	}
-	for _, d := range current.DeploymentSpecs {
-		delete(previousDeploymentsMap, d.Name)
-	}
-	log.Debugf("preparing to cleanup: %s", previousDeploymentsMap)
-	// delete deployments in old strategy but not new
-	var err error = nil
-	for name := range previousDeploymentsMap {
-		err = i.strategyClient.DeleteDeployment(name)
-	}
-	return err
-}
-
 func (i *StrategyDeploymentInstaller) Install(s Strategy) error {
 	strategy, ok := s.(*v1alpha1.StrategyDetailsDeployment)
 	if !ok {
@@ -235,11 +218,6 @@ func (i *StrategyDeploymentInstaller) CheckInstalled(s Strategy) (installed bool
 }
 
 func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1alpha1.StrategyDeploymentSpec) error {
-	var depNames []string
-	for _, dep := range deploymentSpecs {
-		depNames = append(depNames, dep.Name)
-	}
-
 	// Check the owner is a CSV
 	csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 	if !ok {
@@ -273,7 +251,7 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al
 
 		// check annotations
 		if len(i.templateAnnotations) > 0 && dep.Spec.Template.Annotations == nil {
-			return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: fmt.Sprintf("no annotations found on deployment")}
+			return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: "no annotations found on deployment"}
 		}
 		for key, value := range i.templateAnnotations {
 			if actualValue, ok := dep.Spec.Template.Annotations[key]; !ok {
@@ -286,11 +264,11 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al
 		// check that the deployment spec hasn't changed since it was created
 		labels := dep.GetLabels()
 		if len(labels) == 0 {
-			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")}
+			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)}
 		}
 		existingDeploymentSpecHash, ok := labels[DeploymentSpecHashLabelKey]
 		if !ok {
-			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")}
+			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)}
 		}
 
 		_, calculatedDeploymentHash, err := i.deploymentForSpec(spec.Name, spec.Spec, labels)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker.go b/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
index b1550776d5..88dd64037f 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
@@ -67,7 +67,6 @@ func (c *CSVRuleChecker) RuleSatisfied(sa *corev1.ServiceAccount, namespace stri
 		if decision == authorizer.DecisionDeny || decision == authorizer.DecisionNoOpinion {
 			return false, nil
 		}
-
 	}
 
 	return true, nil
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker_test.go b/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker_test.go
index 3b3047dd3f..d49be53902 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/rule_checker_test.go
@@ -23,7 +23,6 @@ import (
 )
 
 func TestRuleSatisfied(t *testing.T) {
-
 	csv := &v1alpha1.ClusterServiceVersion{}
 	csv.SetName("barista-operator")
 	csv.SetUID(types.UID("barista-operator"))
@@ -606,7 +605,6 @@ func NewFakeCSVRuleChecker(k8sObjs []runtime.Object, csv *v1alpha1.ClusterServic
 	ruleChecker := NewCSVRuleChecker(roleInformer.Lister(), roleBindingInformer.Lister(), clusterRoleInformer.Lister(), clusterRoleBindingInformer.Lister(), csv)
 
 	return ruleChecker, nil
-
 }
 
 func Objs(roles []*rbacv1.Role, roleBindings []*rbacv1.RoleBinding, clusterRoles []*rbacv1.ClusterRole, clusterRoleBindings []*rbacv1.ClusterRoleBinding) []runtime.Object {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/install/webhook.go b/staging/operator-lifecycle-manager/pkg/controller/install/webhook.go
index c1dd4a1252..74c1987516 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/install/webhook.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/install/webhook.go
@@ -24,18 +24,18 @@ func ValidWebhookRules(rules []admissionregistrationv1.RuleWithOperations) error
 
 		// protect OLM resources
 		if contains(apiGroupMap, "*") {
-			return fmt.Errorf("Webhook rules cannot include all groups")
+			return fmt.Errorf("webhook rules cannot include all groups")
 		}
 
 		if contains(apiGroupMap, "operators.coreos.com") {
-			return fmt.Errorf("Webhook rules cannot include the OLM group")
+			return fmt.Errorf("webhook rules cannot include the OLM group")
 		}
 
 		// protect Admission Webhook resources
 		if contains(apiGroupMap, "admissionregistration.k8s.io") {
 			resourceGroupMap := listToMap(rule.Resources)
 			if contains(resourceGroupMap, "*") || contains(resourceGroupMap, "MutatingWebhookConfiguration") || contains(resourceGroupMap, "ValidatingWebhookConfiguration") {
-				return fmt.Errorf("Webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")
+				return fmt.Errorf("webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")
 			}
 		}
 	}
@@ -58,7 +58,7 @@ func contains(m map[string]struct{}, tar string) bool {
 func (i *StrategyDeploymentInstaller) createOrUpdateWebhook(caPEM []byte, desc v1alpha1.WebhookDescription) error {
 	operatorGroups, err := i.strategyClient.GetOpLister().OperatorsV1().OperatorGroupLister().OperatorGroups(i.owner.GetNamespace()).List(labels.Everything())
 	if err != nil || len(operatorGroups) != 1 {
-		return fmt.Errorf("Error retrieving OperatorGroup info")
+		return fmt.Errorf("error retrieving OperatorGroup info")
 	}
 	ogNamespacelabelSelector, err := operatorGroups[0].NamespaceLabelSelector()
 	if err != nil {
@@ -190,15 +190,14 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 	// get a list of owned CRDs
 	csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 	if !ok {
-		return fmt.Errorf("ConversionWebhook owner must be a ClusterServiceVersion")
+		return fmt.Errorf("unable to manage conversion webhook: conversion webhook owner must be a ClusterServiceVersion")
 	}
-
 	if !isSingletonOperator(*csv) {
-		return fmt.Errorf("CSVs with conversion webhooks must support only AllNamespaces")
+		return fmt.Errorf("unable to manage conversion webhook: CSVs with conversion webhooks must support only AllNamespaces")
 	}
 
 	if len(desc.ConversionCRDs) == 0 {
-		return fmt.Errorf("Conversion Webhook must have at least one CRD specified")
+		return fmt.Errorf("unable to manager conversion webhook: conversion webhook must have at least one CRD specified")
 	}
 
 	// iterate over all the ConversionCRDs
@@ -207,7 +206,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 			// Get existing CRD on cluster
 			crd, err := i.strategyClient.GetOpClient().ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), conversionCRD, metav1.GetOptions{})
 			if err != nil {
-				return fmt.Errorf("Unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err)
+				return fmt.Errorf("unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err)
 			}
 
 			// check if this CRD is an owned CRD
@@ -219,7 +218,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 				}
 			}
 			if !foundCRD {
-				return fmt.Errorf("CSV %s does not own CRD %s", csv.GetName(), conversionCRD)
+				return fmt.Errorf("csv %s does not own CRD %s", csv.GetName(), conversionCRD)
 			}
 
 			// crd.Spec.Conversion.Strategy specifies how custom resources are converted between versions.
@@ -232,7 +231,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 			// By default the strategy is none
 			// Reference:
 			// 	- https://v1-15.docs.kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definition-versioning/#specify-multiple-versions
-			if crd.Spec.PreserveUnknownFields != false {
+			if crd.Spec.PreserveUnknownFields {
 				return fmt.Errorf("crd.Spec.PreserveUnknownFields must be false to let API Server call webhook to do the conversion")
 			}
 
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go b/staging/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
index 8fb18ed92f..f0cd672893 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
@@ -37,7 +37,6 @@ type AdoptionReconciler struct {
 	client.Client
 
 	log     logr.Logger
-	mu      sync.RWMutex
 	factory decorators.OperatorFactory
 }
 
@@ -268,7 +267,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 
 	if err := r.Get(ctx, types.NamespacedName{Namespace: m.GetNamespace(), Name: m.GetName()}, cObj); err != nil {
@@ -290,7 +289,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 		// Only update if freshly adopted
 		pCObj, ok := candidate.(client.Object)
 		if !ok {
-			return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+			return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 		}
 		return r.Patch(ctx, pCObj, client.MergeFrom(cObj))
 	}
@@ -301,7 +300,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Operator, component runtime.Object) error {
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	candidate := component.DeepCopyObject()
 	disowned, err := operator.DisownComponent(candidate)
@@ -318,7 +317,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op
 	r.log.V(1).Info("component disowned", "component", candidate)
 	uCObj, ok := candidate.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	return r.Patch(ctx, uCObj, client.MergeFrom(cObj))
 }
@@ -326,7 +325,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op
 func (r *AdoptionReconciler) disownFromAll(ctx context.Context, component runtime.Object) error {
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	var operators []decorators.Operator
 	for _, name := range decorators.OperatorNames(cObj.GetLabels()) {
@@ -362,7 +361,7 @@ func (r *AdoptionReconciler) adoptees(ctx context.Context, operator decorators.O
 	for _, list := range componentLists {
 		cList, ok := list.(client.ObjectList)
 		if !ok {
-			return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList")
+			return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList")
 		}
 		if err := r.List(ctx, cList, opt); err != nil {
 			return nil, err
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
index a749a9c114..a4ca7f8ff6 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
@@ -552,8 +552,6 @@ func (o *Operator) handleDeletion(obj interface{}) {
 	}).Debug("handling object deletion")
 
 	o.requeueOwners(metaObj)
-
-	return
 }
 
 func (o *Operator) handleCatSrcDeletion(obj interface{}) {
@@ -562,13 +560,13 @@ func (o *Operator) handleCatSrcDeletion(obj interface{}) {
 		if !ok {
 			tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
 			if !ok {
-				utilruntime.HandleError(fmt.Errorf("Couldn't get object from tombstone %#v", obj))
+				utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
 				return
 			}
 
 			catsrc, ok = tombstone.Obj.(metav1.Object)
 			if !ok {
-				utilruntime.HandleError(fmt.Errorf("Tombstone contained object that is not a Namespace %#v", obj))
+				utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
 				return
 			}
 		}
@@ -716,11 +714,10 @@ func (o *Operator) syncRegistryServer(logger *logrus.Entry, in *v1alpha1.Catalog
 			logger.Debug("requeueing registry server for catalog update check: update pod not yet ready")
 			o.catsrcQueueSet.RequeueAfter(out.GetNamespace(), out.GetName(), reconciler.CatalogPollingRequeuePeriod)
 			return
-		} else {
-			syncError = fmt.Errorf("couldn't ensure registry server - %v", err)
-			out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError)
-			return
 		}
+		syncError = fmt.Errorf("couldn't ensure registry server - %v", err)
+		out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError)
+		return
 	}
 
 	logger.Debug("ensured registry server")
@@ -785,8 +782,6 @@ func (o *Operator) syncConnection(logger *logrus.Entry, in *v1alpha1.CatalogSour
 		return
 	}
 
-	logger = logger.WithField("address", address).WithField("currentSource", sourceKey)
-
 	if source.Address != address {
 		source, syncError = connectFunc()
 		if syncError != nil {
@@ -1531,22 +1526,21 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		}
 		syncError = ipFailError
 		return
-	} else {
-		// reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps
-		// (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after
-		// the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would
-		// be confusing to the user
-
-		// NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is
-		// true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as
-		// InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere
-		// is not being unset here unintentionally.
-		if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed {
-			plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger)
-			if err != nil {
-				syncError = err
-				return
-			}
+	}
+	// reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps
+	// (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after
+	// the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would
+	// be confusing to the user
+
+	// NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is
+	// true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as
+	// InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere
+	// is not being unset here unintentionally.
+	if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed {
+		plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger)
+		if err != nil {
+			syncError = err
+			return
 		}
 	}
 
@@ -1588,7 +1582,7 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		// which means bundle lookup has failed and the InstallPlan should be failed as well
 		isFailed, cond := hasBundleLookupFailureCondition(plan)
 		if isFailed {
-			err := fmt.Errorf("Bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message)
+			err := fmt.Errorf("bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message)
 			// Mark the InstallPlan as failed for a fatal bundle unpack error
 			logger.Infof("%v", err)
 
@@ -1672,7 +1666,7 @@ func (o *Operator) transitionInstallPlanToFailed(plan *v1alpha1.InstallPlan, log
 	logger.Errorf("error transitioning InstallPlan to failed")
 
 	// retry sync with error to update InstallPlan status
-	return fmt.Errorf("InstallPlan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr)
+	return fmt.Errorf("installplan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr)
 }
 
 func (o *Operator) requeueSubscriptionForInstallPlan(plan *v1alpha1.InstallPlan, logger *logrus.Entry) {
@@ -1869,7 +1863,7 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error {
 	// Get the set of initial installplan csv names
 	initialCSVNames := getCSVNameSet(plan)
 	// Get pre-existing CRD owners to make decisions about applying resolved CSVs
-	existingCRDOwners, err := o.getExistingApiOwners(plan.GetNamespace())
+	existingCRDOwners, err := o.getExistingAPIOwners(plan.GetNamespace())
 	if err != nil {
 		return err
 	}
@@ -2330,8 +2324,8 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error {
 	return nil
 }
 
-// getExistingApiOwners creates a map of CRD names to existing owner CSVs in the given namespace
-func (o *Operator) getExistingApiOwners(namespace string) (map[string][]string, error) {
+// getExistingAPIOwners creates a map of CRD names to existing owner CSVs in the given namespace
+func (o *Operator) getExistingAPIOwners(namespace string) (map[string][]string, error) {
 	// Get a list of CSVs in the namespace
 	csvList, err := o.client.OperatorsV1alpha1().ClusterServiceVersions(namespace).List(context.TODO(), metav1.ListOptions{})
 
@@ -2445,7 +2439,7 @@ func (o *Operator) apiresourceFromGVK(gvk schema.GroupVersionKind) (metav1.APIRe
 		}
 	}
 	logger.Info("couldn't find GVK in api discovery")
-	return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{gvk.Group, gvk.Version, gvk.Kind}
+	return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{Group: gvk.Group, Version: gvk.Version, Kind: gvk.Kind}
 }
 
 const (
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go
index 8abd022d94..0bc9056018 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/operator_test.go
@@ -246,7 +246,6 @@ func TestSyncInstallPlanUnhappy(t *testing.T) {
 			if tt.expectedCondition != nil {
 				require.True(t, hasExpectedCondition(ip, *tt.expectedCondition))
 			}
-
 		})
 	}
 }
@@ -258,7 +257,6 @@ func (ipSet) Generate(rand *rand.Rand, size int) reflect.Value {
 
 	// each i is the generation value
 	for i := 0; i < rand.Intn(size)+1; i++ {
-
 		// generate a few at each generation to account for bugs that don't increment the generation
 		for j := 0; j < rand.Intn(3); j++ {
 			ips = append(ips, v1alpha1.InstallPlan{
@@ -283,7 +281,7 @@ func TestGCInstallPlans(t *testing.T) {
 		ctx, cancel := context.WithCancel(context.TODO())
 		defer cancel()
 
-		var maxGen int64 = 0
+		var maxGen int64
 		for _, i := range ips {
 			if g := i.Generation; g > maxGen {
 				maxGen = g
@@ -296,7 +294,7 @@ func TestGCInstallPlans(t *testing.T) {
 		op, err := NewFakeOperator(ctx, "ns", []string{"ns"}, withClientObjs(objs...))
 		require.NoError(t, err)
 
-		out := make([]v1alpha1.InstallPlan, 0)
+		var out []v1alpha1.InstallPlan
 		for {
 			op.gcInstallPlans(logrus.New(), "ns")
 			require.NoError(t, err)
@@ -1107,7 +1105,7 @@ func TestSyncCatalogSources(t *testing.T) {
 			}
 
 			for _, o := range tt.expectedObjs {
-				switch o.(type) {
+				switch o := o.(type) {
 				case *corev1.Pod:
 					t.Log("verifying pod")
 					pods, err := op.opClient.KubernetesInterface().CoreV1().Pods(tt.catalogSource.Namespace).List(context.TODO(), metav1.ListOptions{})
@@ -1115,7 +1113,7 @@ func TestSyncCatalogSources(t *testing.T) {
 					require.Len(t, pods.Items, 1)
 
 					// set the name to the generated name
-					o.(*corev1.Pod).SetName(pods.Items[0].GetName())
+					o.SetName(pods.Items[0].GetName())
 					require.EqualValues(t, o, &pods.Items[0])
 				}
 			}
@@ -1134,9 +1132,6 @@ func TestSyncResolvingNamespace(t *testing.T) {
 		existingOLMObjs   []runtime.Object
 		existingObjects   []runtime.Object
 	}
-	type args struct {
-		obj interface{}
-	}
 	tests := []struct {
 		name    string
 		fields  fields
@@ -1281,6 +1276,7 @@ func TestSyncResolvingNamespace(t *testing.T) {
 }
 
 func TestCompetingCRDOwnersExist(t *testing.T) {
+	t.Parallel()
 
 	testNamespace := "default"
 	tests := []struct {
@@ -1458,12 +1454,6 @@ func withSources(sources ...sourceAddress) fakeOperatorOption {
 	}
 }
 
-func withReconciler(rec reconciler.RegistryReconcilerFactory) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.reconciler = rec
-	}
-}
-
 func withClock(clock utilclock.Clock) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		config.clock = clock
@@ -1571,6 +1561,9 @@ func NewFakeOperator(ctx context.Context, namespace string, namespaces []string,
 
 	// Create the new operator
 	queueOperator, err := queueinformer.NewOperator(opClientFake.KubernetesInterface().Discovery())
+	if err != nil {
+		return nil, fmt.Errorf("failed to create queueinformer operator: %w", err)
+	}
 	for _, informer := range sharedInformers {
 		queueOperator.RegisterInformer(informer)
 	}
@@ -1698,26 +1691,6 @@ func crd(name string) apiextensionsv1beta1.CustomResourceDefinition {
 	}
 }
 
-func v1crd(name string) apiextensionsv1.CustomResourceDefinition {
-	return apiextensionsv1.CustomResourceDefinition{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: name,
-		},
-		Spec: apiextensionsv1.CustomResourceDefinitionSpec{
-			Group: name + "group",
-			Versions: []apiextensionsv1.CustomResourceDefinitionVersion{
-				{
-					Name:   "v1",
-					Served: true,
-				},
-			},
-			Names: apiextensionsv1.CustomResourceDefinitionNames{
-				Kind: name,
-			},
-		},
-	}
-}
-
 func service(name, namespace string) *corev1.Service {
 	return &corev1.Service{
 		TypeMeta: metav1.TypeMeta{
@@ -1832,37 +1805,12 @@ func withOwner(owner ownerutil.Owner) modifierFunc {
 	})
 }
 
-func withObjectMeta(t *testing.T, obj runtime.Object, m *metav1.ObjectMeta) runtime.Object {
-	o := obj.DeepCopyObject()
-	accessor, err := meta.Accessor(o)
-	require.NoError(t, err)
-
-	accessor.SetAnnotations(m.GetAnnotations())
-	accessor.SetClusterName(m.GetClusterName())
-	accessor.SetCreationTimestamp(m.GetCreationTimestamp())
-	accessor.SetDeletionGracePeriodSeconds(m.GetDeletionGracePeriodSeconds())
-	accessor.SetDeletionTimestamp(m.GetDeletionTimestamp())
-	accessor.SetFinalizers(m.GetFinalizers())
-	accessor.SetGenerateName(m.GetGenerateName())
-	accessor.SetGeneration(m.GetGeneration())
-	accessor.SetLabels(m.GetLabels())
-	accessor.SetManagedFields(m.GetManagedFields())
-	accessor.SetName(m.GetName())
-	accessor.SetNamespace(m.GetNamespace())
-	accessor.SetOwnerReferences(m.GetOwnerReferences())
-	accessor.SetResourceVersion(m.GetResourceVersion())
-	accessor.SetSelfLink(m.GetSelfLink())
-	accessor.SetUID(m.GetUID())
-
-	return o
-}
-
 func apiResourcesForObjects(objs []runtime.Object) []*metav1.APIResourceList {
 	apis := []*metav1.APIResourceList{}
 	for _, o := range objs {
-		switch o.(type) {
+		switch o := o.(type) {
 		case *apiextensionsv1beta1.CustomResourceDefinition:
-			crd := o.(*apiextensionsv1beta1.CustomResourceDefinition)
+			crd := o
 			apis = append(apis, &metav1.APIResourceList{
 				GroupVersion: metav1.GroupVersion{Group: crd.Spec.Group, Version: crd.Spec.Versions[0].Name}.String(),
 				APIResources: []metav1.APIResource{
@@ -1877,7 +1825,7 @@ func apiResourcesForObjects(objs []runtime.Object) []*metav1.APIResourceList {
 				},
 			})
 		case *apiregistrationv1.APIService:
-			a := o.(*apiregistrationv1.APIService)
+			a := o
 			names := strings.Split(a.Name, ".")
 			apis = append(apis, &metav1.APIResourceList{
 				GroupVersion: metav1.GroupVersion{Group: names[1], Version: a.Spec.Version}.String(),
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/querier_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/querier_test.go
index 022abeb4f3..a907973cdd 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/querier_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/querier_test.go
@@ -14,7 +14,7 @@ import (
 func TestNewNamespaceSourceQuerier(t *testing.T) {
 	emptySources := map[registry.CatalogKey]registry.ClientInterface{}
 	nonEmptySources := map[registry.CatalogKey]registry.ClientInterface{
-		registry.CatalogKey{"test", "ns"}: &registry.Client{
+		{Name: "test", Namespace: "ns"}: &registry.Client{
 			Client: &client.Client{
 				Registry: &fakes.FakeRegistryClient{},
 			},
@@ -85,7 +85,7 @@ func TestNamespaceSourceQuerier_Queryable(t *testing.T) {
 			name: "nonEmpty",
 			fields: fields{
 				sources: map[registry.CatalogKey]registry.ClientInterface{
-					registry.CatalogKey{"test", "ns"}: &registry.Client{
+					{Name: "test", Namespace: "ns"}: &registry.Client{
 						Client: &client.Client{
 							Registry: &fakes.FakeRegistryClient{},
 						},
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
index 1093c1ddd1..a6a80bfaff 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
@@ -102,9 +102,8 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter
 			if err != nil {
 				if k8serrors.IsNotFound(err) {
 					return v1alpha1.StepStatusNotPresent, nil
-				} else {
-					return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name)
 				}
+				return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name)
 			}
 			established, namesAccepted := false, false
 			for _, cdt := range crd.Status.Conditions {
@@ -167,7 +166,7 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter
 				// Unexpected error creating the CRD.
 				return v1alpha1.StepStatusUnknown, createError
 			}
-			// If no error occured, make sure to wait for the API to become available.
+			// If no error occurred, make sure to wait for the API to become available.
 			return v1alpha1.StepStatusWaitingForAPI, nil
 		}
 		return v1alpha1.StepStatusUnknown, nil
@@ -186,9 +185,8 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi
 			if err != nil {
 				if k8serrors.IsNotFound(err) {
 					return v1alpha1.StepStatusNotPresent, nil
-				} else {
-					return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err)
 				}
+				return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err)
 			}
 			established, namesAccepted := false, false
 			for _, cdt := range crd.Status.Conditions {
@@ -252,7 +250,7 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi
 				// Unexpected error creating the CRD.
 				return v1alpha1.StepStatusUnknown, createError
 			}
-			// If no error occured, make sure to wait for the API to become available.
+			// If no error occurred, make sure to wait for the API to become available.
 			return v1alpha1.StepStatusWaitingForAPI, nil
 		}
 		return v1alpha1.StepStatusUnknown, nil
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step_ensurer_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step_ensurer_test.go
index a62bab92ca..4bceee3077 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step_ensurer_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/step_ensurer_test.go
@@ -10,8 +10,8 @@ import (
 
 func TestMergedOwnerReferences(t *testing.T) {
 	var (
-		True  bool = true
-		False bool = false
+		True  = true
+		False = false
 	)
 
 	for _, tc := range []struct {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/reconciler_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/reconciler_test.go
index 54ed929c51..b27529d5d3 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/reconciler_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/reconciler_test.go
@@ -1696,7 +1696,6 @@ type fakeReconcilerConfig struct {
 	now                       func() *metav1.Time
 	registryReconcilerFactory registryreconciler.RegistryReconcilerFactory
 	globalCatalogNamespace    string
-	subscriptionNamespace     string
 	existingObjs              existingObjs
 }
 
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
index 024cb3dd96..92cba65c58 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
@@ -243,7 +243,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha
 	var known CatalogHealthKnownState
 	switch {
 	case missingTargeted:
-		healthy = false
 		cond.Message = fmt.Sprintf("targeted catalogsource %s/%s missing", in.Spec.CatalogSourceNamespace, in.Spec.CatalogSource)
 		fallthrough
 	case !healthy:
@@ -273,7 +272,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha
 	case numNew < numOld:
 		cond.Reason = v1alpha1.CatalogSourcesDeleted
 	case numNew == 0 && numNew == numOld:
-		healthy = false
 		cond.Reason = v1alpha1.NoCatalogSourcesFound
 		cond.Message = "dependency resolution requires at least one catalogsource"
 	case numNew == numOld:
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state_test.go
index afd0f576b4..a950311c96 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state_test.go
@@ -5,14 +5,13 @@ import (
 	"testing"
 	"time"
 
+	"github.com/operator-framework/api/pkg/operators/v1alpha1"
+	"github.com/stretchr/testify/require"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	utilclock "k8s.io/apimachinery/pkg/util/clock"
-
-	"github.com/operator-framework/api/pkg/operators/v1alpha1"
-	"github.com/stretchr/testify/require"
 )
 
 func TestUpdateHealth(t *testing.T) {
@@ -488,7 +487,6 @@ func TestUpdateHealth(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, sub, clusterSub)
 			}
-
 		})
 	}
 }
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/syncer_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/syncer_test.go
index a8ed1002a6..e1afd66313 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/syncer_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/syncer_test.go
@@ -19,8 +19,7 @@ func TestSync(t *testing.T) {
 		event kubestate.ResourceEvent
 	}
 	type want struct {
-		err           error
-		subscriptions []v1alpha1.Subscription
+		err error
 	}
 
 	tests := []struct {
@@ -56,5 +55,4 @@ func TestSync(t *testing.T) {
 			require.Equal(t, tt.want.err, tt.fields.syncer.Sync(ctx, tt.args.event))
 		})
 	}
-
 }
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go
deleted file mode 100644
index 298e0e3232..0000000000
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package catalog
-
-import (
-	"errors"
-
-	"github.com/operator-framework/api/pkg/operators/v1alpha1"
-)
-
-var (
-	ErrNilSubscription = errors.New("invalid Subscription object: <nil>")
-)
-
-const (
-	PackageLabel          = "olm.package"
-	CatalogLabel          = "olm.catalog"
-	CatalogNamespaceLabel = "olm.catalog.namespace"
-	ChannelLabel          = "olm.channel"
-)
-
-func labelsForSubscription(sub *v1alpha1.Subscription) map[string]string {
-	return map[string]string{
-		PackageLabel:          sub.Spec.Package,
-		CatalogLabel:          sub.Spec.CatalogSource,
-		CatalogNamespaceLabel: sub.Spec.CatalogSourceNamespace,
-		ChannelLabel:          sub.Spec.Channel,
-	}
-}
-
-// TODO remove this once UI no longer needs them
-func legacyLabelsForSubscription(sub *v1alpha1.Subscription) map[string]string {
-	return map[string]string{
-		"alm-package": sub.Spec.Package,
-		"alm-catalog": sub.Spec.CatalogSource,
-		"alm-channel": sub.Spec.Channel,
-	}
-}
-
-func ensureLabels(sub *v1alpha1.Subscription) *v1alpha1.Subscription {
-	labels := sub.GetLabels()
-	if labels == nil {
-		labels = map[string]string{}
-	}
-	for k, v := range labelsForSubscription(sub) {
-		labels[k] = v
-	}
-	for k, v := range legacyLabelsForSubscription(sub) {
-		labels[k] = v
-	}
-	sub.SetLabels(labels)
-	return sub
-}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions_test.go
index 15e44269fb..6a813d88df 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions_test.go
@@ -1054,6 +1054,7 @@ func TestSyncSubscriptions(t *testing.T) {
 			}
 
 			installPlans, err := o.client.OperatorsV1alpha1().InstallPlans(testNamespace).List(context.TODO(), metav1.ListOptions{})
+			require.NoError(t, err)
 			require.Len(t, installPlans.Items, len(tt.wantInstallPlans))
 
 			haveIPs := make(map[string]v1alpha1.InstallPlan)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
index c91dc7c90e..ad50cc3018 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
@@ -175,7 +175,6 @@ func (o *Operator) syncCatalogSources(obj interface{}) error {
 
 		// make sure that the processed image reference is actually different
 		if outputCatalogSource.Spec.Image != processedCatalogImageTemplate {
-
 			outputCatalogSource.Spec.Image = processedCatalogImageTemplate
 
 			if err := catalogsource.UpdateSpecAndStatusConditions(logger, o.client, outputCatalogSource, conditions...); err != nil {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
index 4046f7ee09..612a8a6244 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
@@ -22,9 +22,9 @@ import (
 )
 
 const (
-	newOperatorError       = "Cannot create new Operator: %s"
-	newComponentError      = "Cannot create new Component: %s"
-	componentLabelKeyError = "Cannot generate component label key: %s"
+	newOperatorError       = "cannot create new Operator: %s"
+	newComponentError      = "cannot create new Component: %s"
+	componentLabelKeyError = "cannot generate component label key: %s"
 
 	// ComponentLabelKeyPrefix is the key prefix used for labels marking operator component resources.
 	ComponentLabelKeyPrefix = "operators.coreos.com/"
@@ -295,7 +295,7 @@ func (o *Operator) AddComponents(components ...runtime.Object) error {
 		if matches, err := component.Matches(selector); err != nil {
 			return err
 		} else if !matches {
-			return fmt.Errorf("Cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String())
+			return fmt.Errorf("cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String())
 		}
 
 		ref, err := component.Reference()
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
index 88a93fd1b4..79e79179af 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
@@ -88,7 +88,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		// Check if the APIService points to the correct service
 		if apiService.Spec.Service.Name != serviceName || apiService.Spec.Service.Namespace != csv.GetNamespace() {
 			logger.WithFields(log.Fields{"service": apiService.Spec.Service.Name, "serviceNamespace": apiService.Spec.Service.Namespace}).Warnf("APIService service reference mismatch")
-			errs = append(errs, fmt.Errorf("APIService service reference mismatch"))
+			errs = append(errs, fmt.Errorf("found APIService and service reference mismatch"))
 			continue
 		}
 
@@ -102,7 +102,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if !certs.Active(ca) {
 			logger.Warnf("CA cert not active")
-			errs = append(errs, fmt.Errorf("CA cert not active"))
+			errs = append(errs, fmt.Errorf("found the CA cert is not active"))
 			continue
 		}
 
@@ -122,7 +122,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if !certs.Active(cert) {
 			logger.Warnf("serving cert not active")
-			errs = append(errs, fmt.Errorf("serving cert not active"))
+			errs = append(errs, fmt.Errorf("found the serving cert not active"))
 			continue
 		}
 
@@ -155,7 +155,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if hash, ok := deployment.Spec.Template.GetAnnotations()[install.OLMCAHashAnnotationKey]; !ok || hash != caHash {
 			logger.WithField("deployment", desc.DeploymentName).Warnf("Deployment CA cert hash does not match expected")
-			errs = append(errs, fmt.Errorf("Deployment %s CA cert hash does not match expected", desc.DeploymentName))
+			errs = append(errs, fmt.Errorf("deployment %s CA cert hash does not match expected", desc.DeploymentName))
 			continue
 		}
 
@@ -214,7 +214,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 				}
 				if !satisfied {
 					logger.WithField("rule", fmt.Sprintf("%+v", rule)).Warnf("Rule not satisfied")
-					errs = append(errs, fmt.Errorf("Rule %+v not satisfied", rule))
+					errs = append(errs, fmt.Errorf("rule %+v not satisfied", rule))
 					continue
 				}
 			}
@@ -260,7 +260,7 @@ func (a *Operator) getAPIServiceCABundle(csv *v1alpha1.ClusterServiceVersion, de
 		return apiService.Spec.CABundle, nil
 	}
 
-	return nil, fmt.Errorf("Unable to find ca")
+	return nil, fmt.Errorf("unable to find CA")
 }
 
 // getWebhookCABundle returns the CA associated with a webhook
@@ -303,13 +303,13 @@ func (a *Operator) getWebhookCABundle(csv *v1alpha1.ClusterServiceVersion, desc
 		}
 	}
 
-	return nil, fmt.Errorf("Unable to find ca")
+	return nil, fmt.Errorf("unable to find CA")
 }
 
-// updateDeploymentSpecsWithApiServiceData transforms an install strategy to include information about apiservices
+// updateDeploymentSpecsWithAPIServiceData transforms an install strategy to include information about apiservices
 // it is used in generating hashes for deployment specs to know when something in the spec has changed,
 // but duplicates a lot of installAPIServiceRequirements and should be refactored.
-func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) {
+func (a *Operator) updateDeploymentSpecsWithAPIServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) {
 	// Assume the strategy is for a deployment
 	strategyDetailsDeployment, ok := strategy.(*v1alpha1.StrategyDetailsDeployment)
 	if !ok {
@@ -335,7 +335,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 
 		depSpec, ok := depSpecs[desc.DeploymentName]
 		if !ok {
-			return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group))
+			return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group))
 		}
 
 		if depSpec.Template.Spec.ServiceAccountName == "" {
@@ -345,7 +345,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 		// Update deployment with secret volume mount.
 		secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName)))
 		if err != nil {
-			return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
+			return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
 		}
 
 		install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName())
@@ -362,7 +362,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 
 		depSpec, ok := depSpecs[desc.DeploymentName]
 		if !ok {
-			return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName)
+			return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName)
 		}
 
 		if depSpec.Template.Spec.ServiceAccountName == "" {
@@ -372,7 +372,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 		// Update deployment with secret volume mount.
 		secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName)))
 		if err != nil {
-			return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
+			return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
 		}
 		install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName())
 
@@ -406,7 +406,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e
 	for _, webhook := range validatingWebhookConfigurationList.Items {
 		webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey]
 		if !ok {
-			return fmt.Errorf("ValidatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
+			return fmt.Errorf("validatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
 		}
 		if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok {
 			err = a.opClient.KubernetesInterface().AdmissionregistrationV1().ValidatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{})
@@ -424,7 +424,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e
 	for _, webhook := range mutatingWebhookConfigurationList.Items {
 		webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey]
 		if !ok {
-			return fmt.Errorf("MutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
+			return fmt.Errorf("mutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
 		}
 		if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok {
 			err = a.opClient.KubernetesInterface().AdmissionregistrationV1().MutatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{})
@@ -473,7 +473,7 @@ func (a *Operator) areWebhooksAvailable(csv *v1alpha1.ClusterServiceVersion) (bo
 				}
 
 				if crd.Spec.Conversion == nil || crd.Spec.Conversion.Strategy != "Webhook" || crd.Spec.Conversion.Webhook == nil || crd.Spec.Conversion.Webhook.ClientConfig == nil && crd.Spec.Conversion.Webhook.ClientConfig.CABundle == nil {
-					return false, fmt.Errorf("ConversionWebhook not ready")
+					return false, fmt.Errorf("conversionWebhook not ready")
 				}
 				webhookCount++
 			}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/groups_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/groups_test.go
index 9534ab4593..0f986c041e 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/groups_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/groups_test.go
@@ -799,7 +799,6 @@ func TestGroupIntersection(t *testing.T) {
 			require.EqualValues(t, tt.want, tt.in.left.GroupIntersection(tt.in.right...))
 		})
 	}
-
 }
 
 func apiIntersectionReconcilerSuite(t *testing.T, reconciler APIIntersectionReconciler) {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
index ffc9c3b264..862a3dd98e 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
@@ -418,7 +418,6 @@ func newOperatorWithConfig(ctx context.Context, config *operatorConfig) (*Operat
 		if err := op.RegisterQueueInformer(objGCQueueInformer); err != nil {
 			return nil, err
 		}
-
 	}
 
 	// add queue for all namespaces as well
@@ -617,8 +616,6 @@ func (a *Operator) syncSubscriptionDeleted(obj interface{}) {
 	if !ok {
 		a.logger.Debugf("casting Subscription failed, wrong type: %#v\n", obj)
 	}
-
-	return
 }
 
 func (a *Operator) syncAPIService(obj interface{}) (syncError error) {
@@ -823,7 +820,6 @@ func (a *Operator) syncObject(obj interface{}) (syncError error) {
 				return
 			}
 		}
-
 	}
 
 	// Requeue all owner CSVs
@@ -891,7 +887,6 @@ func (a *Operator) namespaceAddedOrRemoved(obj interface{}) {
 			}
 		}
 	}
-	return
 }
 
 func (a *Operator) syncNamespace(obj interface{}) error {
@@ -1193,7 +1188,6 @@ func (a *Operator) syncClusterServiceVersion(obj interface{}) (syncError error)
 		outCSV.Status.Phase == clusterServiceVersion.Status.Phase &&
 		outCSV.Status.Reason == clusterServiceVersion.Status.Reason &&
 		outCSV.Status.Message == clusterServiceVersion.Status.Message) {
-
 		// Update CSV with status of transition. Log errors if we can't write them to the status.
 		_, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(outCSV.GetNamespace()).UpdateStatus(context.TODO(), outCSV, metav1.UpdateOptions{})
 		if err != nil {
@@ -1337,7 +1331,7 @@ func getCopiedCSVsCondition(isDisabled, csvIsRequeued bool) metav1.Condition {
 	}
 	if !isDisabled {
 		condition.Reason = "CopiedCSVsEnabled"
-		condition.Message = "Copied CSVs are enabled and present accross the cluster"
+		condition.Message = "Copied CSVs are enabled and present across the cluster"
 		if csvIsRequeued {
 			condition.Message = "Copied CSVs are enabled and at least one copied CSVs is missing"
 		}
@@ -1719,6 +1713,10 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 
 	// Check for intersecting provided APIs in intersecting OperatorGroups
 	allGroups, err := a.lister.OperatorsV1().OperatorGroupLister().List(labels.Everything())
+	if err != nil {
+		logger.WithError(err).Warn("failed to list operatorgroups")
+		return
+	}
 	otherGroups := make([]v1.OperatorGroup, 0, len(allGroups))
 	for _, g := range allGroups {
 		if g.GetName() != operatorGroup.GetName() || g.GetNamespace() != operatorGroup.GetNamespace() {
@@ -1835,7 +1833,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		for _, desc := range out.Spec.WebhookDefinitions {
 			_, present := webhookNames[desc.GenerateName]
 			if present {
-				logger.WithError(fmt.Errorf("Repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid")
+				logger.WithError(fmt.Errorf("repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid")
 				out.SetPhaseWithEventIfChanged(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInvalidWebhookDescription, "CSV contains repeated WebhookDescription name", now, a.recorder)
 				return
 			}
@@ -1911,7 +1909,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			return
 		}
 
-		strategy, err := a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err := a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -1927,7 +1925,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			// Set phase to failed if it's been a long time since the last transition (5 minutes)
 			if out.Status.LastTransitionTime != nil && a.now().Sub(out.Status.LastTransitionTime.Time) >= 5*time.Minute {
 				logger.Warn("install timed out")
-				out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, fmt.Sprintf("install timeout"), now, a.recorder)
+				out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, "install timeout", now, a.recorder)
 				return
 			}
 		}
@@ -1968,12 +1966,12 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		} else if !met {
 			logger.Debug("CSV Requirements are no longer met")
 			out.SetRequirementStatus(statuses)
-			out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements no longer met"), now, a.recorder)
+			out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, "requirements no longer met", now, a.recorder)
 			return
 		}
 
 		// Check install status
-		strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -2039,7 +2037,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		} else if !met {
 			logger.Debug("CSV Requirements are not met")
 			out.SetRequirementStatus(statuses)
-			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements not met"), now, a.recorder)
+			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, "requirements not met", now, a.recorder)
 			return
 		}
 
@@ -2061,7 +2059,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		}
 
 		// Check install status
-		strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -2168,17 +2166,18 @@ func (a *Operator) updateInstallStatus(csv *v1alpha1.ClusterServiceVersion, inst
 	}
 
 	if !apiServicesInstalled {
-		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf("APIServices not installed"), now, a.recorder)
+		msg := "apiServices not installed"
+		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder)
 		if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil {
 			a.logger.Warn(err.Error())
 		}
 
-		return fmt.Errorf("APIServices not installed")
+		return fmt.Errorf(msg)
 	}
 
 	if !webhooksInstalled || webhookErr != nil {
-		msg := "Webhooks not installed"
-		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf(msg), now, a.recorder)
+		msg := "webhooks not installed"
+		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder)
 		if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil {
 			a.logger.Warn(err.Error())
 		}
@@ -2240,10 +2239,14 @@ func (a *Operator) parseStrategiesAndUpdateStatus(csv *v1alpha1.ClusterServiceVe
 	querierFunc := a.serviceAccountQuerier.NamespaceQuerier(csv.GetNamespace())
 	attenuate, err := a.clientAttenuator.AttenuateToServiceAccount(querierFunc)
 	if err != nil {
-		a.logger.Errorf("failed to get a client for operator deployment- %v", err)
+		a.logger.Errorf("failed to get a client for operator deployment - %v", err)
 		return nil, nil
 	}
 	kubeclient, err := a.clientFactory.WithConfigTransformer(attenuate).NewOperatorClient()
+	if err != nil {
+		a.logger.Errorf("failed to get an operator client for operator deployment - %v", err)
+		return nil, nil
+	}
 
 	strName := strategy.GetStrategyName()
 	installer := a.resolver.InstallerForStrategy(strName, kubeclient, a.lister, csv, csv.GetAnnotations(), csv.GetAllAPIServiceDescriptions(), csv.Spec.WebhookDefinitions, previousStrategy)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator_test.go
index 722789053e..ce3daf6c8b 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operator_test.go
@@ -102,17 +102,17 @@ func ownerLabelFromCSV(name, namespace string) map[string]string {
 	}
 }
 
-func addDepSpecHashLabel(labels map[string]string, strat v1alpha1.NamedInstallStrategy) map[string]string {
-	labels[install.DeploymentSpecHashLabelKey] = install.HashDeploymentSpec(strat.StrategySpec.DeploymentSpecs[0].Spec)
+func addDepSpecHashLabel(labels map[string]string, strategy v1alpha1.NamedInstallStrategy) map[string]string {
+	labels[install.DeploymentSpecHashLabelKey] = install.HashDeploymentSpec(strategy.StrategySpec.DeploymentSpecs[0].Spec)
 	return labels
 }
 
 func apiResourcesForObjects(objs []runtime.Object) []*metav1.APIResourceList {
 	apis := []*metav1.APIResourceList{}
 	for _, o := range objs {
-		switch o.(type) {
+		switch o := o.(type) {
 		case *apiextensionsv1.CustomResourceDefinition:
-			crd := o.(*apiextensionsv1.CustomResourceDefinition)
+			crd := o
 			apis = append(apis, &metav1.APIResourceList{
 				GroupVersion: metav1.GroupVersion{Group: crd.Spec.Group, Version: crd.Spec.Versions[0].Name}.String(),
 				APIResources: []metav1.APIResource{
@@ -127,7 +127,7 @@ func apiResourcesForObjects(objs []runtime.Object) []*metav1.APIResourceList {
 				},
 			})
 		case *apiregistrationv1.APIService:
-			a := o.(*apiregistrationv1.APIService)
+			a := o
 			names := strings.Split(a.Name, ".")
 			apis = append(apis, &metav1.APIResourceList{
 				GroupVersion: metav1.GroupVersion{Group: names[1], Version: a.Spec.Version}.String(),
@@ -161,42 +161,18 @@ type fakeOperatorConfig struct {
 // fakeOperatorOption applies an option to the given fake operator configuration.
 type fakeOperatorOption func(*fakeOperatorConfig)
 
-func withResyncPeriod(period time.Duration) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.resyncPeriod = queueinformer.ResyncWithJitter(period, 0.1)
-	}
-}
-
 func withOperatorNamespace(namespace string) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		config.operatorNamespace = namespace
 	}
 }
 
-func withWatchedNamespaces(namespaces ...string) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.watchedNamespaces = namespaces
-	}
-}
-
-func withLogger(logger *logrus.Logger) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.logger = logger
-	}
-}
-
 func withClock(clock utilclock.Clock) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		config.clock = clock
 	}
 }
 
-func withStrategyResolver(strategyResolver install.StrategyResolverInterface) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.strategyResolver = strategyResolver
-	}
-}
-
 func withAPIReconciler(apiReconciler APIIntersectionReconciler) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		if apiReconciler != nil {
@@ -213,24 +189,12 @@ func withAPILabeler(apiLabeler labeler.Labeler) fakeOperatorOption {
 	}
 }
 
-func withEventRecorder(rec record.EventRecorder) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.recorder = rec
-	}
-}
-
 func withNamespaces(namespaces ...string) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		config.namespaces = namespaces
 	}
 }
 
-func withFakeClientOptions(options ...clientfake.Option) fakeOperatorOption {
-	return func(config *fakeOperatorConfig) {
-		config.fakeClientOptions = options
-	}
-}
-
 func withClientObjs(clientObjs ...runtime.Object) fakeOperatorOption {
 	return func(config *fakeOperatorConfig) {
 		config.clientObjs = clientObjs
@@ -748,7 +712,6 @@ func withAPIServices(csv *v1alpha1.ClusterServiceVersion, owned, required []v1al
 func withInstallModes(csv *v1alpha1.ClusterServiceVersion, installModes []v1alpha1.InstallMode) *v1alpha1.ClusterServiceVersion {
 	csv.Spec.InstallModes = installModes
 	return csv
-
 }
 
 func apis(apis ...string) []v1alpha1.APIServiceDescription {
@@ -917,7 +880,7 @@ func TestTransitionCSV(t *testing.T) {
 
 	type csvState struct {
 		exists bool
-		phase  v1alpha1.ClusterServiceVersionPhase
+		phase  v1alpha1.ClusterServiceVersionPhase //nolint:structcheck
 		reason v1alpha1.ConditionReason
 	}
 	type operatorConfig struct {
@@ -3131,7 +3094,7 @@ func TestTransitionCSV(t *testing.T) {
 func TestWebhookCABundleRetrieval(t *testing.T) {
 	logrus.SetLevel(logrus.DebugLevel)
 	namespace := "ns"
-	missingCAError := fmt.Errorf("Unable to find ca")
+	missingCAError := fmt.Errorf("unable to find CA")
 	caBundle := []byte("Foo")
 
 	type initial struct {
@@ -3365,6 +3328,8 @@ func TestWebhookCABundleRetrieval(t *testing.T) {
 // TestUpdates verifies that a set of expected phase transitions occur when multiple CSVs are present
 // and that they do not depend on sync order or event order
 func TestUpdates(t *testing.T) {
+	t.Parallel()
+
 	// A - replacedby -> B - replacedby -> C
 	namespace := "ns"
 	defaultOperatorGroup := &v1.OperatorGroup{
@@ -5048,7 +5013,6 @@ func TestAPIServiceResourceErrorActionable(t *testing.T) {
 			require.Equal(t, tt.actionable, op.apiServiceResourceErrorActionable(aggregate))
 		})
 	}
-
 }
 
 func crdWithConversionWebhook(crd *apiextensionsv1.CustomResourceDefinition, caBundle []byte) *apiextensionsv1.CustomResourceDefinition {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
index 6dfb5fca35..04ba9a7ebe 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
@@ -37,17 +37,17 @@ func (a *Operator) isOperatorUpgradeable(csv *v1alpha1.ClusterServiceVersion) (b
 			return true, nil
 		}
 		logger.Infof("Upgradeable condition is overridden to false: %s", o.Message)
-		return false, fmt.Errorf("The operator is not upgradeable: %s", o.Message)
+		return false, fmt.Errorf("the operator is not upgradeable: %s", o.Message)
 	}
 
 	// Check for OperatorUpgradeable condition status
 	if c := meta.FindStatusCondition(cond.Status.Conditions, operatorsv2.Upgradeable); c != nil {
 		if c.ObservedGeneration != cond.ObjectMeta.Generation {
 			logger.Debugf("Upgradeable condition's generation doesn't match: %d/%d", c.ObservedGeneration, cond.ObjectMeta.Generation)
-			return false, fmt.Errorf("The operatorcondition status %q=%q is outdated", c.Type, c.Status)
+			return false, fmt.Errorf("the operatorcondition status %q=%q is outdated", c.Type, c.Status)
 		}
 		if c.Status == metav1.ConditionFalse {
-			return false, fmt.Errorf("The operator is not upgradeable: %s", c.Message)
+			return false, fmt.Errorf("the operator is not upgradeable: %s", c.Message)
 		}
 	}
 
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
index f308c6af9a..e7ca97a4ce 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
@@ -264,7 +264,7 @@ func (a *Operator) annotateCSVs(group *v1.OperatorGroup, targetNamespaces []stri
 		}
 		logger := logger.WithField("csv", csv.GetName())
 
-		originalNamespacesAnnotation, _ := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey]
+		originalNamespacesAnnotation := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey]
 		originalNamespaceSet := NewNamespaceSetFromString(originalNamespacesAnnotation)
 
 		if a.operatorGroupAnnotationsDiffer(&csv.ObjectMeta, group) {
@@ -367,7 +367,6 @@ func (a *Operator) pruneProvidedAPIs(group *v1.OperatorGroup, groupProvidedAPIs
 			logger.WithError(err).Warn("could not update provided api annotations")
 		}
 	}
-	return
 }
 
 // ensureProvidedAPIClusterRole ensures that a clusterrole exists (admin, edit, or view) for a single provided API Type
@@ -391,7 +390,10 @@ func (a *Operator) ensureProvidedAPIClusterRole(namePrefix, suffix string, verbs
 	}
 
 	existingCR, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name)
-	if existingCR == nil {
+	if err != nil && !k8serrors.IsNotFound(err) {
+		return err
+	}
+	if k8serrors.IsNotFound(err) {
 		existingCR, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{})
 		if err == nil {
 			return nil
@@ -478,9 +480,7 @@ func (a *Operator) ensureRBACInTargetNamespace(csv *v1alpha1.ClusterServiceVersi
 		logger.Debug("opgroup is global")
 
 		// synthesize cluster permissions to verify rbac
-		for _, p := range strategyDetailsDeployment.Permissions {
-			strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, p)
-		}
+		strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, strategyDetailsDeployment.Permissions...)
 		strategyDetailsDeployment.Permissions = nil
 		permMet, _, err := a.permissionStatus(strategyDetailsDeployment, ruleChecker, corev1.NamespaceAll, csv)
 		if err != nil {
@@ -799,7 +799,6 @@ func (a *Operator) copyToNamespace(prototype *v1alpha1.ClusterServiceVersion, ns
 
 	existing, err := a.copiedCSVLister.ClusterServiceVersions(nsTo).Get(prototype.GetName())
 	if k8serrors.IsNotFound(err) {
-
 		created, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(nsTo).Create(context.TODO(), prototype, metav1.CreateOptions{})
 		if err != nil {
 			return nil, err
@@ -1007,7 +1006,10 @@ func (a *Operator) ensureOpGroupClusterRole(op *v1.OperatorGroup, suffix string,
 	}
 
 	existingRole, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name)
-	if existingRole == nil {
+	if err != nil && !k8serrors.IsNotFound(err) {
+		return err
+	}
+	if k8serrors.IsNotFound(err) {
 		existingRole, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{})
 		if err == nil {
 			return nil
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go
index b41825af91..3c4f6d36da 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/overrides/inject/inject_test.go
@@ -12,36 +12,36 @@ import (
 
 var (
 	defaultEnvVars = []corev1.EnvVar{
-		corev1.EnvVar{
+		{
 			Name:  "HTTP_PROXY",
 			Value: "http://foo.com:8080",
 		},
-		corev1.EnvVar{
+		{
 			Name:  "HTTPS_PROXY",
 			Value: "https://foo.com:443",
 		},
-		corev1.EnvVar{
+		{
 			Name:  "NO_PROXY",
 			Value: "a.com,b.com",
 		},
 	}
 
 	defaultVolumeMounts = []corev1.VolumeMount{
-		corev1.VolumeMount{
+		{
 			Name:      "foo",
 			MountPath: "/bar",
 		},
 	}
 
 	defaultVolumes = []corev1.Volume{
-		corev1.Volume{
+		{
 			Name:         "foo",
 			VolumeSource: corev1.VolumeSource{},
 		},
 	}
 
 	defaultTolerations = []corev1.Toleration{
-		corev1.Toleration{
+		{
 			Key:      "my-toleration-key",
 			Effect:   corev1.TaintEffectNoSchedule,
 			Value:    "my-toleration-value",
@@ -79,15 +79,11 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			// Expected: The container's VolumeMount list remains empty.
 			name: "EmptyVolumeMounts",
 			podSpec: &corev1.PodSpec{
-				Containers: []corev1.Container{
-					corev1.Container{},
-				},
+				Containers: []corev1.Container{},
 			},
 			volumeMounts: []corev1.VolumeMount{},
 			expected: &corev1.PodSpec{
-				Containers: []corev1.Container{
-					corev1.Container{},
-				},
+				Containers: []corev1.Container{},
 			},
 		},
 		{
@@ -95,14 +91,12 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			// Expected: The container contains the injected VolumeMount.
 			name: "WithContainerHasNoVolumeMounts",
 			podSpec: &corev1.PodSpec{
-				Containers: []corev1.Container{
-					corev1.Container{},
-				},
+				Containers: []corev1.Container{{}},
 			},
 			volumeMounts: defaultVolumeMounts,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: defaultVolumeMounts,
 					},
 				},
@@ -114,7 +108,7 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			name: "WithContainerHasVolumeMountsEmptyDefaults",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: defaultVolumeMounts,
 					},
 				},
@@ -122,7 +116,7 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			volumeMounts: []corev1.VolumeMount{},
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: defaultVolumeMounts,
 					},
 				},
@@ -134,9 +128,9 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			name: "WithContainerHasNonOverlappingEnvVar",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: []corev1.VolumeMount{
-							corev1.VolumeMount{
+							{
 								Name:      "bar",
 								MountPath: "/foo",
 							},
@@ -147,13 +141,13 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			volumeMounts: defaultVolumeMounts,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: []corev1.VolumeMount{
-							corev1.VolumeMount{
+							{
 								Name:      "bar",
 								MountPath: "/foo",
 							},
-							corev1.VolumeMount{
+							{
 								Name:      "foo",
 								MountPath: "/bar",
 							},
@@ -169,9 +163,9 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			name: "WithContainerHasOverlappingVolumeMounts",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: []corev1.VolumeMount{
-							corev1.VolumeMount{
+							{
 								Name:      "foo",
 								MountPath: "/barbar",
 							},
@@ -182,9 +176,9 @@ func TestInjectVolumeMountIntoDeployment(t *testing.T) {
 			volumeMounts: defaultVolumeMounts,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						VolumeMounts: []corev1.VolumeMount{
-							corev1.VolumeMount{
+							{
 								Name:      "foo",
 								MountPath: "/bar",
 							},
@@ -254,7 +248,7 @@ func TestInjectVolumeIntoDeployment(t *testing.T) {
 			name: "WithContainerHasNonOverlappingEnvVar",
 			podSpec: &corev1.PodSpec{
 				Volumes: []corev1.Volume{
-					corev1.Volume{
+					{
 						Name:         "bar",
 						VolumeSource: corev1.VolumeSource{},
 					},
@@ -263,11 +257,11 @@ func TestInjectVolumeIntoDeployment(t *testing.T) {
 			volumes: defaultVolumes,
 			expected: &corev1.PodSpec{
 				Volumes: []corev1.Volume{
-					corev1.Volume{
+					{
 						Name:         "bar",
 						VolumeSource: corev1.VolumeSource{},
 					},
-					corev1.Volume{
+					{
 						Name:         "foo",
 						VolumeSource: corev1.VolumeSource{},
 					},
@@ -280,7 +274,7 @@ func TestInjectVolumeIntoDeployment(t *testing.T) {
 			name: "WithContainerHasOverlappingVolumeMounts",
 			podSpec: &corev1.PodSpec{
 				Volumes: []corev1.Volume{
-					corev1.Volume{
+					{
 						Name: "foo",
 					},
 				},
@@ -288,7 +282,7 @@ func TestInjectVolumeIntoDeployment(t *testing.T) {
 			volumes: defaultVolumes,
 			expected: &corev1.PodSpec{
 				Volumes: []corev1.Volume{
-					corev1.Volume{
+					{
 						Name:         "foo",
 						VolumeSource: corev1.VolumeSource{},
 					},
@@ -321,14 +315,12 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			// Expected: All env variable(s) specified are injected.
 			name: "WithContainerHasNoEnvVar",
 			podSpec: &corev1.PodSpec{
-				Containers: []corev1.Container{
-					corev1.Container{},
-				},
+				Containers: []corev1.Container{{}},
 			},
 			envVar: defaultEnvVars,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: defaultEnvVars,
 					},
 				},
@@ -341,9 +333,9 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			name: "WithContainerHasNonOverlappingEnvVar",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
@@ -354,9 +346,9 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			envVar: defaultEnvVars,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: append([]corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
@@ -372,13 +364,13 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			name: "WithContainerHasOverlappingEnvVar",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "bar_value",
 							},
@@ -387,32 +379,32 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 				},
 			},
 			envVar: []corev1.EnvVar{
-				corev1.EnvVar{
+				{
 					Name:  "extra",
 					Value: "extra_value",
 				},
-				corev1.EnvVar{
+				{
 					Name:  "foo",
 					Value: "new_foo_value",
 				},
-				corev1.EnvVar{
+				{
 					Name:  "bar",
 					Value: "new_bar_value",
 				},
 			},
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "new_foo_value",
 							},
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "new_bar_value",
 							},
-							corev1.EnvVar{
+							{
 								Name:  "extra",
 								Value: "extra_value",
 							},
@@ -428,13 +420,13 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			name: "WithContainerEnvVarBeingUnset",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "bar_value",
 							},
@@ -443,20 +435,20 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 				},
 			},
 			envVar: []corev1.EnvVar{
-				corev1.EnvVar{
+				{
 					Name:  "bar",
 					Value: "",
 				},
 			},
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "",
 							},
@@ -472,18 +464,18 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			name: "WithMultipleContainers",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{},
-					corev1.Container{
+					{},
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
 						},
 					},
-					corev1.Container{
+					{
 						Env: []corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "bar_value",
 							},
@@ -494,20 +486,20 @@ func TestInjectEnvIntoDeployment(t *testing.T) {
 			envVar: defaultEnvVars,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Env: defaultEnvVars,
 					},
-					corev1.Container{
+					{
 						Env: append([]corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "foo",
 								Value: "foo_value",
 							},
 						}, defaultEnvVars...),
 					},
-					corev1.Container{
+					{
 						Env: append([]corev1.EnvVar{
-							corev1.EnvVar{
+							{
 								Name:  "bar",
 								Value: "bar_value",
 							},
@@ -567,7 +559,7 @@ func TestInjectTolerationsIntoDeployment(t *testing.T) {
 			name: "WithDeploymentHasOneNonOverlappingToleration",
 			podSpec: &corev1.PodSpec{
 				Tolerations: []corev1.Toleration{
-					corev1.Toleration{
+					{
 						Key:      "my-different-toleration-key",
 						Operator: corev1.TolerationOpExists,
 					},
@@ -576,7 +568,7 @@ func TestInjectTolerationsIntoDeployment(t *testing.T) {
 			tolerations: defaultTolerations,
 			expected: &corev1.PodSpec{
 				Tolerations: append([]corev1.Toleration{
-					corev1.Toleration{
+					{
 						Key:      "my-different-toleration-key",
 						Operator: corev1.TolerationOpExists,
 					},
@@ -601,21 +593,21 @@ func TestInjectTolerationsIntoDeployment(t *testing.T) {
 			name: "WithDeploymentHasOverlappingAndNonOverlappingTolerations",
 			podSpec: &corev1.PodSpec{
 				Tolerations: []corev1.Toleration{
-					corev1.Toleration{
+					{
 						Key:      "my-different-toleration-key",
 						Operator: corev1.TolerationOpExists,
 					},
 				},
 			},
 			tolerations: append([]corev1.Toleration{
-				corev1.Toleration{
+				{
 					Key:      "my-different-toleration-key",
 					Operator: corev1.TolerationOpExists,
 				},
 			}, defaultTolerations...),
 			expected: &corev1.PodSpec{
 				Tolerations: append([]corev1.Toleration{
-					corev1.Toleration{
+					{
 						Key:      "my-different-toleration-key",
 						Operator: corev1.TolerationOpExists,
 					},
@@ -649,7 +641,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			name: "WithNilResources",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: defaultResources,
 					},
 				},
@@ -657,7 +649,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			resources: nil,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: defaultResources,
 					},
 				},
@@ -669,7 +661,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			name: "WithDeploymentHasNoResources",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: corev1.ResourceRequirements{},
 					},
 				},
@@ -677,7 +669,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			resources: &defaultResources,
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: defaultResources,
 					},
 				},
@@ -690,7 +682,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			name: "WithDeploymentHasResources",
 			podSpec: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: defaultResources,
 					},
 				},
@@ -698,7 +690,7 @@ func TestInjectResourcesIntoDeployment(t *testing.T) {
 			resources: &corev1.ResourceRequirements{},
 			expected: &corev1.PodSpec{
 				Containers: []corev1.Container{
-					corev1.Container{
+					{
 						Resources: corev1.ResourceRequirements{},
 					},
 				},
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/requirements_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/requirements_test.go
index ac9c6df692..e3712d695d 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/olm/requirements_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/olm/requirements_test.go
@@ -948,7 +948,7 @@ func TestMinKubeVersionStatus(t *testing.T) {
 		namespace,
 		"0.0.0",
 		"",
-		v1alpha1.NamedInstallStrategy{"deployment", v1alpha1.StrategyDetailsDeployment{}},
+		v1alpha1.NamedInstallStrategy{StrategyName: "deployment", StrategySpec: v1alpha1.StrategyDetailsDeployment{}},
 		nil,
 		nil,
 		v1alpha1.CSVPhasePending,
@@ -974,7 +974,7 @@ func TestMinKubeVersionStatus(t *testing.T) {
 			minKubeVersion: "0.0.0",
 			expectedMet:    true,
 			expectedRequirementStatuses: []v1alpha1.RequirementStatus{
-				v1alpha1.RequirementStatus{
+				{
 					Status:  v1alpha1.RequirementStatusReasonPresent,
 					Message: fmt.Sprintf("CSV minKubeVersion (%s) less than server version", "0.0.0"),
 					Group:   "operators.coreos.com",
@@ -990,7 +990,7 @@ func TestMinKubeVersionStatus(t *testing.T) {
 			minKubeVersion: "999.999.999",
 			expectedMet:    false,
 			expectedRequirementStatuses: []v1alpha1.RequirementStatus{
-				v1alpha1.RequirementStatus{
+				{
 					Status:  v1alpha1.RequirementStatusReasonPresentNotSatisfied,
 					Message: fmt.Sprintf("CSV version requirement not met: minKubeVersion (%s)", "999.999.999"),
 					Group:   "operators.coreos.com",
@@ -1006,7 +1006,7 @@ func TestMinKubeVersionStatus(t *testing.T) {
 			minKubeVersion: "a.b.c",
 			expectedMet:    false,
 			expectedRequirementStatuses: []v1alpha1.RequirementStatus{
-				v1alpha1.RequirementStatus{
+				{
 					Status:  v1alpha1.RequirementStatusReasonPresentNotSatisfied,
 					Message: "CSV version parsing error",
 					Group:   "operators.coreos.com",
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/clusteroperator_controller_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/clusteroperator_controller_test.go
index 16b23113e1..724628192f 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/clusteroperator_controller_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/clusteroperator_controller_test.go
@@ -85,7 +85,7 @@ var _ = Describe("ClusterOperator controller", func() {
 	})
 
 	It("should ensure the ClusterOperator always exists", func() {
-		By("initally creating it")
+		By("initially creating it")
 		co := &configv1.ClusterOperator{}
 		Eventually(func() error {
 			return k8sClient.Get(ctx, clusterOperatorName, co)
@@ -156,7 +156,7 @@ var _ = Describe("ClusterOperator controller", func() {
 			Type:               configv1.OperatorUpgradeable,
 			Status:             configv1.ConditionFalse,
 			Reason:             ErrorCheckingOperatorCompatibility,
-			Message:            "Encountered errors while checking compatibility with the next minor version of OpenShift: Desired release version missing from ClusterVersion",
+			Message:            "Encountered errors while checking compatibility with the next minor version of OpenShift: desired release version missing from ClusterVersion",
 			LastTransitionTime: fixedNow(),
 		}))
 
@@ -296,7 +296,7 @@ var _ = Describe("ClusterOperator controller", func() {
 				{
 					namespace: ns.GetName(),
 					name:      incompatible.GetName(),
-					err:       fmt.Errorf(`Failed to parse "garbage" as semver: %w`, parseErr),
+					err:       fmt.Errorf(`failed to parse "garbage" as semver: %w`, parseErr),
 				},
 			}.String(),
 			LastTransitionTime: fixedNow(),
@@ -320,7 +320,7 @@ var _ = Describe("ClusterOperator controller", func() {
 				{
 					namespace: ns.GetName(),
 					name:      incompatible.GetName(),
-					err:       fmt.Errorf(`Defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty),
+					err:       fmt.Errorf(`defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty),
 				},
 			}.String(),
 			LastTransitionTime: fixedNow(),
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
index f75f001e4f..22ae894a32 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
@@ -27,12 +27,6 @@ func stripObject(obj client.Object) {
 	obj.SetUID("")
 }
 
-func watchNamespace(namespace *string) predicate.Funcs {
-	return predicate.NewPredicateFuncs(func(object client.Object) bool {
-		return object.GetNamespace() == *namespace
-	})
-}
-
 func watchName(name *string) predicate.Funcs {
 	return predicate.NewPredicateFuncs(func(object client.Object) bool {
 		return object.GetName() == *name
@@ -58,7 +52,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo
 
 	counts := map[configv1.OperandVersion]int{}
 	for _, av := range a {
-		counts[av] += 1
+		counts[av]++
 	}
 
 	for _, bv := range b {
@@ -72,7 +66,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo
 			continue
 		}
 
-		counts[bv] -= 1
+		counts[bv]--
 	}
 
 	return len(counts) < 1
@@ -132,7 +126,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 
 	if desired == nil {
 		// Note: This shouldn't happen
-		return nil, fmt.Errorf("Failed to determine current OpenShift Y-stream release")
+		return nil, fmt.Errorf("failed to determine current OpenShift Y-stream release")
 	}
 
 	next, err := nextY(*desired)
@@ -142,7 +136,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 
 	csvList := &operatorsv1alpha1.ClusterServiceVersionList{}
 	if err := cli.List(ctx, csvList); err != nil {
-		return nil, &transientError{fmt.Errorf("Failed to list ClusterServiceVersions: %w", err)}
+		return nil, &transientError{fmt.Errorf("failed to list ClusterServiceVersions: %w", err)}
 	}
 
 	var incompatible skews
@@ -177,18 +171,18 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 func desiredRelease(ctx context.Context, cli client.Client) (*semver.Version, error) {
 	cv := configv1.ClusterVersion{}
 	if err := cli.Get(ctx, client.ObjectKey{Name: "version"}, &cv); err != nil { // "version" is the name of OpenShift's ClusterVersion singleton
-		return nil, &transientError{fmt.Errorf("Failed to get ClusterVersion: %w", err)}
+		return nil, &transientError{fmt.Errorf("failed to get ClusterVersion: %w", err)}
 	}
 
 	v := cv.Status.Desired.Version
 	if v == "" {
 		// The release version hasn't been set yet
-		return nil, fmt.Errorf("Desired release version missing from ClusterVersion")
+		return nil, fmt.Errorf("desired release version missing from ClusterVersion")
 	}
 
 	desired, err := semver.ParseTolerant(v)
 	if err != nil {
-		return nil, fmt.Errorf("ClusterVersion has invalid desired release version: %w", err)
+		return nil, fmt.Errorf("cluster version has invalid desired release version: %w", err)
 	}
 
 	return &desired, nil
@@ -231,7 +225,7 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver.
 		}
 
 		if max != nil {
-			return nil, fmt.Errorf(`Defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty)
+			return nil, fmt.Errorf(`defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty)
 		}
 
 		max = &property.Value
@@ -245,12 +239,12 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver.
 	value := strings.Trim(*max, "\"")
 	if value == "" {
 		// Handle "" separately, so parse doesn't treat it as a zero
-		return nil, fmt.Errorf(`Value cannot be "" (an empty string)`)
+		return nil, fmt.Errorf(`value cannot be "" (an empty string)`)
 	}
 
 	version, err := semver.ParseTolerant(value)
 	if err != nil {
-		return nil, fmt.Errorf(`Failed to parse "%s" as semver: %w`, value, err)
+		return nil, fmt.Errorf(`failed to parse "%s" as semver: %w`, value, err)
 	}
 
 	truncatedVersion := semver.Version{Major: version.Major, Minor: version.Minor}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers_test.go
index 71c908392c..653620f804 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers_test.go
@@ -414,7 +414,7 @@ func TestIncompatibleOperators(t *testing.T) {
 					{
 						name:      "chestnut",
 						namespace: "default",
-						err: fmt.Errorf(`Failed to parse "bad_version" as semver: %w`, func() error {
+						err: fmt.Errorf(`failed to parse "bad_version" as semver: %w`, func() error {
 							_, err := semver.ParseTolerant("bad_version")
 							return err
 						}()),
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
index e5b0a4b64a..552dee99c9 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
@@ -51,10 +51,10 @@ func (c *ReconcilerConfig) apply(opts []ReconcilerOption) {
 
 func (c *ReconcilerConfig) complete() error {
 	if c.Client == nil {
-		return fmt.Errorf("No client specified")
+		return fmt.Errorf("no client specified")
 	}
 	if c.Name == "" {
-		return fmt.Errorf("No ClusterOperator name specified")
+		return fmt.Errorf("no ClusterOperator name specified")
 	}
 	if c.Log == nil {
 		c.Log = ctrl.Log.WithName(c.Name)
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/suite_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/suite_test.go
index 4d932c3ded..7c1018cef4 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/suite_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/suite_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/operator-framework/api/crds"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/rest"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/envtest"
@@ -33,7 +32,6 @@ func TestControllers(t *testing.T) {
 
 var (
 	testEnv   *envtest.Environment
-	cfg       *rest.Config
 	k8sClient client.Client
 	ctx       context.Context
 	fixedNow  NowFunc
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
index 0583945ec4..84d4a9591b 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
@@ -38,7 +38,6 @@ func (s *SyncTracker) Start(ctx context.Context) error {
 	})
 
 	return err
-
 }
 
 func (s *SyncTracker) start(ctx context.Context) error {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker_test.go b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker_test.go
index d70138dc0c..3064f1d4cc 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker_test.go
@@ -43,7 +43,7 @@ func TestSyncCount(t *testing.T) {
 		}()
 
 		go func() {
-			err := fmt.Errorf("failure!")
+			err := fmt.Errorf("failure")
 			f := uint(failed)
 			s := uint(successful)
 			for f > 0 || s > 0 {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go b/staging/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
index 62aa4e2d06..31d5c92c34 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
@@ -159,7 +159,6 @@ func (r *OperatorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	if err = r.updateComponents(ctx, operator); err != nil {
 		log.Error(err, "Could not update components")
 		return reconcile.Result{Requeue: true}, nil
-
 	}
 
 	if create {
@@ -205,7 +204,7 @@ func (r *OperatorReconciler) listComponents(ctx context.Context, selector labels
 	for _, list := range componentLists {
 		cList, ok := list.(client.ObjectList)
 		if !ok {
-			return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList")
+			return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList")
 		}
 		if err := r.List(ctx, cList, opt); err != nil {
 			return nil, err
@@ -233,7 +232,7 @@ func (r *OperatorReconciler) hasExistingComponents(ctx context.Context, name str
 	for _, list := range components {
 		items, err := meta.ExtractList(list)
 		if err != nil {
-			return false, fmt.Errorf("Unable to extract list from runtime.Object")
+			return false, fmt.Errorf("unable to extract list from runtime.Object")
 		}
 		if len(items) > 0 {
 			return true, nil
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/grpc/source_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/grpc/source_test.go
index ed9d957f64..1c06b0b19e 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/grpc/source_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/grpc/source_test.go
@@ -3,8 +3,9 @@ package grpc
 
 import (
 	"context"
-	"fmt"
 	"net"
+	"net/url"
+	"os"
 	"sync"
 	"testing"
 	"time"
@@ -23,7 +24,7 @@ import (
 )
 
 func server(store opregistry.Query) (func(), string, func()) {
-	lis, err := net.Listen("tcp", fmt.Sprintf("localhost:"))
+	lis, err := net.Listen("tcp", "localhost:")
 	if err != nil {
 		logrus.Fatalf("failed to listen: %v", err)
 	}
@@ -59,7 +60,7 @@ func (f *FakeSourceSyncer) sync(state SourceState) {
 		f.History[state.Key] = []connectivity.State{}
 	}
 	f.History[state.Key] = append(f.History[state.Key], state.State)
-	f.expectedEvents -= 1
+	f.expectedEvents--
 	if f.expectedEvents == 0 {
 		f.done <- struct{}{}
 	}
@@ -124,7 +125,7 @@ func TestConnectionEvents(t *testing.T) {
 		{
 			name: "Basic",
 			expectedHistory: map[registry.CatalogKey][]connectivity.State{
-				registry.CatalogKey{Name: "test", Namespace: "test"}: {
+				{Name: "test", Namespace: "test"}: {
 					connectivity.Connecting,
 					connectivity.Ready,
 				},
@@ -133,11 +134,11 @@ func TestConnectionEvents(t *testing.T) {
 		{
 			name: "Multiple",
 			expectedHistory: map[registry.CatalogKey][]connectivity.State{
-				registry.CatalogKey{Name: "test", Namespace: "test"}: {
+				{Name: "test", Namespace: "test"}: {
 					connectivity.Connecting,
 					connectivity.Ready,
 				},
-				registry.CatalogKey{Name: "test2", Namespace: "test2"}: {
+				{Name: "test2", Namespace: "test2"}: {
 					connectivity.Connecting,
 					connectivity.Ready,
 				},
@@ -149,3 +150,244 @@ func TestConnectionEvents(t *testing.T) {
 		t.Run(tt.name, test(tt))
 	}
 }
+
+func TestGetEnvAny(t *testing.T) {
+	type envVar struct {
+		key   string
+		value string
+	}
+
+	type testcase struct {
+		name          string
+		envVars       []envVar
+		expectedValue string
+	}
+
+	test := func(tt testcase) func(t *testing.T) {
+		return func(t *testing.T) {
+			for _, envVar := range tt.envVars {
+				os.Setenv(envVar.key, envVar.value)
+			}
+
+			defer func() {
+				for _, envVar := range tt.envVars {
+					os.Setenv(envVar.key, "")
+				}
+			}()
+
+			require.Equal(t, getEnvAny("NO_PROXY", "no_proxy"), tt.expectedValue)
+		}
+	}
+
+	cases := []testcase{
+		{
+			name:          "NotFound",
+			expectedValue: "",
+		},
+		{
+			name: "LowerCaseFound",
+			envVars: []envVar{
+				{
+					key:   "no_proxy",
+					value: "foo",
+				},
+			},
+			expectedValue: "foo",
+		},
+		{
+			name: "UpperCaseFound",
+			envVars: []envVar{
+				{
+					key:   "NO_PROXY",
+					value: "bar",
+				},
+			},
+			expectedValue: "bar",
+		},
+		{
+			name: "OrderPreference",
+			envVars: []envVar{
+				{
+					key:   "no_proxy",
+					value: "foo",
+				},
+				{
+					key:   "NO_PROXY",
+					value: "bar",
+				},
+			},
+			expectedValue: "bar",
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, test(tt))
+	}
+}
+
+func TestGetGRPCProxyEnv(t *testing.T) {
+	type envVar struct {
+		key   string
+		value string
+	}
+
+	type testcase struct {
+		name          string
+		envVars       []envVar
+		expectedValue string
+	}
+
+	test := func(tt testcase) func(t *testing.T) {
+		return func(t *testing.T) {
+			for _, envVar := range tt.envVars {
+				os.Setenv(envVar.key, envVar.value)
+			}
+
+			defer func() {
+				for _, envVar := range tt.envVars {
+					os.Setenv(envVar.key, "")
+				}
+			}()
+
+			require.Equal(t, getGRPCProxyEnv(), tt.expectedValue)
+		}
+	}
+
+	cases := []testcase{
+		{
+			name:          "NotFound",
+			expectedValue: "",
+		},
+		{
+			name: "LowerCaseFound",
+			envVars: []envVar{
+				{
+					key:   "grpc_proxy",
+					value: "foo",
+				},
+			},
+			expectedValue: "foo",
+		},
+		{
+			name: "UpperCaseFound",
+			envVars: []envVar{
+				{
+					key:   "GRPC_PROXY",
+					value: "bar",
+				},
+			},
+			expectedValue: "bar",
+		},
+		{
+			name: "UpperCasePreference",
+			envVars: []envVar{
+				{
+					key:   "grpc_proxy",
+					value: "foo",
+				},
+				{
+					key:   "GRPC_PROXY",
+					value: "bar",
+				},
+			},
+			expectedValue: "bar",
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, test(tt))
+	}
+}
+
+func TestGRPCProxyURL(t *testing.T) {
+	type envVar struct {
+		key   string
+		value string
+	}
+
+	type testcase struct {
+		name          string
+		address       string
+		envVars       []envVar
+		expectedProxy string
+		expectedError error
+	}
+
+	test := func(tt testcase) func(t *testing.T) {
+		return func(t *testing.T) {
+			for _, envVar := range tt.envVars {
+				os.Setenv(envVar.key, envVar.value)
+			}
+
+			defer func() {
+				for _, envVar := range tt.envVars {
+					os.Setenv(envVar.key, "")
+				}
+			}()
+
+			var expectedProxyURL *url.URL
+			var err error
+			if tt.expectedProxy != "" {
+				expectedProxyURL, err = url.Parse(tt.expectedProxy)
+				require.NoError(t, err)
+			}
+
+			proxyURL, err := grpcProxyURL(tt.address)
+			require.Equal(t, expectedProxyURL, proxyURL)
+			require.Equal(t, tt.expectedError, err)
+		}
+	}
+
+	cases := []testcase{
+		{
+			name:          "NoGRPCProxySet",
+			address:       "foo.com:8080",
+			expectedProxy: "",
+			expectedError: nil,
+		},
+		{
+			name:    "GRPCProxyFoundForAddress",
+			address: "foo.com:8080",
+			envVars: []envVar{
+				{
+					key:   "GRPC_PROXY",
+					value: "http://my-proxy:8080",
+				},
+			},
+			expectedProxy: "http://my-proxy:8080",
+			expectedError: nil,
+		},
+		{
+			name:    "GRPCNoProxyIncludesAddress",
+			address: "foo.com:8080",
+			envVars: []envVar{
+				{
+					key:   "GRPC_PROXY",
+					value: "http://my-proxy:8080",
+				},
+				{
+					key:   "NO_PROXY",
+					value: "foo.com:8080",
+				},
+			},
+			expectedProxy: "",
+			expectedError: nil,
+		},
+		{
+			name:          "MissingPort",
+			address:       "foo.com",
+			expectedProxy: "",
+			expectedError: error(&net.AddrError{Err: "missing port in address", Addr: "foo.com"}),
+		},
+		{
+			name:          "TooManyColons",
+			address:       "http://bar.com:8080",
+			expectedProxy: "",
+			expectedError: error(&net.AddrError{Err: "too many colons in address", Addr: "http://bar.com:8080"}),
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, test(tt))
+	}
+}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go
index ced4b9115c..ddd0218661 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/configmap_test.go
@@ -60,12 +60,6 @@ func withK8sClientOptions(options ...clientfake.Option) fakeReconcilerOption {
 	}
 }
 
-func withConfigMapServerImage(configMapServerImage string) fakeReconcilerOption {
-	return func(config *fakeReconcilerConfig) {
-		config.configMapServerImage = configMapServerImage
-	}
-}
-
 func fakeReconcilerFactory(t *testing.T, stopc <-chan struct{}, options ...fakeReconcilerOption) (RegistryReconcilerFactory, operatorclient.ClientInterface) {
 	config := &fakeReconcilerConfig{
 		now:                  metav1.Now,
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go
index 6ac3406487..ef55a856d1 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/reconciler/grpc_test.go
@@ -362,7 +362,6 @@ func TestGrpcRegistryReconciler(t *testing.T) {
 				require.NoError(t, err)
 				require.True(t, k8serrors.IsNotFound(serviceErr))
 			}
-
 		})
 	}
 }
@@ -581,7 +580,6 @@ func TestGrpcRegistryChecker(t *testing.T) {
 			}
 
 			require.Equal(t, tt.out.healthy, healthy)
-
 		})
 	}
 }
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/registry_client.go b/staging/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
index fe9e2b6a3a..57a974bc63 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
@@ -88,7 +88,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki
 	}
 	entry := rc.filterChannelEntries(ctx, it, excludedPackages)
 	if entry == nil {
-		return nil, fmt.Errorf("Unable to find a channel entry that satisfies the requirements")
+		return nil, fmt.Errorf("unable to find a channel entry that satisfies the requirements")
 	}
 	bundle, err := rc.Client.Registry.GetBundle(ctx, &registryapi.GetBundleRequest{PkgName: entry.PackageName, ChannelName: entry.ChannelName, CsvName: entry.BundleName})
 	if err != nil {
@@ -101,7 +101,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki
 // API and come from the same package with original operator and returns the
 // first entry on the list from the default channel of that package
 func (rc *Client) filterChannelEntries(ctx context.Context, it *ChannelEntryIterator, excludedPackages map[string]struct{}) *opregistry.ChannelEntry {
-	defChannels := make(map[string]string, 0)
+	defChannels := make(map[string]string)
 
 	var entries []*opregistry.ChannelEntry
 	for e := it.Next(); e != nil; e = it.Next() {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
index e719265ff4..240f647dd8 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
@@ -85,8 +85,6 @@ type Cache struct {
 	m            sync.RWMutex
 }
 
-type catalogSourcePriority int
-
 var _ OperatorCacheProvider = &Cache{}
 
 type Option func(*Cache)
@@ -402,13 +400,13 @@ func (s sortableSnapshots) Swap(i, j int) {
 	s.snapshots[i], s.snapshots[j] = s.snapshots[j], s.snapshots[i]
 }
 
-func (s *snapshotHeader) Find(p ...Predicate) []*Entry {
-	s.m.RLock()
-	defer s.m.RUnlock()
-	if s.snapshot == nil {
+func (hdr *snapshotHeader) Find(p ...Predicate) []*Entry {
+	hdr.m.RLock()
+	defer hdr.m.RUnlock()
+	if hdr.snapshot == nil {
 		return nil
 	}
-	return Filter(s.snapshot.Entries, p...)
+	return Filter(hdr.snapshot.Entries, p...)
 }
 
 type OperatorFinder interface {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache_test.go
index 766362dcab..639945bc43 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache_test.go
@@ -166,7 +166,6 @@ func TestCatalogSnapshotValid(t *testing.T) {
 			assert.Equal(t, tt.Expected, s.Valid(tt.At))
 		})
 	}
-
 }
 
 func TestCatalogSnapshotFind(t *testing.T) {
@@ -235,7 +234,6 @@ func TestCatalogSnapshotFind(t *testing.T) {
 			assert.Equal(t, tt.Expected, s.Find(tt.Predicate))
 		})
 	}
-
 }
 
 type ErrorSource struct {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
index 8e09d5dad4..681c074735 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
@@ -106,9 +106,7 @@ func (s APISet) Intersection(sets ...APISet) APISet {
 func (s APISet) Difference(set APISet) APISet {
 	difference := make(APISet).Union(s)
 	for api := range set {
-		if _, ok := difference[api]; ok {
-			delete(difference, api)
-		}
+		delete(difference, api)
 	}
 
 	return difference
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
index 037af4207d..73866ebbf1 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
@@ -235,7 +235,7 @@ func And(p ...Predicate) Predicate {
 
 func (p andPredicate) Test(o *Entry) bool {
 	for _, predicate := range p.predicates {
-		if predicate.Test(o) == false {
+		if !predicate.Test(o) {
 			return false
 		}
 	}
@@ -265,7 +265,7 @@ type orPredicate struct {
 
 func (p orPredicate) Test(o *Entry) bool {
 	for _, predicate := range p.predicates {
-		if predicate.Test(o) == true {
+		if predicate.Test(o) {
 			return true
 		}
 	}
@@ -295,7 +295,7 @@ type notPredicate struct {
 
 func (p notPredicate) Test(o *Entry) bool {
 	// !pred && !pred is equivalent to !(pred || pred).
-	return !orPredicate{p.predicates}.Test(o)
+	return !orPredicate(p).Test(o)
 }
 
 func (p notPredicate) String() string {
@@ -323,9 +323,9 @@ func (b booleanPredicate) Test(o *Entry) bool {
 
 func (b booleanPredicate) String() string {
 	if b.result {
-		return fmt.Sprintf("predicate is true")
+		return "predicate is true"
 	}
-	return fmt.Sprintf("predicate is false")
+	return "predicate is false"
 }
 
 func True() Predicate {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go
new file mode 100644
index 0000000000..aaa98e64c4
--- /dev/null
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go
@@ -0,0 +1,9 @@
+package resolver
+
+// stepResolverInitHook provides a way for the downstream
+// to modify the step resolver at creation time.
+// This is a bit of a hack to enable system constraints downstream
+// without affecting the upstream. We may want to clean this up when
+// either we have a more pluggable architecture; or system constraints
+// come to the upstream
+type stepResolverInitHook func(*OperatorStepResolver) error
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
index 580e3c7a32..1abd16ed71 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
@@ -40,7 +40,7 @@ func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey,
 	info := strings.Split(i.identifier.String(), "/")
 	// This should be enforced by Kube naming constraints
 	if len(info) != 4 {
-		return "", "", cache.SourceKey{}, fmt.Errorf("Unable to parse identifier %s for source info", i.identifier)
+		return "", "", cache.SourceKey{}, fmt.Errorf("unable to parse identifier %s for source info", i.identifier)
 	}
 	catalog := cache.SourceKey{
 		Name:      info[0],
@@ -51,7 +51,7 @@ func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey,
 	return csvName, channel, catalog, nil
 }
 
-func bundleId(bundle, channel string, catalog cache.SourceKey) solver.Identifier {
+func bundleID(bundle, channel string, catalog cache.SourceKey) solver.Identifier {
 	return solver.IdentifierFromString(fmt.Sprintf("%s/%s/%s", catalog.String(), channel, bundle))
 }
 
@@ -59,7 +59,7 @@ func NewBundleInstallableFromOperator(o *cache.Entry) (BundleInstallable, error)
 	if o.SourceInfo == nil {
 		return BundleInstallable{}, fmt.Errorf("unable to resolve the source of bundle %s", o.Name)
 	}
-	id := bundleId(o.Name, o.Channel(), o.SourceInfo.Catalog)
+	id := bundleID(o.Name, o.Channel(), o.SourceInfo.Catalog)
 	var constraints []solver.Constraint
 	if o.SourceInfo.Catalog.Virtual() && o.SourceInfo.Subscription == nil {
 		// CSVs already associated with a Subscription
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
index 453ae4a0b8..abbb938597 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
@@ -27,9 +27,9 @@ func (ir *InstrumentedResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step
 	start := time.Now()
 	steps, lookups, subs, err := ir.resolver.ResolveSteps(namespace)
 	if err != nil {
-		ir.failureMetricsEmitter(time.Now().Sub(start))
+		ir.failureMetricsEmitter(time.Since(start))
 	} else {
-		ir.successMetricsEmitter(time.Now().Sub(start))
+		ir.successMetricsEmitter(time.Since(start))
 	}
 	return steps, lookups, subs, err
 }
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver_test.go
index 3b0aa0d59a..a0b76d4257 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver_test.go
@@ -13,7 +13,6 @@ import (
 const (
 	failure = time.Duration(0)
 	success = time.Duration(1)
-	reset   = time.Duration(99999)
 )
 
 type fakeResolverWithError struct{}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
index 4905aa3765..4b2f868d61 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
@@ -26,9 +26,10 @@ type OperatorResolver interface {
 }
 
 type SatResolver struct {
-	cache cache.OperatorCacheProvider
-	log   logrus.FieldLogger
-	pc    *predicateConverter
+	cache                     cache.OperatorCacheProvider
+	log                       logrus.FieldLogger
+	pc                        *predicateConverter
+	systemConstraintsProvider solver.ConstraintProvider
 }
 
 func NewDefaultSatResolver(rcp cache.SourceProvider, catsrcLister v1alpha1listers.CatalogSourceLister, logger logrus.FieldLogger) *SatResolver {
@@ -54,8 +55,8 @@ func (w *debugWriter) Write(b []byte) (int, error) {
 func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription) (cache.OperatorSet, error) {
 	var errs []error
 
-	installables := make(map[solver.Identifier]solver.Installable, 0)
-	visited := make(map[*cache.Entry]*BundleInstallable, 0)
+	installables := make(map[solver.Identifier]solver.Installable)
+	visited := make(map[*cache.Entry]*BundleInstallable)
 
 	// TODO: better abstraction
 	startingCSVs := make(map[string]struct{})
@@ -145,7 +146,7 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 		}
 	}
 
-	operators := make(map[string]*cache.Entry, 0)
+	operators := make(map[string]*cache.Entry)
 	for _, installableOperator := range operatorInstallables {
 		csvName, channel, catalog, err := installableOperator.BundleSourceInfo()
 		if err != nil {
@@ -177,9 +178,28 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 	return operators, nil
 }
 
+// newBundleInstallableFromEntry converts an entry into a bundle installable with
+// system constraints applied, if they are defined for the entry
+func (r *SatResolver) newBundleInstallableFromEntry(entry *cache.Entry) (*BundleInstallable, error) {
+	bundleInstalleble, err := NewBundleInstallableFromOperator(entry)
+	if err != nil {
+		return nil, err
+	}
+
+	// apply system constraints if necessary
+	if r.systemConstraintsProvider != nil && !(entry.SourceInfo.Catalog.Virtual()) {
+		systemConstraints, err := r.systemConstraintsProvider.Constraints(entry)
+		if err != nil {
+			return nil, err
+		}
+		bundleInstalleble.constraints = append(bundleInstalleble.constraints, systemConstraints...)
+	}
+	return &bundleInstalleble, nil
+}
+
 func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, current *cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]solver.Installable, error) {
 	var cachePredicates, channelPredicates []cache.Predicate
-	installables := make(map[solver.Identifier]solver.Installable, 0)
+	installables := make(map[solver.Identifier]solver.Installable)
 
 	catalog := cache.SourceKey{
 		Name:      sub.Spec.CatalogSource,
@@ -296,12 +316,12 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 			// safe to remove this conflict if properties
 			// annotations are made mandatory for
 			// resolution.
-			c.AddConflict(bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
+			c.AddConflict(bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
 		}
 		depIds = append(depIds, c.Identifier())
 	}
 	if current != nil {
-		depIds = append(depIds, bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
+		depIds = append(depIds, bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
 	}
 
 	// all candidates added as options for this constraint
@@ -313,7 +333,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 
 func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleStack []*cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleInstallable, error) {
 	errs := make([]error, 0)
-	installables := make(map[solver.Identifier]*BundleInstallable, 0) // all installables, including dependencies
+	installables := make(map[solver.Identifier]*BundleInstallable) // all installables, including dependencies
 
 	// track the first layer of installable ids
 	var initial = make(map[*cache.Entry]struct{})
@@ -334,13 +354,13 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			continue
 		}
 
-		bundleInstallable, err := NewBundleInstallableFromOperator(bundle)
+		bundleInstallable, err := r.newBundleInstallableFromEntry(bundle)
 		if err != nil {
 			errs = append(errs, err)
 			continue
 		}
 
-		visited[bundle] = &bundleInstallable
+		visited[bundle] = bundleInstallable
 
 		dependencyPredicates, err := r.pc.convertDependencyProperties(bundle.Properties)
 		if err != nil {
@@ -389,12 +409,12 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			// (after sorting) to remove all bundles that
 			// don't satisfy the dependency.
 			for _, b := range cache.Filter(sortedBundles, d) {
-				i, err := NewBundleInstallableFromOperator(b)
+				i, err := r.newBundleInstallableFromEntry(b)
 				if err != nil {
 					errs = append(errs, err)
 					continue
 				}
-				installables[i.Identifier()] = &i
+				installables[i.Identifier()] = i
 				bundleDependencies = append(bundleDependencies, i.Identifier())
 				bundleStack = append(bundleStack, b)
 			}
@@ -404,14 +424,14 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			))
 		}
 
-		installables[bundleInstallable.Identifier()] = &bundleInstallable
+		installables[bundleInstallable.Identifier()] = bundleInstallable
 	}
 
 	if len(errs) > 0 {
 		return nil, nil, utilerrors.NewAggregate(errs)
 	}
 
-	ids := make(map[solver.Identifier]struct{}, 0) // immediate installables found via predicates
+	ids := make(map[solver.Identifier]struct{}) // immediate installables found via predicates
 	for o := range initial {
 		ids[visited[o].Identifier()] = struct{}{}
 	}
@@ -449,17 +469,17 @@ func (r *SatResolver) inferProperties(csv *v1alpha1.ClusterServiceVersion, subs
 	if !csv.Spec.Version.Version.Equals(semver.Version{}) {
 		version = csv.Spec.Version.String()
 	}
-	if pp, err := json.Marshal(opregistry.PackageProperty{
+	pp, err := json.Marshal(opregistry.PackageProperty{
 		PackageName: pkg,
 		Version:     version,
-	}); err != nil {
+	})
+	if err != nil {
 		return nil, fmt.Errorf("failed to marshal inferred package property: %w", err)
-	} else {
-		properties = append(properties, &api.Property{
-			Type:  opregistry.PackageType,
-			Value: string(pp),
-		})
 	}
+	properties = append(properties, &api.Property{
+		Type:  opregistry.PackageType,
+		Value: string(pp),
+	})
 
 	return properties, nil
 }
@@ -795,10 +815,8 @@ func (pc *predicateConverter) predicateForConstraintProperty(value string) (cach
 // convertConstraints creates predicates from each element of constraints, recursing on compound constraints.
 // New constraint types added to the constraints package must be handled here.
 func (pc *predicateConverter) convertConstraints(constraints ...constraints.Constraint) ([]cache.Predicate, error) {
-
 	preds := make([]cache.Predicate, len(constraints))
 	for i, constraint := range constraints {
-
 		var err error
 		switch {
 		case constraint.GVK != nil:
@@ -828,7 +846,6 @@ func (pc *predicateConverter) convertConstraints(constraints ...constraints.Cons
 		if err != nil {
 			return nil, err
 		}
-
 	}
 
 	return preds, nil
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver_test.go
index 0002c35522..f48ff19079 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver_test.go
@@ -66,6 +66,109 @@ func TestSolveOperators(t *testing.T) {
 	require.EqualValues(t, expected, operators)
 }
 
+func TestSolveOperators_WithSystemConstraints(t *testing.T) {
+	const namespace = "test-namespace"
+	catalog := cache.SourceKey{Name: "test-catalog", Namespace: namespace}
+
+	packageASub := newSub(namespace, "packageA", "alpha", catalog)
+	packageDSub := existingSub(namespace, "packageD.v1", "packageD", "alpha", catalog)
+
+	APISet := cache.APISet{opregistry.APIKey{Group: "g", Version: "v", Kind: "k", Plural: "ks"}: struct{}{}}
+
+	// packageA requires an API that can be provided by B or C
+	packageA := genOperator("packageA.v1", "0.0.1", "", "packageA", "alpha", catalog.Name, catalog.Namespace, APISet, nil, nil, "", false)
+	packageB := genOperator("packageB.v1", "1.0.0", "", "packageB", "alpha", catalog.Name, catalog.Namespace, nil, APISet, nil, "", false)
+	packageC := genOperator("packageC.v1", "1.0.0", "", "packageC", "alpha", catalog.Name, catalog.Namespace, nil, APISet, nil, "", false)
+
+	// Existing operators
+	packageD := genOperator("packageD.v1", "1.0.0", "", "packageD", "alpha", catalog.Name, catalog.Namespace, nil, nil, nil, "", false)
+	existingPackageD := existingOperator(namespace, "packageD.v1", "packageD", "alpha", "", nil, nil, nil, nil)
+	existingPackageD.Annotations = map[string]string{"operatorframework.io/properties": `{"properties":[{"type":"olm.package","value":{"packageName":"packageD","version":"1.0.0"}}]}`}
+
+	whiteListConstraintProvider := func(whiteList ...*cache.Entry) solver.ConstraintProviderFunc {
+		return func(entry *cache.Entry) ([]solver.Constraint, error) {
+			for _, whiteListedEntry := range whiteList {
+				if whiteListedEntry.Package() == entry.Package() &&
+					whiteListedEntry.Name == entry.Name &&
+					whiteListedEntry.Version == entry.Version {
+					return nil, nil
+				}
+			}
+			return []solver.Constraint{PrettyConstraint(
+				solver.Prohibited(),
+				fmt.Sprintf("package: %s is not white listed", entry.Package()),
+			)}, nil
+		}
+	}
+
+	testCases := []struct {
+		title                     string
+		systemConstraintsProvider solver.ConstraintProvider
+		expectedOperators         cache.OperatorSet
+		csvs                      []*v1alpha1.ClusterServiceVersion
+		subs                      []*v1alpha1.Subscription
+		snapshotEntries           []*cache.Entry
+		err                       string
+	}{
+		{
+			title:                     "No runtime constraints",
+			snapshotEntries:           []*cache.Entry{packageA, packageB, packageC, packageD},
+			systemConstraintsProvider: nil,
+			expectedOperators:         cache.OperatorSet{"packageA.v1": packageA, "packageB.v1": packageB},
+			csvs:                      nil,
+			subs:                      []*v1alpha1.Subscription{packageASub},
+			err:                       "",
+		},
+		{
+			title:                     "Runtime constraints only accept packages A and C",
+			snapshotEntries:           []*cache.Entry{packageA, packageB, packageC, packageD},
+			systemConstraintsProvider: whiteListConstraintProvider(packageA, packageC),
+			expectedOperators:         cache.OperatorSet{"packageA.v1": packageA, "packageC.v1": packageC},
+			csvs:                      nil,
+			subs:                      []*v1alpha1.Subscription{packageASub},
+			err:                       "",
+		},
+		{
+			title:                     "Existing packages are ignored",
+			snapshotEntries:           []*cache.Entry{packageA, packageB, packageC, packageD},
+			systemConstraintsProvider: whiteListConstraintProvider(packageA, packageC),
+			expectedOperators:         cache.OperatorSet{"packageA.v1": packageA, "packageC.v1": packageC},
+			csvs:                      []*v1alpha1.ClusterServiceVersion{existingPackageD},
+			subs:                      []*v1alpha1.Subscription{packageASub, packageDSub},
+			err:                       "",
+		},
+		{
+			title:                     "Runtime constraints don't allow A",
+			snapshotEntries:           []*cache.Entry{packageA, packageB, packageC, packageD},
+			systemConstraintsProvider: whiteListConstraintProvider(),
+			expectedOperators:         nil,
+			csvs:                      nil,
+			subs:                      []*v1alpha1.Subscription{packageASub},
+			err:                       "packageA is not white listed",
+		},
+	}
+
+	for _, testCase := range testCases {
+		satResolver := SatResolver{
+			cache: cache.New(cache.StaticSourceProvider{
+				catalog: &cache.Snapshot{
+					Entries: testCase.snapshotEntries,
+				},
+			}),
+			log:                       logrus.New(),
+			systemConstraintsProvider: testCase.systemConstraintsProvider,
+		}
+		operators, err := satResolver.SolveOperators([]string{namespace}, testCase.csvs, testCase.subs)
+
+		if testCase.err != "" {
+			require.Containsf(t, err.Error(), testCase.err, "Test %s failed", testCase.title)
+		} else {
+			require.NoErrorf(t, err, "Test %s failed", testCase.title)
+		}
+		require.EqualValuesf(t, testCase.expectedOperators, operators, "Test %s failed", testCase.title)
+	}
+}
+
 func TestDisjointChannelGraph(t *testing.T) {
 	const namespace = "test-namespace"
 	catalog := cache.SourceKey{Name: "test-catalog", Namespace: namespace}
@@ -508,7 +611,6 @@ func TestSolveOperators_CatsrcPrioritySorting(t *testing.T) {
 	for k, e := range expected {
 		assert.EqualValues(t, e, operators[k])
 	}
-
 }
 
 func TestSolveOperators_WithPackageDependencies(t *testing.T) {
@@ -630,9 +732,7 @@ func TestSolveOperators_WithLabelDependencies(t *testing.T) {
 	}
 
 	operatorBv1 := genOperator("packageB.v1", "1.0.0", "", "packageB", "beta", "community", "olm", nil, nil, nil, "", false)
-	for _, p := range props {
-		operatorBv1.Properties = append(operatorBv1.Properties, p)
-	}
+	operatorBv1.Properties = append(operatorBv1.Properties, props...)
 
 	satResolver := SatResolver{
 		cache: cache.New(cache.StaticSourceProvider{
@@ -2382,7 +2482,7 @@ func TestNewOperatorFromCSV(t *testing.T) {
 }
 
 func TestSolveOperators_GenericConstraint(t *testing.T) {
-	Provides1 := cache.APISet{opregistry.APIKey{"g", "v", "k", "ks"}: struct{}{}}
+	Provides1 := cache.APISet{opregistry.APIKey{Group: "g", Version: "v", Kind: "k", Plural: "ks"}: struct{}{}}
 	namespace := "olm"
 	catalog := cache.SourceKey{Name: "community", Namespace: namespace}
 
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go
new file mode 100644
index 0000000000..ce119abed4
--- /dev/null
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go
@@ -0,0 +1,19 @@
+package solver
+
+import "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
+
+// ConstraintProvider knows how to provide solver constraints for a given cache entry.
+// For instance, it could be used to surface additional constraints against an entry given some
+// properties it may expose. E.g. olm.maxOpenShiftVersion could be checked against the cluster version
+// and prohibit any entry that doesn't meet the requirement
+type ConstraintProvider interface {
+	// Constraints returns a set of solver constraints for a cache entry.
+	Constraints(e *cache.Entry) ([]Constraint, error)
+}
+
+// ConstraintProviderFunc is a simple implementation of ConstraintProvider
+type ConstraintProviderFunc func(e *cache.Entry) ([]Constraint, error)
+
+func (c ConstraintProviderFunc) Constraints(e *cache.Entry) ([]Constraint, error) {
+	return c(e)
+}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
index dedb5fb8da..ff15346832 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
@@ -31,7 +31,6 @@ type litMapping struct {
 	constraints  map[z.Lit]AppliedConstraint
 	c            *logic.C
 	errs         inconsistentLitMapping
-	buf          []z.Lit
 }
 
 // newLitMapping returns a new litMapping with its state initialized based on
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
index ed84ea9309..363595eca0 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
@@ -26,8 +26,6 @@ type search struct {
 	assumptions            map[z.Lit]struct{} // set of assumed lits - duplicates guess stack - for fast lookup
 	guesses                []guess            // stack of assumed guesses
 	headChoice, tailChoice *choice            // deque of unmade choices
-	heap                   []choice
-	position               int
 	tracer                 Tracer
 	result                 int
 	buffer                 []z.Lit
@@ -119,8 +117,8 @@ func (h *search) PopChoiceFront() choice {
 	}
 	h.headChoice = c.next
 	return *c
-
 }
+
 func (h *search) PushChoiceBack(c choice) {
 	if h.tailChoice == nil {
 		h.headChoice = &c
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
index 5d81f459a2..873f17697f 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
@@ -11,7 +11,7 @@ import (
 	"github.com/go-air/gini/z"
 )
 
-var Incomplete = errors.New("cancelled before a solution could be found")
+var ErrIncomplete = errors.New("cancelled before a solution could be found")
 
 // NotSatisfiable is an error composed of a minimal set of applied
 // constraints that is sufficient to make a solution impossible.
@@ -114,7 +114,7 @@ func (s *solver) Solve(ctx context.Context) (result []Installable, err error) {
 		return nil, NotSatisfiable(s.litMap.Conflicts(s.g))
 	}
 
-	return nil, Incomplete
+	return nil, ErrIncomplete
 }
 
 func New(options ...Option) (Solver, error) {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry_test.go
index 6abf41c009..738c1bd13a 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/source_registry_test.go
@@ -42,15 +42,15 @@ func TestNewOperatorFromBundle(t *testing.T) {
 		},
 	}
 
-	csvJson, err := json.Marshal(csv)
+	csvJSON, err := json.Marshal(csv)
 	require.NoError(t, err)
 	bundleNoAPIs := &api.Bundle{
 		CsvName:     "testBundle",
 		PackageName: "testPackage",
 		ChannelName: "testChannel",
 		Version:     version.String(),
-		CsvJson:     string(csvJson),
-		Object:      []string{string(csvJson)},
+		CsvJson:     string(csvJSON),
+		Object:      []string{string(csvJSON)},
 	}
 
 	csv.Spec.CustomResourceDefinitions.Owned = []v1alpha1.CRDDescription{
@@ -84,7 +84,7 @@ func TestNewOperatorFromBundle(t *testing.T) {
 		},
 	}
 
-	csvJsonWithApis, err := json.Marshal(csv)
+	csvJSONWithAPIs, err := json.Marshal(csv)
 	require.NoError(t, err)
 
 	crd := v1beta1.CustomResourceDefinition{
@@ -112,7 +112,7 @@ func TestNewOperatorFromBundle(t *testing.T) {
 			},
 		},
 	}
-	crdJson, err := json.Marshal(crd)
+	crdJSON, err := json.Marshal(crd)
 	require.NoError(t, err)
 
 	bundleWithAPIs := &api.Bundle{
@@ -120,8 +120,8 @@ func TestNewOperatorFromBundle(t *testing.T) {
 		PackageName: "testPackage",
 		ChannelName: "testChannel",
 		Version:     version.String(),
-		CsvJson:     string(csvJsonWithApis),
-		Object:      []string{string(csvJsonWithApis), string(crdJson)},
+		CsvJson:     string(csvJSONWithAPIs),
+		Object:      []string{string(csvJSONWithAPIs), string(crdJSON)},
 		ProvidedApis: []*api.GroupVersionKind{
 			{
 				Group:   "crd.group.com",
@@ -184,14 +184,13 @@ func TestNewOperatorFromBundle(t *testing.T) {
 		CsvName:     "testBundle",
 		PackageName: "testPackage",
 		ChannelName: "testChannel",
-		CsvJson:     string(csvJsonWithApis),
-		Object:      []string{string(csvJsonWithApis), string(crdJson)},
+		CsvJson:     string(csvJSONWithAPIs),
+		Object:      []string{string(csvJSONWithAPIs), string(crdJSON)},
 	}
 
 	type args struct {
 		bundle         *api.Bundle
 		sourceKey      cache.SourceKey
-		replaces       string
 		defaultChannel string
 	}
 	tests := []struct {
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
index 079b928065..35b3a906be 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
@@ -4,7 +4,6 @@ package resolver
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
@@ -26,7 +25,8 @@ const (
 	BundleLookupConditionPacked v1alpha1.BundleLookupConditionType = "BundleLookupNotPersisted"
 )
 
-var timeNow = func() metav1.Time { return metav1.NewTime(time.Now().UTC()) }
+// init hooks provides the downstream a way to modify the upstream behavior
+var initHooks []stepResolverInitHook
 
 type StepResolver interface {
 	ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
@@ -48,7 +48,7 @@ var _ StepResolver = &OperatorStepResolver{}
 
 func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versioned.Interface, kubeclient kubernetes.Interface,
 	globalCatalogNamespace string, provider RegistryClientProvider, log logrus.FieldLogger) *OperatorStepResolver {
-	return &OperatorStepResolver{
+	stepResolver := &OperatorStepResolver{
 		subLister:              lister.OperatorsV1alpha1().SubscriptionLister(),
 		csvLister:              lister.OperatorsV1alpha1().ClusterServiceVersionLister(),
 		ipLister:               lister.OperatorsV1alpha1().InstallPlanLister(),
@@ -58,6 +58,15 @@ func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versio
 		satResolver:            NewDefaultSatResolver(SourceProviderFromRegistryClientProvider(provider, log), lister.OperatorsV1alpha1().CatalogSourceLister(), log),
 		log:                    log,
 	}
+
+	// init hooks can be added to the downstream to
+	// modify resolver behaviour
+	for _, initHook := range initHooks {
+		if err := initHook(stepResolver); err != nil {
+			panic(err)
+		}
+	}
+	return stepResolver
 }
 
 func (r *OperatorStepResolver) Expire(key cache.SourceKey) {
@@ -166,11 +175,11 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step,
 					},
 				},
 			}
-			if anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties); err != nil {
+			anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties)
+			if err != nil {
 				return nil, nil, nil, fmt.Errorf("failed to serialize operator properties for %q: %w", op.Name, err)
-			} else {
-				lookup.Properties = anno
 			}
+			lookup.Properties = anno
 			bundleLookups = append(bundleLookups, lookup)
 		}
 
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver_test.go
index 6c29c127ea..3a66f273f2 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver_test.go
@@ -47,6 +47,33 @@ var (
 	Requires4 = APISet4
 )
 
+func TestInitHooks(t *testing.T) {
+	clientFake := fake.NewSimpleClientset()
+	lister := operatorlister.NewLister()
+	kClientFake := k8sfake.NewSimpleClientset()
+	log := logrus.New()
+
+	// no init hooks
+	resolver := NewOperatorStepResolver(lister, clientFake, kClientFake, "", nil, log)
+	require.NotNil(t, resolver.satResolver)
+
+	// with init hook
+	var testHook stepResolverInitHook = func(resolver *OperatorStepResolver) error {
+		resolver.satResolver = nil
+		return nil
+	}
+
+	// defined in step_resolver.go
+	initHooks = append(initHooks, testHook)
+	defer func() {
+		// reset initHooks
+		initHooks = nil
+	}()
+
+	resolver = NewOperatorStepResolver(lister, clientFake, kClientFake, "", nil, log)
+	require.Nil(t, resolver.satResolver)
+}
+
 func TestResolver(t *testing.T) {
 	const namespace = "catsrc-namespace"
 	catalog := resolvercache.SourceKey{Name: "catsrc", Namespace: namespace}
@@ -872,18 +899,6 @@ func TestResolver(t *testing.T) {
 	}
 }
 
-type stubOperatorCacheProvider struct {
-	noc *resolvercache.NamespacedOperatorCache
-}
-
-func (stub *stubOperatorCacheProvider) Namespaced(namespaces ...string) resolvercache.MultiCatalogOperatorFinder {
-	return stub.noc
-}
-
-func (stub *stubOperatorCacheProvider) Expire(key resolvercache.SourceKey) {
-	return
-}
-
 func TestNamespaceResolverRBAC(t *testing.T) {
 	namespace := "catsrc-namespace"
 	catalog := resolvercache.SourceKey{Name: "catsrc", Namespace: namespace}
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
index 7f2270881b..7860c7108a 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
@@ -120,17 +120,18 @@ func NewStepResourceFromBundle(bundle *api.Bundle, namespace, replaces, catalogS
 
 	csv.SetNamespace(namespace)
 	csv.Spec.Replaces = replaces
-	if anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties); err != nil {
+	anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties)
+	if err != nil {
 		return nil, fmt.Errorf("failed to construct properties annotation for %q: %w", csv.GetName(), err)
-	} else {
-		annos := csv.GetAnnotations()
-		if annos == nil {
-			annos = make(map[string]string)
-		}
-		annos[projection.PropertiesAnnotationKey] = anno
-		csv.SetAnnotations(annos)
 	}
 
+	annos := csv.GetAnnotations()
+	if annos == nil {
+		annos = make(map[string]string)
+	}
+	annos[projection.PropertiesAnnotationKey] = anno
+	csv.SetAnnotations(annos)
+
 	step, err := NewStepResourceFromObject(csv, catalogSourceName, catalogSourceNamespace)
 	if err != nil {
 		return nil, err
diff --git a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/util_test.go b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/util_test.go
index 9dbb050761..87fcddd458 100644
--- a/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/util_test.go
+++ b/staging/operator-lifecycle-manager/pkg/controller/registry/resolver/util_test.go
@@ -215,25 +215,25 @@ func withVersion(version string) bundleOpt {
 }
 
 func bundle(name, pkg, channel, replaces string, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices cache.APISet, opts ...bundleOpt) *api.Bundle {
-	csvJson, err := json.Marshal(csv(name, replaces, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices, nil, nil))
+	csvJSON, err := json.Marshal(csv(name, replaces, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices, nil, nil))
 	if err != nil {
 		panic(err)
 	}
 
-	objs := []string{string(csvJson)}
+	objs := []string{string(csvJSON)}
 	for p := range providedCRDs {
-		crdJson, err := json.Marshal(crd(p))
+		crdJSON, err := json.Marshal(crd(p))
 		if err != nil {
 			panic(err)
 		}
-		objs = append(objs, string(crdJson))
+		objs = append(objs, string(crdJSON))
 	}
 
 	b := &api.Bundle{
 		CsvName:      name,
 		PackageName:  pkg,
 		ChannelName:  channel,
-		CsvJson:      string(csvJson),
+		CsvJson:      string(csvJSON),
 		Object:       objs,
 		Version:      "0.0.0",
 		ProvidedApis: apiSetToGVK(providedCRDs, providedAPIServices),
@@ -271,36 +271,31 @@ func withBundlePath(bundle *api.Bundle, path string) *api.Bundle {
 }
 
 func bundleWithPermissions(name, pkg, channel, replaces string, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices cache.APISet, permissions, clusterPermissions []v1alpha1.StrategyDeploymentPermissions) *api.Bundle {
-	csvJson, err := json.Marshal(csv(name, replaces, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices, permissions, clusterPermissions))
+	csvJSON, err := json.Marshal(csv(name, replaces, providedCRDs, requiredCRDs, providedAPIServices, requiredAPIServices, permissions, clusterPermissions))
 	if err != nil {
 		panic(err)
 	}
 
-	objs := []string{string(csvJson)}
+	objs := []string{string(csvJSON)}
 	for p := range providedCRDs {
-		crdJson, err := json.Marshal(crd(p))
+		crdJSON, err := json.Marshal(crd(p))
 		if err != nil {
 			panic(err)
 		}
-		objs = append(objs, string(crdJson))
+		objs = append(objs, string(crdJSON))
 	}
 
 	return &api.Bundle{
 		CsvName:      name,
 		PackageName:  pkg,
 		ChannelName:  channel,
-		CsvJson:      string(csvJson),
+		CsvJson:      string(csvJSON),
 		Object:       objs,
 		ProvidedApis: apiSetToGVK(providedCRDs, providedAPIServices),
 		RequiredApis: apiSetToGVK(requiredCRDs, requiredAPIServices),
 	}
 }
 
-func withReplaces(operator *cache.Entry, replaces string) *cache.Entry {
-	operator.Replaces = replaces
-	return operator
-}
-
 func requirePropertiesEqual(t *testing.T, a, b []*api.Property) {
 	type Property struct {
 		Type  string
diff --git a/staging/operator-lifecycle-manager/pkg/metrics/metrics.go b/staging/operator-lifecycle-manager/pkg/metrics/metrics.go
index ec1a188846..bbb17b00b0 100644
--- a/staging/operator-lifecycle-manager/pkg/metrics/metrics.go
+++ b/staging/operator-lifecycle-manager/pkg/metrics/metrics.go
@@ -13,20 +13,20 @@ import (
 )
 
 const (
-	NAME_LABEL      = "name"
-	INSTALLED_LABEL = "installed"
-	NAMESPACE_LABEL = "namespace"
-	CHANNEL_LABEL   = "channel"
-	VERSION_LABEL   = "version"
-	PHASE_LABEL     = "phase"
-	REASON_LABEL    = "reason"
-	PACKAGE_LABEL   = "package"
-	Outcome         = "outcome"
-	Succeeded       = "succeeded"
-	Failed          = "failed"
-	APPROVAL_LABEL  = "approval"
-	WARNING_LABEL   = "warning"
-	GVK_LABEL       = "gvk"
+	NameLabel      = "name"
+	InstalledLabel = "installed"
+	NamespaceLabel = "namespace"
+	ChannelLabel   = "channel"
+	VersionLabel   = "version"
+	PhaseLabel     = "phase"
+	ReasonLabel    = "reason"
+	PackageLabel   = "package"
+	Outcome        = "outcome"
+	Succeeded      = "succeeded"
+	Failed         = "failed"
+	ApprovalLabel  = "approval"
+	WarningLabel   = "warning"
+	GVKLabel       = "gvk"
 )
 
 type MetricsProvider interface {
@@ -90,7 +90,6 @@ type metricsCatalogSource struct {
 
 func NewMetricsCatalogSource(lister v1alpha1.CatalogSourceLister) MetricsProvider {
 	return &metricsCatalogSource{lister}
-
 }
 
 func (m *metricsCatalogSource) HandleMetrics() error {
@@ -149,7 +148,7 @@ var (
 			Name: "catalogsource_ready",
 			Help: "State of a CatalogSource. 1 indicates that the CatalogSource is in a READY state. 0 indicates CatalogSource is in a Non READY state.",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL},
+		[]string{NamespaceLabel, NameLabel},
 	)
 
 	// exported since it's not handled by HandleMetrics
@@ -165,7 +164,7 @@ var (
 			Name: "subscription_sync_total",
 			Help: "Monotonic count of subscription syncs",
 		},
-		[]string{NAME_LABEL, INSTALLED_LABEL, CHANNEL_LABEL, PACKAGE_LABEL, APPROVAL_LABEL},
+		[]string{NameLabel, InstalledLabel, ChannelLabel, PackageLabel, ApprovalLabel},
 	)
 
 	csvSucceeded = prometheus.NewGaugeVec(
@@ -173,7 +172,7 @@ var (
 			Name: "csv_succeeded",
 			Help: "Successful CSV install",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL},
+		[]string{NamespaceLabel, NameLabel, VersionLabel},
 	)
 
 	csvAbnormal = prometheus.NewGaugeVec(
@@ -181,7 +180,7 @@ var (
 			Name: "csv_abnormal",
 			Help: "CSV is not installed",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL, PHASE_LABEL, REASON_LABEL},
+		[]string{NamespaceLabel, NameLabel, VersionLabel, PhaseLabel, ReasonLabel},
 	)
 
 	dependencyResolutionSummary = prometheus.NewSummaryVec(
@@ -200,7 +199,7 @@ var (
 		},
 	)
 
-	// subscriptionSyncCounters keeps a record of the promethues counters emitted by
+	// subscriptionSyncCounters keeps a record of the Prometheus counters emitted by
 	// Subscription objects. The key of a record is the Subscription name, while the value
 	//  is struct containing label values used in the counter
 	subscriptionSyncCounters = make(map[string]subscriptionSyncLabelValues)
@@ -310,7 +309,6 @@ func UpdateSubsSyncCounterStorage(sub *olmv1alpha1.Subscription) {
 		sub.Spec.Package != counterValues.pkg ||
 		sub.Status.InstalledCSV != counterValues.installedCSV ||
 		approvalStrategy != counterValues.approvalStrategy {
-
 		// Delete metric will label values of old Subscription first
 		SubscriptionSyncCount.DeleteLabelValues(sub.GetName(), counterValues.installedCSV, counterValues.channel, counterValues.pkg, counterValues.approvalStrategy)
 
diff --git a/staging/operator-lifecycle-manager/pkg/package-server/client/util.go b/staging/operator-lifecycle-manager/pkg/package-server/client/util.go
index 886168dd05..79ba6e84ae 100644
--- a/staging/operator-lifecycle-manager/pkg/package-server/client/util.go
+++ b/staging/operator-lifecycle-manager/pkg/package-server/client/util.go
@@ -5,7 +5,6 @@ import (
 	"os"
 
 	log "github.com/sirupsen/logrus"
-	_ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 )
diff --git a/staging/operator-lifecycle-manager/pkg/package-server/provider/registry.go b/staging/operator-lifecycle-manager/pkg/package-server/provider/registry.go
index a761eeb180..0a959b8c09 100644
--- a/staging/operator-lifecycle-manager/pkg/package-server/provider/registry.go
+++ b/staging/operator-lifecycle-manager/pkg/package-server/provider/registry.go
@@ -61,7 +61,7 @@ func catalogIndexFunc(obj interface{}) ([]string, error) {
 
 func PackageManifestKeyFunc(obj interface{}) (string, error) {
 	if key, ok := obj.(string); ok {
-		return string(key), nil
+		return key, nil
 	}
 
 	pkg, ok := obj.(*operators.PackageManifest)
@@ -351,7 +351,7 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s
 				continue
 			}
 		}
-		if err := p.cache.Delete(string(storedPkgKey)); err != nil {
+		if err := p.cache.Delete(storedPkgKey); err != nil {
 			logger.WithField("pkg", name).WithError(err).Warn("failed to delete cache entry")
 			errs = append(errs, err)
 		}
@@ -363,18 +363,16 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s
 func (p *RegistryProvider) catalogSourceDeleted(obj interface{}) {
 	catsrc, ok := obj.(metav1.Object)
 	if !ok {
+		tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
 		if !ok {
-			tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
-				return
-			}
+			utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
+			return
+		}
 
-			catsrc, ok = tombstone.Obj.(metav1.Object)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
-				return
-			}
+		catsrc, ok = tombstone.Obj.(metav1.Object)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
+			return
 		}
 	}
 
diff --git a/staging/operator-lifecycle-manager/pkg/package-server/provider/registry_test.go b/staging/operator-lifecycle-manager/pkg/package-server/provider/registry_test.go
index c9a809ec60..339094d761 100644
--- a/staging/operator-lifecycle-manager/pkg/package-server/provider/registry_test.go
+++ b/staging/operator-lifecycle-manager/pkg/package-server/provider/registry_test.go
@@ -50,6 +50,9 @@ func server() {
 	s := grpc.NewServer()
 
 	db, err := sql.Open("sqlite3", dbName)
+	if err != nil {
+		logrus.Fatal(err)
+	}
 	load, err := sqlite.NewSQLLiteLoader(db)
 	if err != nil {
 		logrus.Fatal(err)
@@ -124,13 +127,12 @@ func TestMain(m *testing.M) {
 }
 
 var (
-	etcdCSVJSON                = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"annotations\":{\"alm-examples\":\"[{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdCluster\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example\\\",\\\"namespace\\\":\\\"default\\\"},\\\"spec\\\":{\\\"size\\\":3,\\\"version\\\":\\\"3.2.13\\\"}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdRestore\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"spec\\\":{\\\"etcdCluster\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"backupStorageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdBackup\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster-backup\\\"},\\\"spec\\\":{\\\"etcdEndpoints\\\":[\\\"\\u003cetcd-cluster-endpoints\\u003e\\\"],\\\"storageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}}]\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"icon\":[{\"base64data\":\"iVBORw0KGgoAAAANSUhEUgAAAOEAAADZCAYAAADWmle6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAEKlJREFUeNrsndt1GzkShmEev4sTgeiHfRYdgVqbgOgITEVgOgLTEQydwIiKwFQCayoCU6+7DyYjsBiBFyVVz7RkXvqCSxXw/+f04XjGQ6IL+FBVuL769euXgZ7r39f/G9iP0X+u/jWDNZzZdGI/Ftama1jjuV4BwmcNpbAf1Fgu+V/9YRvNAyzT2a59+/GT/3hnn5m16wKWedJrmOCxkYztx9Q+py/+E0GJxtJdReWfz+mxNt+QzS2Mc0AI+HbBBwj9QViKbH5t64DsP2fvmGXUkWU4WgO+Uve2YQzBUGd7r+zH2ZG/tiUQc4QxKwgbwFfVGwwmdLL5wH78aPC/ZBem9jJpCAX3xtcNASSNgJLzUPSQyjB1zQNl8IQJ9MIU4lx2+Jo72ysXYKl1HSzN02BMa/vbZ5xyNJIshJzwf3L0dQhJw4Sih/SFw9Tk8sVeghVPoefaIYCkMZCKbrcP9lnZuk0uPUjGE/KE8JQry7W2tgfuC3vXgvNV+qSQbyFtAtyWk7zWiYevvuUQ9QEQCvJ+5mmu6dTjz1zFHLFj8Eb87MtxaZh/IQFIHom+9vgTWwZxAQjT9X4vtbEVPojwjiV471s00mhAckpwGuCn1HtFtRDaSh6y9zsL+LNBvCG/24ThcxHObdlWc1v+VQJe8LcO0jwtuF8BwnAAUgP9M8JPU2Me+Oh12auPGT6fHuTePE3bLDy+x9pTLnhMn+07TQGh//Bz1iI0c6kvtqInjvPZcYR3KsPVmUsPYt9nFig9SCY8VQNhpPBzn952bbgcsk2EvM89wzh3UEffBbyPqvBUBYQ8ODGPFOLsa7RF096WJ69L+E4EmnpjWu5o4ChlKaRTKT39RMMaVPEQRsz/nIWlDN80chjdJlSd1l0pJCAMVZsniobQVuxceMM9OFoaMd9zqZtjMEYYDW38Drb8Y0DYPLShxn0pvIFuOSxd7YCPet9zk452wsh54FJoeN05hcgSQoG5RR0Qh9Q4E4VvL4wcZq8UACgaRFEQKgSwWrkr5WFnGxiHSutqJGlXjBgIOayhwYBTA0ER0oisIVSUV0AAMT0IASCUO4hRIQSAEECMCCEPwqyQA0JCQBzEGjWNAqHiUVAoXUWbvggOIQCEAOJzxTjoaQ4AIaE64/aZridUsBYUgkhB15oGg1DBIl8IqirYwV6hPSGBSFteMCUBSVXwfYixBmamRubeMyjzMJQBDDowE3OesDD+zwqFoDqiEwXoXJpljB+PvWJGy75BKF1FPxhKygJuqUdYQGlLxNEXkrYyjQ0GbaAwEnUIlLRNvVjQDYUAsJB0HKLE4y0AIpQNgCIhBIhQTgCKhZBBpAN/v6LtQI50JfUgYOnnjmLUFHKhjxbAmdTCaTiBm3ovLPqG2urWAij6im0Nd9aTN9ygLUEt9LgSRnohxUPIKxlGaE+/6Y7znFf0yX+GnkvFFWmarkab2o9PmTeq8sbd2a7DaysXz7i64VeznN4jCQhN9gdDbRiuWrfrsq0mHIrlaq+hlotCtd3Um9u0BYWY8y5D67wccJoZjFca7iUs9VqZcfsZwTd1sbWGG+OcYaTnPAP7rTQVVlM4Sg3oGvB1tmNh0t/HKXZ1jFoIMwCQjtqbhNxUmkGYqgZEDZP11HN/S3gAYRozf0l8C5kKEKUvW0t1IfeWG/5MwgheZTT1E0AEhDkAePQO+Ig2H3DncAkQM4cwUQCD530dU4B5Yvmi2LlDqXfWrxMCcMth51RToRMNUXFnfc2KJ0+Ryl0VNOUwlhh6NoxK5gnViTgQpUG4SqSyt5z3zRJpuKmt3Q1614QaCBPaN6je+2XiFcWAKOXcUfIYKRyL/1lb7pe5VxSxxjQ6hImshqGRt5GWZVKO6q2wHwujfwDtIvaIdexj8Cm8+a68EqMfox6x/voMouZF4dHnEGNeCDMwT6vdNfekH1MafMk4PI06YtqLVGl95aEM9Z5vAeCTOA++YLtoVJRrsqNCaJ6WRmkdYaNec5BT/lcTRMqrhmwfjbpkj55+OKp8IEbU/JLgPJE6Wa3TTe9sHS+ShVD5QIyqIxMEwKh12olC6mHIed5ewEop80CNlfIOADYOT2nd6ZXCop+Ebqchc0JqxKcKASxChycJgUh1rnHA5ow9eTrhqNI7JWiAYYwBGGdpyNLoGw0Pkh96h1BpHihyywtATDM/7Hk2fN9EnH8BgKJCU4ooBkbXFMZJiPbrOyecGl3zgQDQL4hk10IZiOe+5w99Q/gBAEIJgPhJM4QAEEoFREAIAAEiIASAkD8Qt4AQAEIAERAGFlX4CACKAXGVM4ivMwWwCLFAlyeoaa70QePKm5Dlp+/n+ye/5dYgva6YsUaVeMa+tzNFeJtWwc+udbJ0Fg399kLielQJ5Ze61c2+7ytA6EZetiPxZC6tj22yJCv6jUwOyj/zcbqAxOMyAKEbfeHtNa7DtYXptjsk2kJxR+eIeim/tHNofUKYy8DMrQcAKWz6brpvzyIAlpwPhQ49l6b7skJf5Z+YTOYQc4FwLDxvoTDwaygQK+U/kVr+ytSFBG01Q3gnJJR4cNiAhx4HDub8/b5DULXlj6SVZghFiE+LdvE9vo/o8Lp1RmH5hzm0T6wdbZ6n+D6i44zDRc3ln6CpAEJfXiRU45oqLz8gFAThWsh7ughrRibc0QynHgZpNJa/ENJ+loCwu/qOGnFIjYR/n7TfgycULhcQhu6VC+HfF+L3BoAQ4WiZTw1M+FPCnA2gKC6/FAhXgDC+ojQGh3NuWsvfF1L/D5ohlCKtl1j2ldu9a/nPAKFwN56Bst10zCG0CPleXN/zXPgHQZXaZaBgrbzyY5V/mUA+6F0hwtGN9rwu5DVZPuwWqfxdFz1LWbJ2lwKEa+0Qsm4Dl3fp+Pu0lV97PgwIPfSsS+UQhj5Oo+vvFULazRIQyvGEcxPuNLCth2MvFsrKn8UOilAQShkh7TTczYNMoS6OdP47msrPi82lXKGWhCdMZYS0bFy+vcnGAjP1CIfvgbKNA9glecEH9RD6Ol4wRuWyN/G9MHnksS6o/GPf5XcwNSUlHzQhDuAKtWJmkwKElU7lylP5rgIcsquh/FI8YZCDpkJBuE4FQm7Icw8N+SrUGaQKyi8FwiDt1ve5o+Vu7qYHy/psgK8cvh+FTYuO77bhEC7GuaPiys/L1X4IgXDL+e3M5+ovLxBy5VLuIebw1oqcHoPfoaMJUsHays878r8KbDc3xtPx/84gZPBG/JwaufrsY/SRG/OY3//8QMNdsvdZCFtbW6f8pFuf5bflILAlX7O+4fdfugKyFYS8T2zAsXthdG0VurPGKwI06oF5vkBgHWkNp6ry29+lsPZMU3vijnXFNmoclr+6+Ou/FIb8yb30sS8YGjmTqCLyQsi5N/6ZwKs0Yenj68pfPjF6N782Dp2FzV9CTyoSeY8mLK16qGxIkLI8oa1n8tz9juP40DlK0epxYEbojbq+9QfurBeVIlCO9D2396bxiV4lkYQ3hOAFw2pbhqMGISkkQOMcQ9EqhDmGZZdo92JC0YHRNTfoSg+5e0IT+opqCKHoIU+4ztQIgBD1EFNrQAgIpYSil9lDmPHqkROPt+JC6AgPquSuumJmg0YARVCuneDfvPVeJokZ6pIXDkNxQtGzTF9/BQjRG0tQznfb74RwCQghpALBtIQnfK4zhxdyQvVCUeknMIT3hLyY+T5jo0yABqKPQNpUNw/09tGZod5jgCaYFxyYvJcNPkv9eof+I3pnCFEHIETjSM8L9tHZHYCQT9PaZGycU6yg8S4akDnJ+P03L0+t23XGzCLzRgII/Wqa+fv/xlfvmKvMUOcOrlCDdoei1MGdZm6G5VEIfRzzjd4aQs69n699Rx7ewhvCGzr2gmTPs8zNsJOrXt24FbkhhOjCfT4ICA/rPbyhUy94Dks0gJCX1NzCZui9YUd3oei+c257TalFbgg19ILHrlrL2gvWgXAL26EX76gZTNASQnad8Ibwhl284NhgXpB0c+jKhWO3Ms1hP9ihJYB9eMF6qd1BCPk0qA1s+LimFIu7m4nsdQIzPK4VbQ8hYvrnuSH2G9b2ggP78QmWqBdF9Vx8SSY6QYdUW7BTA1schZATyhvY8lHvcRbNUS9YGFy2U+qmzh2YPVc0I7yAOFyHfRpyUwtCSzOdPXMHmz7qDIM0e0V2wZTEk+6Ym6N63eBLp/b5Bts+2cKCSJ/LuoZO3ANSiE5hKAZjnvNSS4931jcw9jpwT0feV/qSJ1pVtCyfHKDkvK8Ejx7pUxGh2xFNSwx8QTi2H9ceC0/nni64MS/5N5dG39pDqvRV+WgGk71c9VFXF9b+xYvOw/d61iv7m3MvEHryhvecwC52jSSx4VIIgwnMNT/UsTxIgpPt3K/ARj15CptwL3Zd/ceDSATj2DGQjbxgWwhdeMMte7zpy5On9vymRm/YxBYljGVjKWF9VJf7I1+sex3wY8w/V1QPTborW/72gkdsRDaZMJBdbdHIC7aCkAu9atlLbtnrzerMnyToDaGwelOnk3/hHSem/ZK7e/t7jeeR20LYBgqa8J80gS8jbwi5F02Uj1u2NYJxap8PLkJfLxA2hIJyvnHX/AfeEPLpBfe0uSFHbnXaea3Qd5d6HcpYZ8L6M7lnFwMQ3MNg+RxUR1+6AshtbsVgfXTEg1sIGax9UND2p7f270wdG3eK9gXVGHdw2k5sOyZv+Nbs39Z308XR9DqWb2J+PwKDhuKHPobfuXf7gnYGHdCs7bhDDadD4entDug7LWNsnRNW4mYqwJ9dk+GGSTPBiA2j0G8RWNM5upZtcG4/3vMfP7KnbK2egx6CCnDPhRn7NgD3cghLIad5WcM2SO38iqHvvMOosyeMpQ5zlVCaaj06GVs9xUbHdiKoqrHWgquFEFMWUEWfXUxJAML23hAHFOctmjZQffKD2pywkhtSGHKNtpitLroscAeE7kCkSsC60vxEl6yMtL9EL5HKGCMszU5bk8gdkklAyEn5FO0yK419rIxBOIqwFMooDE0tHEVYijAUECIshRCGIhxFWIowFJ5QkEYIS5PTJrUwNGlPyN6QQPyKtpuM1E/K5+YJDV/MiA3AaehzqgAm7QnZG9IGYKo8bHnSK7VblLL3hOwNHziPuEGOqE5brrdR6i+atCfckyeWD47HkAkepRGLY/e8A8J0gCwYSNypF08bBm+e6zVz2UL4AshhBUjML/rXLefqC82bcQFhGC9JDwZ1uuu+At0S5gCETYHsV4DUeD9fDN2Zfy5OXaW2zAwQygCzBLJ8cvaW5OXKC1FxfTggFAHmoAJnSiOw2wps9KwRWgJCLaEswaj5NqkLwAYIU4BxqTSXbHXpJdRMPZgAOiAMqABCNGYIEEJutEK5IUAIwYMDQgiCACEEAcJs1Vda7gGqDhCmoiEghAAhBAHCrKXVo2C1DCBMRlp37uMIEECoX7xrX3P5C9QiINSuIcoPAUI0YkAICLNWgfJDh4T9hH7zqYH9+JHAq7zBqWjwhPAicTVCVQJCNF50JghHocahKK0X/ZnQKyEkhSdUpzG8OgQI42qC94EQjsYLRSmH+pbgq73L6bYkeEJ4DYTYmeg1TOBFc/usTTp3V9DdEuXJ2xDCUbXhaXk0/kAYmBvuMB4qkC35E5e5AMKkwSQgyxufyuPy6fMMgAFCSI73LFXU/N8AmEL9X4ABACNSKMHAgb34AAAAAElFTkSuQmCC\",\"mediatype\":\"image/png\"}],\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"version\":\"0.9.2\"}}"
-	etcdWithLabelsCSVJSON      = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"labels\": {\"test\": \"label\"},\"annotations\":{\"alm-examples\":\"[{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdCluster\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example\\\",\\\"namespace\\\":\\\"default\\\"},\\\"spec\\\":{\\\"size\\\":3,\\\"version\\\":\\\"3.2.13\\\"}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdRestore\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"spec\\\":{\\\"etcdCluster\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"backupStorageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdBackup\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster-backup\\\"},\\\"spec\\\":{\\\"etcdEndpoints\\\":[\\\"\\u003cetcd-cluster-endpoints\\u003e\\\"],\\\"storageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}}]\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"icon\":[{\"base64data\":\"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\",\"mediatype\":\"image/png\"}],\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"version\":\"0.9.2\"}}"
-	etcdBackupsCRDJSON         = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdbackups.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdBackup\",\"listKind\":\"EtcdBackupList\",\"plural\":\"etcdbackups\",\"singular\":\"etcdbackup\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
-	etcdUpgradesCRDJSON        = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdclusters.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdCluster\",\"listKind\":\"EtcdClusterList\",\"plural\":\"etcdclusters\",\"shortNames\":[\"etcdclus\",\"etcd\"],\"singular\":\"etcdcluster\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
-	etcdRestoresCRDJSON        = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdrestores.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdRestore\",\"listKind\":\"EtcdRestoreList\",\"plural\":\"etcdrestores\",\"singular\":\"etcdrestore\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
-	prometheusCSVJSON          = `{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Prometheus\",\"metadata\":{\"name\":\"example\",\"labels\":{\"prometheus\":\"k8s\"}},\"spec\":{\"replicas\":2,\"version\":\"v2.3.2\",\"serviceAccountName\":\"prometheus-k8s\",\"securityContext\": {}, \"serviceMonitorSelector\":{\"matchExpressions\":[{\"key\":\"k8s-app\",\"operator\":\"Exists\"}]},\"ruleSelector\":{\"matchLabels\":{\"role\":\"prometheus-rulefiles\",\"prometheus\":\"k8s\"}},\"alerting\":{\"alertmanagers\":[{\"namespace\":\"monitoring\",\"name\":\"alertmanager-main\",\"port\":\"web\"}]}}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"ServiceMonitor\",\"metadata\":{\"name\":\"example\",\"labels\":{\"k8s-app\":\"prometheus\"}},\"spec\":{\"selector\":{\"matchLabels\":{\"k8s-app\":\"prometheus\"}},\"endpoints\":[{\"port\":\"web\",\"interval\":\"30s\"}]}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Alertmanager\",\"metadata\":{\"name\":\"alertmanager-main\"},\"spec\":{\"replicas\":3, \"securityContext\": {}}}]"},"name":"prometheusoperator.0.22.2","namespace":"placeholder"},"spec":{"customresourcedefinitions":{"owned":[{"description":"A running Prometheus instance","displayName":"Prometheus","kind":"Prometheus","name":"prometheuses.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"A selector for the ConfigMaps from which to load rule files","displayName":"Rule Config Map Selector","path":"ruleSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:core:v1:ConfigMap"]},{"description":"ServiceMonitors to be selected for target discovery","displayName":"Service Monitor Selector","path":"serviceMonitorSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:monitoring.coreos.com:v1:ServiceMonitor"]},{"description":"The ServiceAccount to use to run the Prometheus pods","displayName":"Service Account","path":"serviceAccountName","x-descriptors":["urn:alm:descriptor:io.kubernetes:ServiceAccount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"},{"description":"A Prometheus Rule configures groups of sequentially evaluated recording and alerting rules.","displayName":"Prometheus Rule","kind":"PrometheusRule","name":"prometheusrules.monitoring.coreos.com","version":"v1"},{"description":"Configures prometheus to monitor a particular k8s service","displayName":"Service Monitor","kind":"ServiceMonitor","name":"servicemonitors.monitoring.coreos.com","resources":[{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"The label to use to retrieve the job name from","displayName":"Job Label","path":"jobLabel","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:label"]},{"description":"A list of endpoints allowed as part of this ServiceMonitor","displayName":"Endpoints","path":"endpoints","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:endpointList"]}],"version":"v1"},{"description":"Configures an Alertmanager for the namespace","displayName":"Alertmanager","kind":"Alertmanager","name":"alertmanagers.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"}]},"description":"The Prometheus Operator for Kubernetes provides easy monitoring definitions for Kubernetes services and deployment and management of Prometheus instances.\n\nOnce installed, the Prometheus Operator provides the following features:\n\n* **Create/Destroy**: Easily launch a Prometheus instance for your Kubernetes namespace, a specific application or team easily using the Operator.\n\n* **Simple Configuration**: Configure the fundamentals of Prometheus like versions, persistence, retention policies, and replicas from a native Kubernetes resource.\n\n* **Target Services via Labels**: Automatically generate monitoring target configurations based on familiar Kubernetes label queries; no need to learn a Prometheus specific configuration language.\n\n### Other Supported Features\n\n**High availability**\n\nMultiple instances are run across failure zones and data is replicated. This keeps your monitoring available during an outage, when you need it most.\n\n**Updates via automated operations**\n\nNew Prometheus versions are deployed using a rolling update with no downtime, making it easy to stay up to date.\n\n**Handles the dynamic nature of containers**\n\nAlerting rules are attached to groups of containers instead of individual instances, which is ideal for the highly dynamic nature of container deployment.\n","displayName":"Prometheus Operator","icon":[{"base64data":"PHN2ZyB3aWR0aD0iMjQ5MCIgaGVpZ2h0PSIyNTAwIiB2aWV3Qm94PSIwIDAgMjU2IDI1NyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBwcmVzZXJ2ZUFzcGVjdFJhdGlvPSJ4TWlkWU1pZCI+PHBhdGggZD0iTTEyOC4wMDEuNjY3QzU3LjMxMS42NjcgMCA1Ny45NzEgMCAxMjguNjY0YzAgNzAuNjkgNTcuMzExIDEyNy45OTggMTI4LjAwMSAxMjcuOTk4UzI1NiAxOTkuMzU0IDI1NiAxMjguNjY0QzI1NiA1Ny45NyAxOTguNjg5LjY2NyAxMjguMDAxLjY2N3ptMCAyMzkuNTZjLTIwLjExMiAwLTM2LjQxOS0xMy40MzUtMzYuNDE5LTMwLjAwNGg3Mi44MzhjMCAxNi41NjYtMTYuMzA2IDMwLjAwNC0zNi40MTkgMzAuMDA0em02MC4xNTMtMzkuOTRINjcuODQyVjE3OC40N2gxMjAuMzE0djIxLjgxNmgtLjAwMnptLS40MzItMzMuMDQ1SDY4LjE4NWMtLjM5OC0uNDU4LS44MDQtLjkxLTEuMTg4LTEuMzc1LTEyLjMxNS0xNC45NTQtMTUuMjE2LTIyLjc2LTE4LjAzMi0zMC43MTYtLjA0OC0uMjYyIDE0LjkzMyAzLjA2IDI1LjU1NiA1LjQ1IDAgMCA1LjQ2NiAxLjI2NSAxMy40NTggMi43MjItNy42NzMtOC45OTQtMTIuMjMtMjAuNDI4LTEyLjIzLTMyLjExNiAwLTI1LjY1OCAxOS42OC00OC4wNzkgMTIuNTgtNjYuMjAxIDYuOTEuNTYyIDE0LjMgMTQuNTgzIDE0LjggMzYuNTA1IDcuMzQ2LTEwLjE1MiAxMC40Mi0yOC42OSAxMC40Mi00MC4wNTYgMC0xMS43NjkgNy43NTUtMjUuNDQgMTUuNTEyLTI1LjkwNy02LjkxNSAxMS4zOTYgMS43OSAyMS4xNjUgOS41MyA0NS40IDIuOTAyIDkuMTAzIDIuNTMyIDI0LjQyMyA0Ljc3MiAzNC4xMzguNzQ0LTIwLjE3OCA0LjIxMy00OS42MiAxNy4wMTQtNTkuNzg0LTUuNjQ3IDEyLjguODM2IDI4LjgxOCA1LjI3IDM2LjUxOCA3LjE1NCAxMi40MjQgMTEuNDkgMjEuODM2IDExLjQ5IDM5LjYzOCAwIDExLjkzNi00LjQwNyAyMy4xNzMtMTEuODQgMzEuOTU4IDguNDUyLTEuNTg2IDE0LjI4OS0zLjAxNiAxNC4yODktMy4wMTZsMjcuNDUtNS4zNTVjLjAwMi0uMDAyLTMuOTg3IDE2LjQwMS0xOS4zMTQgMzIuMTk3eiIgZmlsbD0iI0RBNEUzMSIvPjwvc3ZnPg==","mediatype":"image/svg+xml"}],"install":{"spec":{"deployments":[{"name":"prometheus-operator","spec":{"replicas":1,"selector":{"matchLabels":{"k8s-app":"prometheus-operator"}},"template":{"metadata":{"labels":{"k8s-app":"prometheus-operator"}},"spec":{"containers":[{"args":["-namespace=$(K8S_NAMESPACE)","-manage-crds=false","-logtostderr=true","--config-reloader-image=quay.io/coreos/configmap-reload:v0.0.1","--prometheus-config-reloader=quay.io/coreos/prometheus-config-reloader:v0.22.2"],"env":[{"name":"K8S_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.namespace"}}}],"image":"quay.io/coreos/prometheus-operator@sha256:3daa69a8c6c2f1d35dcf1fe48a7cd8b230e55f5229a1ded438f687debade5bcf","name":"prometheus-operator","ports":[{"containerPort":8080,"name":"http"}],"resources":{"limits":{"cpu":"200m","memory":"100Mi"},"requests":{"cpu":"100m","memory":"50Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"readOnlyRootFilesystem":true}}],"nodeSelector":{"kubernetes.io/os":"linux"},"serviceAccount":"prometheus-operator-0-22-2"}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["nodes","services","endpoints","pods"],"verbs":["get","list","watch"]},{"apiGroups":[""],"resources":["configmaps"],"verbs":["get"]}],"serviceAccountName":"prometheus-k8s"},{"rules":[{"apiGroups":["apiextensions.k8s.io"],"resources":["customresourcedefinitions"],"verbs":["*"]},{"apiGroups":["monitoring.coreos.com"],"resources":["alertmanagers","prometheuses","prometheuses/finalizers","alertmanagers/finalizers","servicemonitors","prometheusrules"],"verbs":["*"]},{"apiGroups":["apps"],"resources":["statefulsets"],"verbs":["*"]},{"apiGroups":[""],"resources":["configmaps","secrets"],"verbs":["*"]},{"apiGroups":[""],"resources":["pods"],"verbs":["list","delete"]},{"apiGroups":[""],"resources":["services","endpoints"],"verbs":["get","create","update"]},{"apiGroups":[""],"resources":["nodes"],"verbs":["list","watch"]},{"apiGroups":[""],"resources":["namespaces"],"verbs":["list","watch"]}],"serviceAccountName":"prometheus-operator-0-22-2"}]},"strategy":"deployment"},"keywords":["prometheus","monitoring","tsdb","alerting"],"labels":{"alm-owner-prometheus":"prometheusoperator","alm-status-descriptors":"prometheusoperator.0.22.2"},"links":[{"name":"Prometheus","url":"https://www.prometheus.io/"},{"name":"Documentation","url":"https://coreos.com/operators/prometheus/docs/latest/"},{"name":"Prometheus Operator","url":"https://github.com/coreos/prometheus-operator"}],"maintainers":[{"email":"openshift-operators@redhat.com","name":"Red Hat"}],"maturity":"beta","provider":{"name":"Red Hat"},"replaces":"prometheusoperator.0.15.0","selector":{"matchLabels":{"alm-owner-prometheus":"prometheusoperator"}},"version":"0.22.2"}}`
-	prometheusWithLabelCSVJSON = `{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"labels": {"test": "label"}, "annotations":{"alm-examples":"[{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Prometheus\",\"metadata\":{\"name\":\"example\",\"labels\":{\"prometheus\":\"k8s\"}},\"spec\":{\"replicas\":2,\"version\":\"v2.3.2\",\"serviceAccountName\":\"prometheus-k8s\",\"securityContext\": {}, \"serviceMonitorSelector\":{\"matchExpressions\":[{\"key\":\"k8s-app\",\"operator\":\"Exists\"}]},\"ruleSelector\":{\"matchLabels\":{\"role\":\"prometheus-rulefiles\",\"prometheus\":\"k8s\"}},\"alerting\":{\"alertmanagers\":[{\"namespace\":\"monitoring\",\"name\":\"alertmanager-main\",\"port\":\"web\"}]}}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"ServiceMonitor\",\"metadata\":{\"name\":\"example\",\"labels\":{\"k8s-app\":\"prometheus\"}},\"spec\":{\"selector\":{\"matchLabels\":{\"k8s-app\":\"prometheus\"}},\"endpoints\":[{\"port\":\"web\",\"interval\":\"30s\"}]}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Alertmanager\",\"metadata\":{\"name\":\"alertmanager-main\"},\"spec\":{\"replicas\":3, \"securityContext\": {}}}]"},"name":"prometheusoperator.0.22.2","namespace":"placeholder"},"spec":{"customresourcedefinitions":{"owned":[{"description":"A running Prometheus instance","displayName":"Prometheus","kind":"Prometheus","name":"prometheuses.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"A selector for the ConfigMaps from which to load rule files","displayName":"Rule Config Map Selector","path":"ruleSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:core:v1:ConfigMap"]},{"description":"ServiceMonitors to be selected for target discovery","displayName":"Service Monitor Selector","path":"serviceMonitorSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:monitoring.coreos.com:v1:ServiceMonitor"]},{"description":"The ServiceAccount to use to run the Prometheus pods","displayName":"Service Account","path":"serviceAccountName","x-descriptors":["urn:alm:descriptor:io.kubernetes:ServiceAccount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"},{"description":"A Prometheus Rule configures groups of sequentially evaluated recording and alerting rules.","displayName":"Prometheus Rule","kind":"PrometheusRule","name":"prometheusrules.monitoring.coreos.com","version":"v1"},{"description":"Configures prometheus to monitor a particular k8s service","displayName":"Service Monitor","kind":"ServiceMonitor","name":"servicemonitors.monitoring.coreos.com","resources":[{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"The label to use to retrieve the job name from","displayName":"Job Label","path":"jobLabel","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:label"]},{"description":"A list of endpoints allowed as part of this ServiceMonitor","displayName":"Endpoints","path":"endpoints","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:endpointList"]}],"version":"v1"},{"description":"Configures an Alertmanager for the namespace","displayName":"Alertmanager","kind":"Alertmanager","name":"alertmanagers.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"}]},"description":"The Prometheus Operator for Kubernetes provides easy monitoring definitions for Kubernetes services and deployment and management of Prometheus instances.\n\nOnce installed, the Prometheus Operator provides the following features:\n\n* **Create/Destroy**: Easily launch a Prometheus instance for your Kubernetes namespace, a specific application or team easily using the Operator.\n\n* **Simple Configuration**: Configure the fundamentals of Prometheus like versions, persistence, retention policies, and replicas from a native Kubernetes resource.\n\n* **Target Services via Labels**: Automatically generate monitoring target configurations based on familiar Kubernetes label queries; no need to learn a Prometheus specific configuration language.\n\n### Other Supported Features\n\n**High availability**\n\nMultiple instances are run across failure zones and data is replicated. This keeps your monitoring available during an outage, when you need it most.\n\n**Updates via automated operations**\n\nNew Prometheus versions are deployed using a rolling update with no downtime, making it easy to stay up to date.\n\n**Handles the dynamic nature of containers**\n\nAlerting rules are attached to groups of containers instead of individual instances, which is ideal for the highly dynamic nature of container deployment.\n","displayName":"Prometheus Operator","icon":[{"base64data":"PHN2ZyB3aWR0aD0iMjQ5MCIgaGVpZ2h0PSIyNTAwIiB2aWV3Qm94PSIwIDAgMjU2IDI1NyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBwcmVzZXJ2ZUFzcGVjdFJhdGlvPSJ4TWlkWU1pZCI+PHBhdGggZD0iTTEyOC4wMDEuNjY3QzU3LjMxMS42NjcgMCA1Ny45NzEgMCAxMjguNjY0YzAgNzAuNjkgNTcuMzExIDEyNy45OTggMTI4LjAwMSAxMjcuOTk4UzI1NiAxOTkuMzU0IDI1NiAxMjguNjY0QzI1NiA1Ny45NyAxOTguNjg5LjY2NyAxMjguMDAxLjY2N3ptMCAyMzkuNTZjLTIwLjExMiAwLTM2LjQxOS0xMy40MzUtMzYuNDE5LTMwLjAwNGg3Mi44MzhjMCAxNi41NjYtMTYuMzA2IDMwLjAwNC0zNi40MTkgMzAuMDA0em02MC4xNTMtMzkuOTRINjcuODQyVjE3OC40N2gxMjAuMzE0djIxLjgxNmgtLjAwMnptLS40MzItMzMuMDQ1SDY4LjE4NWMtLjM5OC0uNDU4LS44MDQtLjkxLTEuMTg4LTEuMzc1LTEyLjMxNS0xNC45NTQtMTUuMjE2LTIyLjc2LTE4LjAzMi0zMC43MTYtLjA0OC0uMjYyIDE0LjkzMyAzLjA2IDI1LjU1NiA1LjQ1IDAgMCA1LjQ2NiAxLjI2NSAxMy40NTggMi43MjItNy42NzMtOC45OTQtMTIuMjMtMjAuNDI4LTEyLjIzLTMyLjExNiAwLTI1LjY1OCAxOS42OC00OC4wNzkgMTIuNTgtNjYuMjAxIDYuOTEuNTYyIDE0LjMgMTQuNTgzIDE0LjggMzYuNTA1IDcuMzQ2LTEwLjE1MiAxMC40Mi0yOC42OSAxMC40Mi00MC4wNTYgMC0xMS43NjkgNy43NTUtMjUuNDQgMTUuNTEyLTI1LjkwNy02LjkxNSAxMS4zOTYgMS43OSAyMS4xNjUgOS41MyA0NS40IDIuOTAyIDkuMTAzIDIuNTMyIDI0LjQyMyA0Ljc3MiAzNC4xMzguNzQ0LTIwLjE3OCA0LjIxMy00OS42MiAxNy4wMTQtNTkuNzg0LTUuNjQ3IDEyLjguODM2IDI4LjgxOCA1LjI3IDM2LjUxOCA3LjE1NCAxMi40MjQgMTEuNDkgMjEuODM2IDExLjQ5IDM5LjYzOCAwIDExLjkzNi00LjQwNyAyMy4xNzMtMTEuODQgMzEuOTU4IDguNDUyLTEuNTg2IDE0LjI4OS0zLjAxNiAxNC4yODktMy4wMTZsMjcuNDUtNS4zNTVjLjAwMi0uMDAyLTMuOTg3IDE2LjQwMS0xOS4zMTQgMzIuMTk3eiIgZmlsbD0iI0RBNEUzMSIvPjwvc3ZnPg==","mediatype":"image/svg+xml"}],"install":{"spec":{"deployments":[{"name":"prometheus-operator","spec":{"replicas":1,"selector":{"matchLabels":{"k8s-app":"prometheus-operator"}},"template":{"metadata":{"labels":{"k8s-app":"prometheus-operator"}},"spec":{"containers":[{"args":["-namespace=$(K8S_NAMESPACE)","-manage-crds=false","-logtostderr=true","--config-reloader-image=quay.io/coreos/configmap-reload:v0.0.1","--prometheus-config-reloader=quay.io/coreos/prometheus-config-reloader:v0.22.2"],"env":[{"name":"K8S_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.namespace"}}}],"image":"quay.io/coreos/prometheus-operator@sha256:3daa69a8c6c2f1d35dcf1fe48a7cd8b230e55f5229a1ded438f687debade5bcf","name":"prometheus-operator","ports":[{"containerPort":8080,"name":"http"}],"resources":{"limits":{"cpu":"200m","memory":"100Mi"},"requests":{"cpu":"100m","memory":"50Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"readOnlyRootFilesystem":true}}],"nodeSelector":{"kubernetes.io/os":"linux"},"serviceAccount":"prometheus-operator-0-22-2"}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["nodes","services","endpoints","pods"],"verbs":["get","list","watch"]},{"apiGroups":[""],"resources":["configmaps"],"verbs":["get"]}],"serviceAccountName":"prometheus-k8s"},{"rules":[{"apiGroups":["apiextensions.k8s.io"],"resources":["customresourcedefinitions"],"verbs":["*"]},{"apiGroups":["monitoring.coreos.com"],"resources":["alertmanagers","prometheuses","prometheuses/finalizers","alertmanagers/finalizers","servicemonitors","prometheusrules"],"verbs":["*"]},{"apiGroups":["apps"],"resources":["statefulsets"],"verbs":["*"]},{"apiGroups":[""],"resources":["configmaps","secrets"],"verbs":["*"]},{"apiGroups":[""],"resources":["pods"],"verbs":["list","delete"]},{"apiGroups":[""],"resources":["services","endpoints"],"verbs":["get","create","update"]},{"apiGroups":[""],"resources":["nodes"],"verbs":["list","watch"]},{"apiGroups":[""],"resources":["namespaces"],"verbs":["list","watch"]}],"serviceAccountName":"prometheus-operator-0-22-2"}]},"strategy":"deployment"},"keywords":["prometheus","monitoring","tsdb","alerting"],"labels":{"alm-owner-prometheus":"prometheusoperator","alm-status-descriptors":"prometheusoperator.0.22.2"},"links":[{"name":"Prometheus","url":"https://www.prometheus.io/"},{"name":"Documentation","url":"https://coreos.com/operators/prometheus/docs/latest/"},{"name":"Prometheus Operator","url":"https://github.com/coreos/prometheus-operator"}],"maintainers":[{"email":"openshift-operators@redhat.com","name":"Red Hat"}],"maturity":"beta","provider":{"name":"Red Hat"},"replaces":"prometheusoperator.0.15.0","selector":{"matchLabels":{"alm-owner-prometheus":"prometheusoperator"}},"version":"0.22.2"}}`
+	etcdCSVJSON           = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"annotations\":{\"alm-examples\":\"[{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdCluster\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example\\\",\\\"namespace\\\":\\\"default\\\"},\\\"spec\\\":{\\\"size\\\":3,\\\"version\\\":\\\"3.2.13\\\"}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdRestore\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"spec\\\":{\\\"etcdCluster\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"backupStorageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdBackup\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster-backup\\\"},\\\"spec\\\":{\\\"etcdEndpoints\\\":[\\\"\\u003cetcd-cluster-endpoints\\u003e\\\"],\\\"storageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}}]\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"icon\":[{\"base64data\":\"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\",\"mediatype\":\"image/png\"}],\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"version\":\"0.9.2\"}}"
+	etcdWithLabelsCSVJSON = "{\"apiVersion\":\"operators.coreos.com/v1alpha1\",\"kind\":\"ClusterServiceVersion\",\"metadata\":{\"labels\": {\"test\": \"label\"},\"annotations\":{\"alm-examples\":\"[{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdCluster\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example\\\",\\\"namespace\\\":\\\"default\\\"},\\\"spec\\\":{\\\"size\\\":3,\\\"version\\\":\\\"3.2.13\\\"}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdRestore\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"spec\\\":{\\\"etcdCluster\\\":{\\\"name\\\":\\\"example-etcd-cluster\\\"},\\\"backupStorageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}},{\\\"apiVersion\\\":\\\"etcd.database.coreos.com/v1beta2\\\",\\\"kind\\\":\\\"EtcdBackup\\\",\\\"metadata\\\":{\\\"name\\\":\\\"example-etcd-cluster-backup\\\"},\\\"spec\\\":{\\\"etcdEndpoints\\\":[\\\"\\u003cetcd-cluster-endpoints\\u003e\\\"],\\\"storageType\\\":\\\"S3\\\",\\\"s3\\\":{\\\"path\\\":\\\"\\u003cfull-s3-path\\u003e\\\",\\\"awsSecret\\\":\\\"\\u003caws-secret\\u003e\\\"}}}]\",\"tectonic-visibility\":\"ocs\"},\"name\":\"etcdoperator.v0.9.2\",\"namespace\":\"placeholder\"},\"spec\":{\"customresourcedefinitions\":{\"owned\":[{\"description\":\"Represents a cluster of etcd nodes.\",\"displayName\":\"etcd Cluster\",\"kind\":\"EtcdCluster\",\"name\":\"etcdclusters.etcd.database.coreos.com\",\"resources\":[{\"kind\":\"Service\",\"version\":\"v1\"},{\"kind\":\"Pod\",\"version\":\"v1\"}],\"specDescriptors\":[{\"description\":\"The desired number of member Pods for the etcd cluster.\",\"displayName\":\"Size\",\"path\":\"size\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podCount\"]},{\"description\":\"Limits describes the minimum/maximum amount of compute resources required/allowed\",\"displayName\":\"Resource Requirements\",\"path\":\"pod.resources\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:resourceRequirements\"]}],\"statusDescriptors\":[{\"description\":\"The status of each of the member Pods for the etcd cluster.\",\"displayName\":\"Member Status\",\"path\":\"members\",\"x-descriptors\":[\"urn:alm:descriptor:com.tectonic.ui:podStatuses\"]},{\"description\":\"The service at which the running etcd cluster can be accessed.\",\"displayName\":\"Service\",\"path\":\"serviceName\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Service\"]},{\"description\":\"The current size of the etcd cluster.\",\"displayName\":\"Cluster Size\",\"path\":\"size\"},{\"description\":\"The current version of the etcd cluster.\",\"displayName\":\"Current Version\",\"path\":\"currentVersion\"},{\"description\":\"The target version of the etcd cluster, after upgrading.\",\"displayName\":\"Target Version\",\"path\":\"targetVersion\"},{\"description\":\"The current status of the etcd cluster.\",\"displayName\":\"Status\",\"path\":\"phase\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase\"]},{\"description\":\"Explanation for the current status of the cluster.\",\"displayName\":\"Status Details\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to backup an etcd cluster.\",\"displayName\":\"etcd Backup\",\"kind\":\"EtcdBackup\",\"name\":\"etcdbackups.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"Specifies the endpoints of an etcd cluster.\",\"displayName\":\"etcd Endpoint(s)\",\"path\":\"etcdEndpoints\",\"x-descriptors\":[\"urn:alm:descriptor:etcd:endpoint\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the backup was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any backup related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"},{\"description\":\"Represents the intent to restore an etcd cluster from a backup.\",\"displayName\":\"etcd Restore\",\"kind\":\"EtcdRestore\",\"name\":\"etcdrestores.etcd.database.coreos.com\",\"specDescriptors\":[{\"description\":\"References the EtcdCluster which should be restored,\",\"displayName\":\"etcd Cluster\",\"path\":\"etcdCluster.name\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:EtcdCluster\",\"urn:alm:descriptor:text\"]},{\"description\":\"The full AWS S3 path where the backup is saved.\",\"displayName\":\"S3 Path\",\"path\":\"s3.path\",\"x-descriptors\":[\"urn:alm:descriptor:aws:s3:path\"]},{\"description\":\"The name of the secret object that stores the AWS credential and config files.\",\"displayName\":\"AWS Secret\",\"path\":\"s3.awsSecret\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes:Secret\"]}],\"statusDescriptors\":[{\"description\":\"Indicates if the restore was successful.\",\"displayName\":\"Succeeded\",\"path\":\"succeeded\",\"x-descriptors\":[\"urn:alm:descriptor:text\"]},{\"description\":\"Indicates the reason for any restore related failures.\",\"displayName\":\"Reason\",\"path\":\"reason\",\"x-descriptors\":[\"urn:alm:descriptor:io.kubernetes.phase:reason\"]}],\"version\":\"v1beta2\"}]},\"description\":\"etcd is a distributed key value store that provides a reliable way to store data across a cluster of machines. It’s open-source and available on GitHub. etcd gracefully handles leader elections during network partitions and will tolerate machine failure, including the leader. Your applications can read and write data into etcd.\\nA simple use-case is to store database connection details or feature flags within etcd as key value pairs. These values can be watched, allowing your app to reconfigure itself when they change. Advanced uses take advantage of the consistency guarantees to implement database leader elections or do distributed locking across a cluster of workers.\\n\\n_The etcd Open Cloud Service is Public Alpha. The goal before Beta is to fully implement backup features._\\n\\n### Reading and writing to etcd\\n\\nCommunicate with etcd though its command line utility `etcdctl` or with the API using the automatically generated Kubernetes Service.\\n\\n[Read the complete guide to using the etcd Open Cloud Service](https://coreos.com/tectonic/docs/latest/alm/etcd-ocs.html)\\n\\n### Supported Features\\n\\n\\n**High availability**\\n\\n\\nMultiple instances of etcd are networked together and secured. Individual failures or networking issues are transparently handled to keep your cluster up and running.\\n\\n\\n**Automated updates**\\n\\n\\nRolling out a new etcd version works like all Kubernetes rolling updates. Simply declare the desired version, and the etcd service starts a safe rolling update to the new version automatically.\\n\\n\\n**Backups included**\\n\\n\\nComing soon, the ability to schedule backups to happen on or off cluster.\\n\",\"displayName\":\"etcd\",\"icon\":[{\"base64data\":\"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\",\"mediatype\":\"image/png\"}],\"install\":{\"spec\":{\"deployments\":[{\"name\":\"etcd-operator\",\"spec\":{\"replicas\":1,\"selector\":{\"matchLabels\":{\"name\":\"etcd-operator-alm-owned\"}},\"template\":{\"metadata\":{\"labels\":{\"name\":\"etcd-operator-alm-owned\"},\"name\":\"etcd-operator-alm-owned\"},\"spec\":{\"containers\":[{\"command\":[\"etcd-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-operator\"},{\"command\":[\"etcd-backup-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-backup-operator\"},{\"command\":[\"etcd-restore-operator\",\"--create-crd=false\"],\"env\":[{\"name\":\"MY_POD_NAMESPACE\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.namespace\"}}},{\"name\":\"MY_POD_NAME\",\"valueFrom\":{\"fieldRef\":{\"fieldPath\":\"metadata.name\"}}}],\"image\":\"quay.io/coreos/etcd-operator@sha256:c0301e4686c3ed4206e370b42de5a3bd2229b9fb4906cf85f3f30650424abec2\",\"name\":\"etcd-restore-operator\"}],\"serviceAccountName\":\"etcd-operator\"}}}}],\"permissions\":[{\"rules\":[{\"apiGroups\":[\"etcd.database.coreos.com\"],\"resources\":[\"etcdclusters\",\"etcdbackups\",\"etcdrestores\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"pods\",\"services\",\"endpoints\",\"persistentvolumeclaims\",\"events\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"apps\"],\"resources\":[\"deployments\"],\"verbs\":[\"*\"]},{\"apiGroups\":[\"\"],\"resources\":[\"secrets\"],\"verbs\":[\"get\"]}],\"serviceAccountName\":\"etcd-operator\"}]},\"strategy\":\"deployment\"},\"keywords\":[\"etcd\",\"key value\",\"database\",\"coreos\",\"open source\"],\"labels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"},\"links\":[{\"name\":\"Blog\",\"url\":\"https://coreos.com/etcd\"},{\"name\":\"Documentation\",\"url\":\"https://coreos.com/operators/etcd/docs/latest/\"},{\"name\":\"etcd Operator Source Code\",\"url\":\"https://github.com/coreos/etcd-operator\"}],\"maintainers\":[{\"email\":\"support@coreos.com\",\"name\":\"CoreOS, Inc\"}],\"maturity\":\"alpha\",\"provider\":{\"name\":\"CoreOS, Inc\"},\"replaces\":\"etcdoperator.v0.9.0\",\"selector\":{\"matchLabels\":{\"alm-owner-etcd\":\"etcdoperator\",\"operated-by\":\"etcdoperator\"}},\"version\":\"0.9.2\"}}"
+	etcdBackupsCRDJSON    = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdbackups.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdBackup\",\"listKind\":\"EtcdBackupList\",\"plural\":\"etcdbackups\",\"singular\":\"etcdbackup\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
+	etcdUpgradesCRDJSON   = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdclusters.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdCluster\",\"listKind\":\"EtcdClusterList\",\"plural\":\"etcdclusters\",\"shortNames\":[\"etcdclus\",\"etcd\"],\"singular\":\"etcdcluster\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
+	etcdRestoresCRDJSON   = "{\"apiVersion\":\"apiextensions.k8s.io/v1beta1\",\"kind\":\"CustomResourceDefinition\",\"metadata\":{\"name\":\"etcdrestores.etcd.database.coreos.com\"},\"spec\":{\"group\":\"etcd.database.coreos.com\",\"names\":{\"kind\":\"EtcdRestore\",\"listKind\":\"EtcdRestoreList\",\"plural\":\"etcdrestores\",\"singular\":\"etcdrestore\"},\"scope\":\"Namespaced\",\"version\":\"v1beta2\"}}"
+	prometheusCSVJSON     = `{"apiVersion":"operators.coreos.com/v1alpha1","kind":"ClusterServiceVersion","metadata":{"annotations":{"alm-examples":"[{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Prometheus\",\"metadata\":{\"name\":\"example\",\"labels\":{\"prometheus\":\"k8s\"}},\"spec\":{\"replicas\":2,\"version\":\"v2.3.2\",\"serviceAccountName\":\"prometheus-k8s\",\"securityContext\": {}, \"serviceMonitorSelector\":{\"matchExpressions\":[{\"key\":\"k8s-app\",\"operator\":\"Exists\"}]},\"ruleSelector\":{\"matchLabels\":{\"role\":\"prometheus-rulefiles\",\"prometheus\":\"k8s\"}},\"alerting\":{\"alertmanagers\":[{\"namespace\":\"monitoring\",\"name\":\"alertmanager-main\",\"port\":\"web\"}]}}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"ServiceMonitor\",\"metadata\":{\"name\":\"example\",\"labels\":{\"k8s-app\":\"prometheus\"}},\"spec\":{\"selector\":{\"matchLabels\":{\"k8s-app\":\"prometheus\"}},\"endpoints\":[{\"port\":\"web\",\"interval\":\"30s\"}]}},{\"apiVersion\":\"monitoring.coreos.com/v1\",\"kind\":\"Alertmanager\",\"metadata\":{\"name\":\"alertmanager-main\"},\"spec\":{\"replicas\":3, \"securityContext\": {}}}]"},"name":"prometheusoperator.0.22.2","namespace":"placeholder"},"spec":{"customresourcedefinitions":{"owned":[{"description":"A running Prometheus instance","displayName":"Prometheus","kind":"Prometheus","name":"prometheuses.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"A selector for the ConfigMaps from which to load rule files","displayName":"Rule Config Map Selector","path":"ruleSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:core:v1:ConfigMap"]},{"description":"ServiceMonitors to be selected for target discovery","displayName":"Service Monitor Selector","path":"serviceMonitorSelector","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:selector:monitoring.coreos.com:v1:ServiceMonitor"]},{"description":"The ServiceAccount to use to run the Prometheus pods","displayName":"Service Account","path":"serviceAccountName","x-descriptors":["urn:alm:descriptor:io.kubernetes:ServiceAccount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"},{"description":"A Prometheus Rule configures groups of sequentially evaluated recording and alerting rules.","displayName":"Prometheus Rule","kind":"PrometheusRule","name":"prometheusrules.monitoring.coreos.com","version":"v1"},{"description":"Configures prometheus to monitor a particular k8s service","displayName":"Service Monitor","kind":"ServiceMonitor","name":"servicemonitors.monitoring.coreos.com","resources":[{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"The label to use to retrieve the job name from","displayName":"Job Label","path":"jobLabel","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:label"]},{"description":"A list of endpoints allowed as part of this ServiceMonitor","displayName":"Endpoints","path":"endpoints","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:endpointList"]}],"version":"v1"},{"description":"Configures an Alertmanager for the namespace","displayName":"Alertmanager","kind":"Alertmanager","name":"alertmanagers.monitoring.coreos.com","resources":[{"kind":"StatefulSet","version":"v1beta2"},{"kind":"Pod","version":"v1"}],"specDescriptors":[{"description":"Desired number of Pods for the cluster","displayName":"Size","path":"replicas","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:podCount"]},{"description":"Limits describes the minimum/maximum amount of compute resources required/allowed","displayName":"Resource Requirements","path":"resources","x-descriptors":["urn:alm:descriptor:com.tectonic.ui:resourceRequirements"]}],"version":"v1"}]},"description":"The Prometheus Operator for Kubernetes provides easy monitoring definitions for Kubernetes services and deployment and management of Prometheus instances.\n\nOnce installed, the Prometheus Operator provides the following features:\n\n* **Create/Destroy**: Easily launch a Prometheus instance for your Kubernetes namespace, a specific application or team easily using the Operator.\n\n* **Simple Configuration**: Configure the fundamentals of Prometheus like versions, persistence, retention policies, and replicas from a native Kubernetes resource.\n\n* **Target Services via Labels**: Automatically generate monitoring target configurations based on familiar Kubernetes label queries; no need to learn a Prometheus specific configuration language.\n\n### Other Supported Features\n\n**High availability**\n\nMultiple instances are run across failure zones and data is replicated. This keeps your monitoring available during an outage, when you need it most.\n\n**Updates via automated operations**\n\nNew Prometheus versions are deployed using a rolling update with no downtime, making it easy to stay up to date.\n\n**Handles the dynamic nature of containers**\n\nAlerting rules are attached to groups of containers instead of individual instances, which is ideal for the highly dynamic nature of container deployment.\n","displayName":"Prometheus Operator","icon":[{"base64data":"PHN2ZyB3aWR0aD0iMjQ5MCIgaGVpZ2h0PSIyNTAwIiB2aWV3Qm94PSIwIDAgMjU2IDI1NyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBwcmVzZXJ2ZUFzcGVjdFJhdGlvPSJ4TWlkWU1pZCI+PHBhdGggZD0iTTEyOC4wMDEuNjY3QzU3LjMxMS42NjcgMCA1Ny45NzEgMCAxMjguNjY0YzAgNzAuNjkgNTcuMzExIDEyNy45OTggMTI4LjAwMSAxMjcuOTk4UzI1NiAxOTkuMzU0IDI1NiAxMjguNjY0QzI1NiA1Ny45NyAxOTguNjg5LjY2NyAxMjguMDAxLjY2N3ptMCAyMzkuNTZjLTIwLjExMiAwLTM2LjQxOS0xMy40MzUtMzYuNDE5LTMwLjAwNGg3Mi44MzhjMCAxNi41NjYtMTYuMzA2IDMwLjAwNC0zNi40MTkgMzAuMDA0em02MC4xNTMtMzkuOTRINjcuODQyVjE3OC40N2gxMjAuMzE0djIxLjgxNmgtLjAwMnptLS40MzItMzMuMDQ1SDY4LjE4NWMtLjM5OC0uNDU4LS44MDQtLjkxLTEuMTg4LTEuMzc1LTEyLjMxNS0xNC45NTQtMTUuMjE2LTIyLjc2LTE4LjAzMi0zMC43MTYtLjA0OC0uMjYyIDE0LjkzMyAzLjA2IDI1LjU1NiA1LjQ1IDAgMCA1LjQ2NiAxLjI2NSAxMy40NTggMi43MjItNy42NzMtOC45OTQtMTIuMjMtMjAuNDI4LTEyLjIzLTMyLjExNiAwLTI1LjY1OCAxOS42OC00OC4wNzkgMTIuNTgtNjYuMjAxIDYuOTEuNTYyIDE0LjMgMTQuNTgzIDE0LjggMzYuNTA1IDcuMzQ2LTEwLjE1MiAxMC40Mi0yOC42OSAxMC40Mi00MC4wNTYgMC0xMS43NjkgNy43NTUtMjUuNDQgMTUuNTEyLTI1LjkwNy02LjkxNSAxMS4zOTYgMS43OSAyMS4xNjUgOS41MyA0NS40IDIuOTAyIDkuMTAzIDIuNTMyIDI0LjQyMyA0Ljc3MiAzNC4xMzguNzQ0LTIwLjE3OCA0LjIxMy00OS42MiAxNy4wMTQtNTkuNzg0LTUuNjQ3IDEyLjguODM2IDI4LjgxOCA1LjI3IDM2LjUxOCA3LjE1NCAxMi40MjQgMTEuNDkgMjEuODM2IDExLjQ5IDM5LjYzOCAwIDExLjkzNi00LjQwNyAyMy4xNzMtMTEuODQgMzEuOTU4IDguNDUyLTEuNTg2IDE0LjI4OS0zLjAxNiAxNC4yODktMy4wMTZsMjcuNDUtNS4zNTVjLjAwMi0uMDAyLTMuOTg3IDE2LjQwMS0xOS4zMTQgMzIuMTk3eiIgZmlsbD0iI0RBNEUzMSIvPjwvc3ZnPg==","mediatype":"image/svg+xml"}],"install":{"spec":{"deployments":[{"name":"prometheus-operator","spec":{"replicas":1,"selector":{"matchLabels":{"k8s-app":"prometheus-operator"}},"template":{"metadata":{"labels":{"k8s-app":"prometheus-operator"}},"spec":{"containers":[{"args":["-namespace=$(K8S_NAMESPACE)","-manage-crds=false","-logtostderr=true","--config-reloader-image=quay.io/coreos/configmap-reload:v0.0.1","--prometheus-config-reloader=quay.io/coreos/prometheus-config-reloader:v0.22.2"],"env":[{"name":"K8S_NAMESPACE","valueFrom":{"fieldRef":{"fieldPath":"metadata.namespace"}}}],"image":"quay.io/coreos/prometheus-operator@sha256:3daa69a8c6c2f1d35dcf1fe48a7cd8b230e55f5229a1ded438f687debade5bcf","name":"prometheus-operator","ports":[{"containerPort":8080,"name":"http"}],"resources":{"limits":{"cpu":"200m","memory":"100Mi"},"requests":{"cpu":"100m","memory":"50Mi"}},"securityContext":{"allowPrivilegeEscalation":false,"readOnlyRootFilesystem":true}}],"nodeSelector":{"kubernetes.io/os":"linux"},"serviceAccount":"prometheus-operator-0-22-2"}}}}],"permissions":[{"rules":[{"apiGroups":[""],"resources":["nodes","services","endpoints","pods"],"verbs":["get","list","watch"]},{"apiGroups":[""],"resources":["configmaps"],"verbs":["get"]}],"serviceAccountName":"prometheus-k8s"},{"rules":[{"apiGroups":["apiextensions.k8s.io"],"resources":["customresourcedefinitions"],"verbs":["*"]},{"apiGroups":["monitoring.coreos.com"],"resources":["alertmanagers","prometheuses","prometheuses/finalizers","alertmanagers/finalizers","servicemonitors","prometheusrules"],"verbs":["*"]},{"apiGroups":["apps"],"resources":["statefulsets"],"verbs":["*"]},{"apiGroups":[""],"resources":["configmaps","secrets"],"verbs":["*"]},{"apiGroups":[""],"resources":["pods"],"verbs":["list","delete"]},{"apiGroups":[""],"resources":["services","endpoints"],"verbs":["get","create","update"]},{"apiGroups":[""],"resources":["nodes"],"verbs":["list","watch"]},{"apiGroups":[""],"resources":["namespaces"],"verbs":["list","watch"]}],"serviceAccountName":"prometheus-operator-0-22-2"}]},"strategy":"deployment"},"keywords":["prometheus","monitoring","tsdb","alerting"],"labels":{"alm-owner-prometheus":"prometheusoperator","alm-status-descriptors":"prometheusoperator.0.22.2"},"links":[{"name":"Prometheus","url":"https://www.prometheus.io/"},{"name":"Documentation","url":"https://coreos.com/operators/prometheus/docs/latest/"},{"name":"Prometheus Operator","url":"https://github.com/coreos/prometheus-operator"}],"maintainers":[{"email":"openshift-operators@redhat.com","name":"Red Hat"}],"maturity":"beta","provider":{"name":"Red Hat"},"replaces":"prometheusoperator.0.15.0","selector":{"matchLabels":{"alm-owner-prometheus":"prometheusoperator"}},"version":"0.22.2"}}`
 )
 
 func TestToPackageManifest(t *testing.T) {
diff --git a/staging/operator-lifecycle-manager/pkg/package-server/storage/printer.go b/staging/operator-lifecycle-manager/pkg/package-server/storage/printer.go
index dece00662e..a0eb2f8af8 100644
--- a/staging/operator-lifecycle-manager/pkg/package-server/storage/printer.go
+++ b/staging/operator-lifecycle-manager/pkg/package-server/storage/printer.go
@@ -30,7 +30,6 @@ func addTableHandlers(h printers.PrintHandler) {
 	}
 	h.TableHandler(podColumnDefinitions, printPackage)
 	h.TableHandler(podColumnDefinitions, printPackageList)
-
 }
 
 func printPackage(manifest *operators.PackageManifest, options printers.GenerateOptions) ([]metav1beta1.TableRow, error) {
diff --git a/staging/operator-lifecycle-manager/test/e2e/catsrc_pod_config_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/catsrc_pod_config_e2e_test.go
index 8d07b4700f..6aebb6a301 100644
--- a/staging/operator-lifecycle-manager/test/e2e/catsrc_pod_config_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/catsrc_pod_config_e2e_test.go
@@ -2,7 +2,6 @@ package e2e
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	. "github.com/onsi/ginkgo"
@@ -176,7 +175,7 @@ func mustGetCatalogSourcePod(client k8scontrollerclient.Client, catalogSource *v
 			return err
 		}
 		if len(podList.Items) != 1 {
-			return errors.New(fmt.Sprintf("expecting one catalog source pod but found %d", len(podList.Items)))
+			return fmt.Errorf("expecting one catalog source pod but found %d", len(podList.Items))
 		}
 		return nil
 	}).Should(BeNil())
diff --git a/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go
index 6d3e95ee8c..b76dd88487 100644
--- a/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/csv_e2e_test.go
@@ -4405,7 +4405,7 @@ var _ = Describe("Disabling copied CSVs", func() {
 
 				expectedCondition := metav1.Condition{
 					Reason:  "CopiedCSVsEnabled",
-					Message: "Copied CSVs are enabled and present accross the cluster",
+					Message: "Copied CSVs are enabled and present across the cluster",
 					Status:  metav1.ConditionFalse,
 				}
 
@@ -4423,8 +4423,6 @@ var _ = Describe("Disabling copied CSVs", func() {
 
 var singleInstance = int32(1)
 
-type cleanupFunc func()
-
 var immediateDeleteGracePeriod int64 = 0
 
 func findLastEvent(events *corev1.EventList) (event corev1.Event) {
@@ -4465,7 +4463,6 @@ func buildCSVCleanupFunc(c operatorclient.ClientInterface, crc versioned.Interfa
 			return err
 		})
 		Expect(err).ShouldNot(HaveOccurred())
-
 	}
 }
 
@@ -4482,7 +4479,6 @@ func createCSV(c operatorclient.ClientInterface, crc versioned.Interface, csv op
 	}).Should(Succeed())
 
 	return buildCSVCleanupFunc(c, crc, csv, namespace, cleanupCRDs, cleanupAPIServices), nil
-
 }
 
 func buildCRDCleanupFunc(c operatorclient.ClientInterface, crdName string) cleanupFunc {
@@ -4593,7 +4589,6 @@ type mockGroupVersionKind struct {
 }
 
 func newMockExtServerDeployment(labelName string, mGVKs []mockGroupVersionKind) appsv1.DeploymentSpec {
-
 	// Create the list of containers
 	containers := []corev1.Container{}
 	for _, mGVK := range mGVKs {
@@ -4742,7 +4737,6 @@ func waitForDeploymentToDelete(c operatorclient.ClientInterface, name string) er
 }
 
 func csvExists(c versioned.Interface, name string) bool {
-
 	fetched, err := c.OperatorsV1alpha1().ClusterServiceVersions(testNamespace).Get(context.TODO(), name, metav1.GetOptions{})
 	if k8serrors.IsNotFound(err) {
 		return false
diff --git a/staging/operator-lifecycle-manager/test/e2e/ctx/ctx.go b/staging/operator-lifecycle-manager/test/e2e/ctx/ctx.go
index c20d986635..cf1154a196 100644
--- a/staging/operator-lifecycle-manager/test/e2e/ctx/ctx.go
+++ b/staging/operator-lifecycle-manager/test/e2e/ctx/ctx.go
@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	. "github.com/onsi/ginkgo"
+	g "github.com/onsi/ginkgo"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/dynamic"
@@ -57,7 +57,7 @@ func (ctx TestContext) Logf(f string, v ...interface{}) {
 	if !strings.HasSuffix(f, "\n") {
 		f += "\n"
 	}
-	fmt.Fprintf(GinkgoWriter, f, v...)
+	fmt.Fprintf(g.GinkgoWriter, f, v...)
 }
 
 func (ctx TestContext) Scheme() *runtime.Scheme {
diff --git a/staging/operator-lifecycle-manager/test/e2e/deprecated_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/deprecated_e2e_test.go
index 25ef916b20..cadb2489b7 100644
--- a/staging/operator-lifecycle-manager/test/e2e/deprecated_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/deprecated_e2e_test.go
@@ -34,8 +34,7 @@ var _ = Describe("Not found APIs", func() {
 			errMessage string
 		}
 
-		var tableEntries []table.TableEntry
-		tableEntries = []table.TableEntry{
+		tableEntries := []table.TableEntry{
 			table.Entry("contains an entry with a missing API not found on cluster ", payload{
 				name: "installplan contains a missing API",
 				IP: &operatorsv1alpha1.InstallPlan{
diff --git a/staging/operator-lifecycle-manager/test/e2e/dsl/dsl.go b/staging/operator-lifecycle-manager/test/e2e/dsl/dsl.go
index 11086aedad..c50479df3b 100644
--- a/staging/operator-lifecycle-manager/test/e2e/dsl/dsl.go
+++ b/staging/operator-lifecycle-manager/test/e2e/dsl/dsl.go
@@ -3,7 +3,7 @@ package dsl
 import (
 	"fmt"
 
-	. "github.com/onsi/ginkgo"
+	g "github.com/onsi/ginkgo"
 )
 
 // IgnoreError acknowledges that an error value is being intentionally
@@ -26,5 +26,5 @@ func IgnoreError(vals ...interface{}) {
 	if _, ok := err.(error); ok {
 		return
 	}
-	Fail(fmt.Sprintf("the last argument to IgnoreError must be an error, but it was %T", err))
+	g.Fail(fmt.Sprintf("the last argument to IgnoreError must be an error, but it was %T", err))
 }
diff --git a/staging/operator-lifecycle-manager/test/e2e/fbc_provider.go b/staging/operator-lifecycle-manager/test/e2e/fbc_provider.go
new file mode 100644
index 0000000000..e02170d0f8
--- /dev/null
+++ b/staging/operator-lifecycle-manager/test/e2e/fbc_provider.go
@@ -0,0 +1,28 @@
+package e2e
+
+import (
+	"io/ioutil"
+)
+
+type FileBasedCatalogProvider interface {
+	GetCatalog() string
+}
+
+type fileBasedFileBasedCatalogProvider struct {
+	fbc string
+}
+
+func NewFileBasedFiledBasedCatalogProvider(path string) (FileBasedCatalogProvider, error) {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &fileBasedFileBasedCatalogProvider{
+		fbc: string(data),
+	}, nil
+}
+
+func (f *fileBasedFileBasedCatalogProvider) GetCatalog() string {
+	return f.fbc
+}
diff --git a/staging/operator-lifecycle-manager/test/e2e/installplan_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/installplan_e2e_test.go
index a31423e482..5aad9dd80b 100644
--- a/staging/operator-lifecycle-manager/test/e2e/installplan_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/installplan_e2e_test.go
@@ -4208,7 +4208,7 @@ func newCSV(name, namespace, replaces string, version semver.Version, owned []ap
 		},
 		Spec: operatorsv1alpha1.ClusterServiceVersionSpec{
 			Replaces:       replaces,
-			Version:        opver.OperatorVersion{version},
+			Version:        opver.OperatorVersion{Version: version},
 			MinKubeVersion: "0.0.0",
 			InstallModes: []operatorsv1alpha1.InstallMode{
 				{
diff --git a/staging/operator-lifecycle-manager/test/e2e/magic_catalog.go b/staging/operator-lifecycle-manager/test/e2e/magic_catalog.go
new file mode 100644
index 0000000000..022bbcaedb
--- /dev/null
+++ b/staging/operator-lifecycle-manager/test/e2e/magic_catalog.go
@@ -0,0 +1,280 @@
+package e2e
+
+import (
+	"context"
+	"fmt"
+
+	operatorsv1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
+	corev1 "k8s.io/api/core/v1"
+	k8serror "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+	k8scontrollerclient "sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+const (
+	olmCatalogLabel    string = "olm.catalogSource"
+	catalogMountPath   string = "/opt/olm"
+	catalogServicePort int32  = 50051
+	catalogReadyState  string = "READY"
+)
+
+type MagicCatalog interface {
+	DeployCatalog(ctx context.Context) error
+	UndeployCatalog(ctx context.Context) []error
+}
+
+type magicCatalog struct {
+	fileBasedCatalog FileBasedCatalogProvider
+	kubeClient       k8scontrollerclient.Client
+	namespace        string
+	name             string
+	configMapName    string
+	serviceName      string
+	podName          string
+}
+
+// NewMagicCatalog creates an object that can deploy an arbitrary file-based catalog given by the FileBasedCatalogProvider
+// Keep in mind that there are limits to the configMaps. So, the catalogs need to be relatively simple
+func NewMagicCatalog(kubeClient k8scontrollerclient.Client, namespace string, catalogName string, provider FileBasedCatalogProvider) MagicCatalog {
+	return &magicCatalog{
+		fileBasedCatalog: provider,
+		kubeClient:       kubeClient,
+		namespace:        namespace,
+		name:             catalogName,
+		configMapName:    catalogName + "-configmap",
+		serviceName:      catalogName + "-svc",
+		podName:          catalogName + "-pod",
+	}
+}
+
+func (c *magicCatalog) DeployCatalog(ctx context.Context) error {
+
+	catalogSource := c.makeCatalogSource()
+	resourcesInOrderOfDeployment := []k8scontrollerclient.Object{
+		c.makeConfigMap(),
+		c.makeCatalogSourcePod(),
+		c.makeCatalogService(),
+		catalogSource,
+	}
+
+	for _, res := range resourcesInOrderOfDeployment {
+		err := c.kubeClient.Create(ctx, res)
+		if err != nil {
+			return c.cleanUpAfter(ctx, err)
+		}
+	}
+
+	// wait for catalog source to become ready
+	err := waitFor(func() (bool, error) {
+		err := c.kubeClient.Get(ctx, k8scontrollerclient.ObjectKey{
+			Name:      catalogSource.GetName(),
+			Namespace: catalogSource.GetNamespace(),
+		}, catalogSource)
+
+		if err != nil || catalogSource.Status.GRPCConnectionState == nil {
+			return false, err
+		}
+
+		state := catalogSource.Status.GRPCConnectionState.LastObservedState
+
+		if state != catalogReadyState {
+			return false, nil
+		} else {
+			return true, nil
+		}
+	})
+
+	if err != nil {
+		return c.cleanUpAfter(ctx, err)
+	}
+
+	return nil
+}
+
+func (c *magicCatalog) UndeployCatalog(ctx context.Context) []error {
+	var errs []error = nil
+
+	resourcesInOrderOfDeletion := []k8scontrollerclient.Object{
+		c.makeCatalogSource(),
+		c.makeCatalogService(),
+		c.makeCatalogSourcePod(),
+		c.makeConfigMap(),
+	}
+
+	// try to delete all resourcesInOrderOfDeletion even if errors are
+	// encountered through deletion.
+	for _, res := range resourcesInOrderOfDeletion {
+		err := c.kubeClient.Delete(ctx, res)
+
+		// ignore not found errors
+		if err != nil && !k8serror.IsNotFound(err) {
+			if errs == nil {
+				errs = make([]error, 0)
+			}
+			errs = append(errs, err)
+		}
+	}
+
+	return errs
+}
+
+func (c *magicCatalog) cleanUpAfter(ctx context.Context, err error) error {
+	cleanupErr := c.UndeployCatalog(ctx)
+	if cleanupErr != nil {
+		return fmt.Errorf("the following cleanup errors occurred: '%s' after an error deploying the configmap: '%s' ", cleanupErr, err)
+	}
+	return err
+}
+
+func (c *magicCatalog) makeCatalogService() *corev1.Service {
+	return &corev1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      c.serviceName,
+			Namespace: c.namespace,
+		},
+		Spec: corev1.ServiceSpec{
+			Ports: []corev1.ServicePort{
+				{
+					Name:       "grpc",
+					Port:       catalogServicePort,
+					Protocol:   "TCP",
+					TargetPort: intstr.FromInt(int(catalogServicePort)),
+				},
+			},
+			Selector: c.makeCatalogSourcePodLabels(),
+		},
+	}
+}
+
+func (c *magicCatalog) makeConfigMap() *corev1.ConfigMap {
+	isImmutable := true
+	return &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      c.configMapName,
+			Namespace: c.namespace,
+		},
+		Immutable: &isImmutable,
+		Data: map[string]string{
+			"catalog.json": c.fileBasedCatalog.GetCatalog(),
+			// due to the way files get mounted to pods from configMaps
+			// it is important to add _this_ .indexignore
+			//
+			// The mount folder will look something like this:
+			// /opt/olm
+			// |--> ..2021_12_15_02_01_11.729011450
+			//      |--> catalog.json
+			//      |--> .indexignore
+			// |--> ..data -> ..2021_12_15_02_01_11.729011450
+			// |--> catalog.json -> ..data/catalog.json
+			// |--> .indexignore -> ..data/.indexignore
+			// Adding '**/..*' to the .indexignore ensures the
+			// '..2021_12_15_02_01_11.729011450' and ' ..data' directories are ignored.
+			// Otherwise, opm will pick up on both catalog.json files and fail with a conflicts (duplicate packages)
+			".indexignore": "**/\\.\\.*\n",
+		},
+	}
+}
+
+func (c *magicCatalog) makeCatalogSource() *operatorsv1alpha1.CatalogSource {
+	return &operatorsv1alpha1.CatalogSource{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      c.name,
+			Namespace: c.namespace,
+		},
+		Spec: operatorsv1alpha1.CatalogSourceSpec{
+			SourceType: operatorsv1alpha1.SourceTypeGrpc,
+			Address:    fmt.Sprintf("%s.%s.svc:50051", c.serviceName, c.namespace),
+		},
+	}
+}
+
+func (c *magicCatalog) makeCatalogSourcePod() *corev1.Pod {
+
+	const (
+		image                  = "quay.io/operator-framework/upstream-opm-builder"
+		readinessDelay  int32  = 5
+		livenessDelay   int32  = 10
+		volumeMountName string = "fbc-catalog"
+	)
+
+	readOnlyRootFilesystem := false
+
+	return &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      c.podName,
+			Namespace: c.namespace,
+			Labels:    c.makeCatalogSourcePodLabels(),
+		},
+		Spec: corev1.PodSpec{
+			Containers: []corev1.Container{
+				{
+					Name:    "catalog",
+					Image:   image,
+					Command: []string{"opm", "serve", catalogMountPath},
+					Ports: []corev1.ContainerPort{
+						{
+							Name:          "grpc",
+							ContainerPort: 50051,
+						},
+					},
+					ReadinessProbe: &corev1.Probe{
+						Handler: corev1.Handler{
+							Exec: &corev1.ExecAction{
+								Command: []string{"grpc_health_probe", "-addr=:50051"},
+							},
+						},
+						InitialDelaySeconds: readinessDelay,
+						TimeoutSeconds:      5,
+					},
+					LivenessProbe: &corev1.Probe{
+						Handler: corev1.Handler{
+							Exec: &corev1.ExecAction{
+								Command: []string{"grpc_health_probe", "-addr=:50051"},
+							},
+						},
+						InitialDelaySeconds: livenessDelay,
+						TimeoutSeconds:      5,
+					},
+					Resources: corev1.ResourceRequirements{
+						Requests: corev1.ResourceList{
+							corev1.ResourceCPU:    resource.MustParse("10m"),
+							corev1.ResourceMemory: resource.MustParse("50Mi"),
+						},
+					},
+					SecurityContext: &corev1.SecurityContext{
+						ReadOnlyRootFilesystem: &readOnlyRootFilesystem,
+					},
+					ImagePullPolicy:          corev1.PullAlways,
+					TerminationMessagePolicy: corev1.TerminationMessageFallbackToLogsOnError,
+					VolumeMounts: []corev1.VolumeMount{
+						{
+							Name:      volumeMountName,
+							MountPath: catalogMountPath,
+							ReadOnly:  true,
+						},
+					},
+				},
+			},
+			Volumes: []corev1.Volume{
+				{
+					Name: volumeMountName,
+					VolumeSource: corev1.VolumeSource{
+						ConfigMap: &corev1.ConfigMapVolumeSource{
+							LocalObjectReference: corev1.LocalObjectReference{
+								Name: c.configMapName,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func (c *magicCatalog) makeCatalogSourcePodLabels() map[string]string {
+	return map[string]string{
+		olmCatalogLabel: c.name,
+	}
+}
diff --git a/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go b/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go
new file mode 100644
index 0000000000..57b2d52e84
--- /dev/null
+++ b/staging/operator-lifecycle-manager/test/e2e/magic_catalog_test.go
@@ -0,0 +1,40 @@
+package e2e
+
+import (
+	"context"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/operator-framework/operator-lifecycle-manager/test/e2e/ctx"
+	corev1 "k8s.io/api/core/v1"
+)
+
+var _ = Describe("MagicCatalog", func() {
+	var (
+		generatedNamespace corev1.Namespace
+	)
+
+	BeforeEach(func() {
+		generatedNamespace = SetupGeneratedTestNamespace(genName("magic-catalog-e2e-"))
+	})
+
+	AfterEach(func() {
+		TeardownNamespace(generatedNamespace.GetName())
+	})
+
+	It("Deploys and Undeploys a File-based Catalog", func() {
+		// create dependencies
+		const catalogName = "test"
+		namespace := generatedNamespace.GetName()
+		kubeClient := ctx.Ctx().Client()
+		provider, err := NewFileBasedFiledBasedCatalogProvider("../test/e2e/testdata/fbc_catalog.json")
+		Expect(err).To(BeNil())
+
+		// create and deploy and undeploy the magic catalog
+		magicCatalog := NewMagicCatalog(kubeClient, namespace, catalogName, provider)
+
+		// deployment blocks until the catalog source has reached a READY status
+		Expect(magicCatalog.DeployCatalog(context.TODO())).To(BeNil())
+		Expect(magicCatalog.UndeployCatalog(context.TODO())).To(BeNil())
+	})
+})
diff --git a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go
index 969779cee3..7af20a6c8e 100644
--- a/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/operator_groups_e2e_test.go
@@ -292,7 +292,6 @@ var _ = Describe("Operator Group", func() {
 		stopCh := make(chan struct{})
 		defer func() {
 			stopCh <- struct{}{}
-			return
 		}()
 
 		for _, informer := range []cache.SharedIndexInformer{roleInformer.Informer(), roleBindingInformer.Informer(), clusterRoleInformer.Informer(), clusterRoleBindingInformer.Informer()} {
@@ -2438,7 +2437,6 @@ func updateOperatorGroupSpecFunc(t GinkgoTInterface, crc versioned.Interface, na
 }
 
 func pollForNamespaceListCount(c operatorclient.ClientInterface, listOptions metav1.ListOptions, expectedLength int) (list *corev1.NamespaceList, err error) {
-
 	Eventually(func() (bool, error) {
 		list, err = c.KubernetesInterface().CoreV1().Namespaces().List(context.TODO(), listOptions)
 		if err != nil {
diff --git a/staging/operator-lifecycle-manager/test/e2e/operator_test.go b/staging/operator-lifecycle-manager/test/e2e/operator_test.go
index 341bcd97a4..033962251f 100644
--- a/staging/operator-lifecycle-manager/test/e2e/operator_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/operator_test.go
@@ -454,7 +454,7 @@ func (matcher *copiedCSVRefMatcher) Match(actual interface{}) (success bool, err
 func (matcher *copiedCSVRefMatcher) FailureMessage(actual interface{}) (message string) {
 	operator, ok := actual.(*operatorsv1.Operator)
 	if !ok {
-		return fmt.Sprintf("copiedCSVRefMatcher matcher expects an *Operator")
+		return "copiedCSVRefMatcher matcher expects an *Operator"
 	}
 	return fmt.Sprintf("Expected\n\t%#v\nto contain copied CSVs in components\n\t%#v\n", operator, operator.Status.Components)
 }
@@ -462,7 +462,7 @@ func (matcher *copiedCSVRefMatcher) FailureMessage(actual interface{}) (message
 func (matcher *copiedCSVRefMatcher) NegatedFailureMessage(actual interface{}) (message string) {
 	operator, ok := actual.(*operatorsv1.Operator)
 	if !ok {
-		return fmt.Sprintf("copiedCSVRefMatcher matcher expects an *Operator")
+		return "copiedCSVRefMatcher matcher expects an *Operator"
 	}
 	return fmt.Sprintf("Expected\n\t%#v\nto not contain copied CSVs in components\n\t%#v\n", operator, operator.Status.Components)
 }
diff --git a/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go
index 153a608612..1e7dcb13fb 100644
--- a/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/packagemanifest_e2e_test.go
@@ -100,7 +100,7 @@ var _ = Describe("Package Manifest API lists available Operators from Catalog So
 
 			csvAlpha = *csv.DeepCopy()
 			csvAlpha.SetName(packageAlpha)
-			csvAlpha.Spec.Version = opver.OperatorVersion{semver.MustParse("0.1.1")}
+			csvAlpha.Spec.Version = opver.OperatorVersion{Version: semver.MustParse("0.1.1")}
 			csvAlpha.Spec.Replaces = csv.GetName()
 			csvAlpha.Spec.Icon = []v1alpha1.Icon{
 				{
diff --git a/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go
index 3d4f16f58f..b0454bce38 100644
--- a/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/subscription_e2e_test.go
@@ -2353,7 +2353,7 @@ var (
 		},
 		Spec: operatorsv1alpha1.ClusterServiceVersionSpec{
 			Replaces:       "",
-			Version:        version.OperatorVersion{semver.MustParse("0.1.0")},
+			Version:        version.OperatorVersion{Version: semver.MustParse("0.1.0")},
 			MinKubeVersion: "0.0.0",
 			InstallModes: []operatorsv1alpha1.InstallMode{
 				{
@@ -2383,7 +2383,7 @@ var (
 		},
 		Spec: operatorsv1alpha1.ClusterServiceVersionSpec{
 			Replaces:       outdated,
-			Version:        version.OperatorVersion{semver.MustParse("0.2.0")},
+			Version:        version.OperatorVersion{Version: semver.MustParse("0.2.0")},
 			MinKubeVersion: "0.0.0",
 			InstallModes: []operatorsv1alpha1.InstallMode{
 				{
@@ -2413,7 +2413,7 @@ var (
 		},
 		Spec: operatorsv1alpha1.ClusterServiceVersionSpec{
 			Replaces: stable,
-			Version:  version.OperatorVersion{semver.MustParse("0.1.1")},
+			Version:  version.OperatorVersion{Version: semver.MustParse("0.1.1")},
 			InstallModes: []operatorsv1alpha1.InstallMode{
 				{
 					Type:      operatorsv1alpha1.InstallModeTypeOwnNamespace,
@@ -2442,7 +2442,7 @@ var (
 		},
 		Spec: operatorsv1alpha1.ClusterServiceVersionSpec{
 			Replaces: beta,
-			Version:  version.OperatorVersion{semver.MustParse("0.3.0")},
+			Version:  version.OperatorVersion{Version: semver.MustParse("0.3.0")},
 			InstallModes: []operatorsv1alpha1.InstallMode{
 				{
 					Type:      operatorsv1alpha1.InstallModeTypeOwnNamespace,
@@ -2534,7 +2534,6 @@ func init() {
 }
 
 func initCatalog(t GinkgoTInterface, namespace string, c operatorclient.ClientInterface, crc versioned.Interface) error {
-
 	dummyCatalogConfigMap.SetNamespace(namespace)
 	if _, err := c.KubernetesInterface().CoreV1().ConfigMaps(namespace).Create(context.Background(), dummyCatalogConfigMap, metav1.CreateOptions{}); err != nil {
 		if k8serrors.IsAlreadyExists(err) {
@@ -2638,9 +2637,7 @@ func fetchSubscription(crc versioned.Interface, namespace, name string, checker
 
 func buildSubscriptionCleanupFunc(crc versioned.Interface, subscription *operatorsv1alpha1.Subscription) cleanupFunc {
 	return func() {
-
 		if installPlanRef := subscription.Status.InstallPlanRef; installPlanRef != nil {
-
 			installPlan, err := crc.OperatorsV1alpha1().InstallPlans(subscription.GetNamespace()).Get(context.Background(), installPlanRef.Name, metav1.GetOptions{})
 			if err == nil {
 				buildInstallPlanCleanupFunc(crc, subscription.GetNamespace(), installPlan)()
diff --git a/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json b/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json
new file mode 100644
index 0000000000..c6c7ee6815
--- /dev/null
+++ b/staging/operator-lifecycle-manager/test/e2e/testdata/fbc_catalog.json
@@ -0,0 +1,38 @@
+{
+  "schema": "olm.package",
+  "name": "packageA",
+  "defaultChannel": "stable"
+}
+{
+  "schema": "olm.channel",
+  "name": "stable",
+  "package": "packageA",
+  "entries": [
+    {
+      "name": "packageA.v1.0.0"
+    }
+  ]
+}
+{
+  "schema": "olm.bundle",
+  "name": "packageA.v1.0.0",
+  "package": "packageA",
+  "image": "packageA:v1.0.0",
+  "properties": [
+    {
+      "type": "olm.gvk",
+      "value": {
+        "group": "example.com",
+        "kind": "TestA",
+        "version": "v1alpha1"
+      }
+    },
+    {
+      "type": "olm.package",
+      "value": {
+        "packageName": "packageA",
+        "version": "1.0.0"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/staging/operator-lifecycle-manager/test/e2e/util_test.go b/staging/operator-lifecycle-manager/test/e2e/util.go
similarity index 94%
rename from staging/operator-lifecycle-manager/test/e2e/util_test.go
rename to staging/operator-lifecycle-manager/test/e2e/util.go
index 88f7a03788..052dbc180c 100644
--- a/staging/operator-lifecycle-manager/test/e2e/util_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/util.go
@@ -77,6 +77,15 @@ func newPMClient() pmversioned.Interface {
 	return ctx.Ctx().PackageClient()
 }
 
+type cleanupFunc func()
+
+// waitFor wraps wait.Pool with default polling parameters
+func waitFor(fn func() (bool, error)) error {
+	return wait.Poll(pollInterval, pollDuration, func() (bool, error) {
+		return fn()
+	})
+}
+
 // awaitPods waits for a set of pods to exist in the cluster
 func awaitPods(t GinkgoTInterface, c operatorclient.ClientInterface, namespace, selector string, checkPods podsCheckFunc) (*corev1.PodList, error) {
 	var fetchedPodList *corev1.PodList
@@ -198,8 +207,7 @@ func awaitPod(t GinkgoTInterface, c operatorclient.ClientInterface, namespace, n
 }
 
 func awaitAnnotations(t GinkgoTInterface, query func() (metav1.ObjectMeta, error), expected map[string]string) error {
-	var err error
-	err = wait.Poll(pollInterval, pollDuration, func() (bool, error) {
+	err := wait.Poll(pollInterval, pollDuration, func() (bool, error) {
 		t.Logf("Waiting for annotations to match %v", expected)
 		obj, err := query()
 		if err != nil && !apierrors.IsNotFound(err) {
@@ -227,8 +235,7 @@ func awaitAnnotations(t GinkgoTInterface, query func() (metav1.ObjectMeta, error
 type checkResourceFunc func() error
 
 func waitForDelete(checkResource checkResourceFunc) error {
-	var err error
-	err = wait.Poll(pollInterval, pollDuration, func() (bool, error) {
+	err := wait.Poll(pollInterval, pollDuration, func() (bool, error) {
 		err := checkResource()
 		if apierrors.IsNotFound(err) {
 			return true, nil
@@ -243,8 +250,7 @@ func waitForDelete(checkResource checkResourceFunc) error {
 }
 
 func waitForEmptyList(checkList func() (int, error)) error {
-	var err error
-	err = wait.Poll(pollInterval, pollDuration, func() (bool, error) {
+	err := wait.Poll(pollInterval, pollDuration, func() (bool, error) {
 		count, err := checkList()
 		if err != nil {
 			return false, err
@@ -518,7 +524,6 @@ func buildServiceAccountCleanupFunc(t GinkgoTInterface, c operatorclient.ClientI
 }
 
 func createInvalidGRPCCatalogSource(crc versioned.Interface, name, namespace string) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
-
 	catalogSource := &operatorsv1alpha1.CatalogSource{
 		TypeMeta: metav1.TypeMeta{
 			Kind:       operatorsv1alpha1.CatalogSourceKind,
@@ -541,7 +546,15 @@ func createInvalidGRPCCatalogSource(crc versioned.Interface, name, namespace str
 	return catalogSource, buildCatalogSourceCleanupFunc(crc, namespace, catalogSource)
 }
 
-func createInternalCatalogSource(c operatorclient.ClientInterface, crc versioned.Interface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
+func createInternalCatalogSource(
+	c operatorclient.ClientInterface,
+	crc versioned.Interface,
+	name,
+	namespace string,
+	manifests []registry.PackageManifest,
+	crds []apiextensions.CustomResourceDefinition,
+	csvs []operatorsv1alpha1.ClusterServiceVersion,
+) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
 	configMap, configMapCleanup := createConfigMapForCatalogData(c, name, namespace, manifests, crds, csvs)
 
 	// Create an internal CatalogSource custom resource pointing to the ConfigMap
@@ -574,10 +587,15 @@ func createInternalCatalogSource(c operatorclient.ClientInterface, crc versioned
 	return catalogSource, cleanupInternalCatalogSource
 }
 
-func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface, crc versioned.Interface, name,
-	namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition,
-	csvs []operatorsv1alpha1.ClusterServiceVersion, priority int) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
-
+func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface,
+	crc versioned.Interface,
+	name,
+	namespace string,
+	manifests []registry.PackageManifest,
+	crds []apiextensions.CustomResourceDefinition,
+	csvs []operatorsv1alpha1.ClusterServiceVersion,
+	priority int,
+) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
 	configMap, configMapCleanup := createConfigMapForCatalogData(c, name, namespace, manifests, crds, csvs)
 	// Create an internal CatalogSource custom resource pointing to the ConfigMap
 	catalogSource := &operatorsv1alpha1.CatalogSource{
@@ -611,7 +629,16 @@ func createInternalCatalogSourceWithPriority(c operatorclient.ClientInterface, c
 	return catalogSource, cleanupInternalCatalogSource
 }
 
-func createV1CRDInternalCatalogSource(t GinkgoTInterface, c operatorclient.ClientInterface, crc versioned.Interface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensionsv1.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
+func createV1CRDInternalCatalogSource(
+	t GinkgoTInterface,
+	c operatorclient.ClientInterface,
+	crc versioned.Interface,
+	name,
+	namespace string,
+	manifests []registry.PackageManifest,
+	crds []apiextensionsv1.CustomResourceDefinition,
+	csvs []operatorsv1alpha1.ClusterServiceVersion,
+) (*operatorsv1alpha1.CatalogSource, cleanupFunc) {
 	configMap, configMapCleanup := createV1CRDConfigMapForCatalogData(t, c, name, namespace, manifests, crds, csvs)
 
 	// Create an internal CatalogSource custom resource pointing to the ConfigMap
@@ -645,7 +672,14 @@ func createV1CRDInternalCatalogSource(t GinkgoTInterface, c operatorclient.Clien
 	return catalogSource, cleanupInternalCatalogSource
 }
 
-func createConfigMapForCatalogData(c operatorclient.ClientInterface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensions.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*corev1.ConfigMap, cleanupFunc) {
+func createConfigMapForCatalogData(
+	c operatorclient.ClientInterface,
+	name,
+	namespace string,
+	manifests []registry.PackageManifest,
+	crds []apiextensions.CustomResourceDefinition,
+	csvs []operatorsv1alpha1.ClusterServiceVersion,
+) (*corev1.ConfigMap, cleanupFunc) {
 	// Create a config map containing the PackageManifests and CSVs
 	configMapName := fmt.Sprintf("%s-configmap", name)
 	catalogConfigMap := &corev1.ConfigMap{
@@ -692,7 +726,15 @@ func createConfigMapForCatalogData(c operatorclient.ClientInterface, name, names
 	return createdConfigMap, buildConfigMapCleanupFunc(c, namespace, createdConfigMap)
 }
 
-func createV1CRDConfigMapForCatalogData(t GinkgoTInterface, c operatorclient.ClientInterface, name, namespace string, manifests []registry.PackageManifest, crds []apiextensionsv1.CustomResourceDefinition, csvs []operatorsv1alpha1.ClusterServiceVersion) (*corev1.ConfigMap, cleanupFunc) {
+func createV1CRDConfigMapForCatalogData(
+	t GinkgoTInterface,
+	c operatorclient.ClientInterface,
+	name,
+	namespace string,
+	manifests []registry.PackageManifest,
+	crds []apiextensionsv1.CustomResourceDefinition,
+	csvs []operatorsv1alpha1.ClusterServiceVersion,
+) (*corev1.ConfigMap, cleanupFunc) {
 	// Create a config map containing the PackageManifests and CSVs
 	configMapName := fmt.Sprintf("%s-configmap", name)
 	catalogConfigMap := &corev1.ConfigMap{
diff --git a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go
index d746117af7..512882e4bd 100644
--- a/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go
+++ b/staging/operator-lifecycle-manager/test/e2e/webhook_e2e_test.go
@@ -171,11 +171,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 
 				// Current Webhook should exist
 				_, err = getWebhookWithGenerateName(c, changedGenerateName)
-				if err != nil {
-					return false
-				}
-
-				return true
+				return err == nil
 			}, time.Minute, 5*time.Second).Should(BeTrue())
 		})
 		It("Reuses existing valid certs", func() {
@@ -212,10 +208,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				fetchedCSV.Status.Phase = operatorsv1alpha1.CSVPhasePending
 
 				_, err = crc.OperatorsV1alpha1().ClusterServiceVersions(namespace.GetName()).UpdateStatus(context.TODO(), fetchedCSV, metav1.UpdateOptions{})
-				if err != nil {
-					return false
-				}
-				return true
+				return err == nil
 			}).Should(BeTrue(), "Unable to set CSV phase to Pending")
 
 			// Wait for webhook-operator to succeed
@@ -259,7 +252,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				AdmissionReviewVersions: []string{"v1beta1", "v1"},
 				SideEffects:             &sideEffect,
 				Rules: []admissionregistrationv1.RuleWithOperations{
-					admissionregistrationv1.RuleWithOperations{
+					{
 						Operations: []admissionregistrationv1.OperationType{},
 						Rule: admissionregistrationv1.Rule{
 							APIGroups:   []string{"*"},
@@ -278,7 +271,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 
 			failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker)
 			Expect(err).Should(BeNil())
-			Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include all groups"))
+			Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include all groups"))
 		})
 		It("Fails if the webhook intercepts OLM resources", func() {
 			sideEffect := admissionregistrationv1.SideEffectClassNone
@@ -290,7 +283,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				AdmissionReviewVersions: []string{"v1beta1", "v1"},
 				SideEffects:             &sideEffect,
 				Rules: []admissionregistrationv1.RuleWithOperations{
-					admissionregistrationv1.RuleWithOperations{
+					{
 						Operations: []admissionregistrationv1.OperationType{},
 						Rule: admissionregistrationv1.Rule{
 							APIGroups:   []string{"operators.coreos.com"},
@@ -309,7 +302,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 
 			failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker)
 			Expect(err).Should(BeNil())
-			Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include the OLM group"))
+			Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include the OLM group"))
 		})
 		It("Fails if webhook intercepts Admission Webhook resources", func() {
 			sideEffect := admissionregistrationv1.SideEffectClassNone
@@ -321,7 +314,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				AdmissionReviewVersions: []string{"v1beta1", "v1"},
 				SideEffects:             &sideEffect,
 				Rules: []admissionregistrationv1.RuleWithOperations{
-					admissionregistrationv1.RuleWithOperations{
+					{
 						Operations: []admissionregistrationv1.OperationType{},
 						Rule: admissionregistrationv1.Rule{
 							APIGroups:   []string{"admissionregistration.k8s.io"},
@@ -340,7 +333,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 
 			failedCSV, err := fetchCSV(crc, csv.Name, namespace.Name, csvFailedChecker)
 			Expect(err).Should(BeNil())
-			Expect(failedCSV.Status.Message).Should(Equal("Webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources"))
+			Expect(failedCSV.Status.Message).Should(Equal("webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources"))
 		})
 		It("Succeeds if the webhook intercepts non Admission Webhook resources in admissionregistration group", func() {
 			sideEffect := admissionregistrationv1.SideEffectClassNone
@@ -352,7 +345,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				AdmissionReviewVersions: []string{"v1beta1", "v1"},
 				SideEffects:             &sideEffect,
 				Rules: []admissionregistrationv1.RuleWithOperations{
-					admissionregistrationv1.RuleWithOperations{
+					{
 						Operations: []admissionregistrationv1.OperationType{
 							admissionregistrationv1.OperationAll,
 						},
@@ -384,7 +377,7 @@ var _ = Describe("CSVs with a Webhook", func() {
 				AdmissionReviewVersions: []string{"v1beta1", "v1"},
 				SideEffects:             &sideEffect,
 				Rules: []admissionregistrationv1.RuleWithOperations{
-					admissionregistrationv1.RuleWithOperations{
+					{
 						Operations: []admissionregistrationv1.OperationType{
 							admissionregistrationv1.OperationAll,
 						},
diff --git a/staging/operator-registry/.github/workflows/goreleaser.yaml b/staging/operator-registry/.github/workflows/goreleaser.yaml
index 974baaf82b..1267e452cf 100644
--- a/staging/operator-registry/.github/workflows/goreleaser.yaml
+++ b/staging/operator-registry/.github/workflows/goreleaser.yaml
@@ -23,29 +23,6 @@ jobs:
         with:
           go-version: '~1.16'
 
-      - name: "Download osxcross cross-compiler for macOS builds"
-        run: |
-          git clone https://github.com/tpoechtrager/osxcross /tmp/osxcross
-          cd /tmp/osxcross
-          wget -P tarballs '<REPLACE_ME_WITH_SECRET_PATH_TO_MACOS_SDK>'
-          echo "/tmp/osxcross/target/bin" >> $GITHUB_PATH
-
-      - name: "Cache the osxcross + tarball build output"
-        id: cache-osxcross
-        uses: actions/cache@v2
-        with:
-          path: /tmp/osxcross/target
-          key: ${{ runner.os }}-osxcross-${{ hashFiles('/tmp/osxcross/**/*') }}
-          restore-keys: |
-            ${{ runner.os }}-osxcross-
-
-      - name: "Build osxcross"
-        if: steps.cache-osxcross.outputs.cache-hit != 'true'
-        run: |
-          cd /tmp/osxcross
-          sudo ./tools/get_dependencies.sh
-          UNATTENDED=1 ./build.sh
-
       - name: "Install linux cross-compilers"
         run: |
           sudo apt-get update
diff --git a/staging/operator-registry/.github/workflows/release.yaml b/staging/operator-registry/.github/workflows/release.yaml
new file mode 100644
index 0000000000..6d05f2f7d5
--- /dev/null
+++ b/staging/operator-registry/.github/workflows/release.yaml
@@ -0,0 +1,48 @@
+name: release
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+defaults:
+  run:
+    shell: bash
+jobs:
+  create:
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.release.outputs.upload_url }}
+    steps:
+      - uses: actions/create-release@v1
+        id: release
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          draft: true
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+  assets:
+    needs: create
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          - windows-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: '~1.16'
+      - run: |
+          echo "asset_path=bin/opm" >> $GITHUB_ENV
+          echo "asset_name=$(go env GOOS)-$(go env GOARCH)-opm$(go env GOEXE)" >> $GITHUB_ENV
+      - run: make ${{ env.asset_path }}
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create.outputs.upload_url }}
+          asset_path: ${{ env.asset_path }}
+          asset_name: ${{ env.asset_name }}
+          asset_content_type: application/octet-stream
diff --git a/staging/operator-registry/.gitignore b/staging/operator-registry/.gitignore
index fe176ef932..6862915385 100644
--- a/staging/operator-registry/.gitignore
+++ b/staging/operator-registry/.gitignore
@@ -179,7 +179,6 @@ tags
 *.userprefs
 
 # Build results
-[Dd]ebug/
 [Dd]ebugPublic/
 x64/
 x86/
diff --git a/staging/operator-registry/.goreleaser.yaml b/staging/operator-registry/.goreleaser.yaml
index a50dfba12e..8049d451ce 100644
--- a/staging/operator-registry/.goreleaser.yaml
+++ b/staging/operator-registry/.goreleaser.yaml
@@ -82,34 +82,6 @@ builds:
     asmflags: *build-asmflags
     gcflags: *build-gcflags
     ldflags: *build-ldflags
-  - id: darwin-amd64
-    main: ./cmd/opm
-    binary: opm
-    goos:
-      - darwin
-    goarch:
-      - amd64
-    env:
-      - CC=o64-clang
-    mod_timestamp: "{{ .CommitTimestamp }}"
-    flags: *build-flags
-    asmflags: *build-asmflags
-    gcflags: *build-gcflags
-    ldflags: *build-ldflags
-  - id: darwin-arm64
-    main: ./cmd/opm
-    binary: opm
-    goos:
-      - darwin
-    goarch:
-      - arm64
-    env:
-      - CC=oa64e-clang
-    mod_timestamp: "{{ .CommitTimestamp }}"
-    flags: *build-flags
-    asmflags: *build-asmflags
-    gcflags: *build-gcflags
-    ldflags: *build-ldflags
 archives:
   - id: opm
     builds:
@@ -118,8 +90,6 @@ archives:
       - linux-ppc64le
       - linux-s390x
       - windows-amd64
-      - darwin-amd64
-      - darwin-arm64
     name_template: "{{ .Binary }}_{{ .Env.OPM_VERSION }}_{{ .Os }}_{{ .Arch }}"
     format: binary
 dockers:
@@ -199,3 +169,6 @@ snapshot:
 release:
   name_template: "{{ .Env.OPM_VERSION }}"
   draft: true
+  ## Disable release steps, since a separate GitHub Action job
+  ## handles binary builds and release uploads
+  disable: true
diff --git a/staging/operator-registry/cmd/opm/alpha/bundle/extract.go b/staging/operator-registry/cmd/opm/alpha/bundle/extract.go
index d07273b3c4..3952a52b8c 100644
--- a/staging/operator-registry/cmd/opm/alpha/bundle/extract.go
+++ b/staging/operator-registry/cmd/opm/alpha/bundle/extract.go
@@ -12,7 +12,7 @@ import (
 var extractCmd = &cobra.Command{
 	Use:   "extract",
 	Short: "Extracts the data in a bundle directory via ConfigMap",
-	Long:  "Extract takes as input a directory containing manifests and writes the per file contents to a ConfipMap",
+	Long:  "Extract takes as input a directory containing manifests and writes the per file contents to a ConfigMap",
 
 	PreRunE: func(cmd *cobra.Command, _ []string) error {
 		if debug, _ := cmd.Flags().GetBool("debug"); debug {
diff --git a/staging/operator-registry/go.mod b/staging/operator-registry/go.mod
index b1e82f13d5..72e3de2e2e 100644
--- a/staging/operator-registry/go.mod
+++ b/staging/operator-registry/go.mod
@@ -29,7 +29,7 @@ require (
 	github.com/h2non/filetype v1.1.1
 	github.com/h2non/go-is-svg v0.0.0-20160927212452-35e8c4b0612c
 	github.com/joelanford/ignore v0.0.0-20210607151042-0d25dc18b62d
-	github.com/mattn/go-sqlite3 v1.10.0
+	github.com/mattn/go-sqlite3 v1.14.10
 	github.com/maxbrunsfeld/counterfeiter/v6 v6.2.2
 	github.com/mitchellh/hashstructure/v2 v2.0.2
 	github.com/onsi/ginkgo v1.16.4
@@ -50,7 +50,7 @@ require (
 	golang.org/x/mod v0.4.2
 	golang.org/x/net v0.0.0-20210825183410-e898025ed96a
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	google.golang.org/grpc v1.40.0
+	google.golang.org/grpc v1.41.0
 	google.golang.org/grpc/cmd/protoc-gen-go-grpc v0.0.0-20200709232328-d8193ee9cc3e
 	google.golang.org/protobuf v1.27.1
 	gopkg.in/yaml.v2 v2.4.0
diff --git a/staging/operator-registry/go.sum b/staging/operator-registry/go.sum
index 10900d0923..827eaa2ec8 100644
--- a/staging/operator-registry/go.sum
+++ b/staging/operator-registry/go.sum
@@ -89,6 +89,7 @@ github.com/alessio/shellescape v1.4.1 h1:V7yhSDDn8LP4lc4jS8pFkt0zCnzVJlG5JXy9BVK
 github.com/alessio/shellescape v1.4.1/go.mod h1:PZAiSCk0LJaZkiCSkPv8qIobYglO3FPpyFjDCtHLS30=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e h1:GCzyKMDDjSGnlpl3clrdAK7I1AaVoaiKDOYkUzChZzg=
 github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
@@ -144,6 +145,7 @@ github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGX
 github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
 github.com/cockroachdb/cockroach-go v0.0.0-20181001143604-e0a95dfd547c/go.mod h1:XGLbWH/ujMcbPbhZq52Nv6UrCghb1yGn//133kEsvDk=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
@@ -247,6 +249,7 @@ github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5y
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/evanphx/json-patch v0.5.2/go.mod h1:ZWS5hhDbVDyob71nXKNL0+PWn6ToqBHMikGIFbs31qQ=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
@@ -381,6 +384,7 @@ github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e/go.mod h1:0AA//
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.1/go.mod h1:xXMiIv4Fb/0kKde4SpL7qlzvu5cMJDRkFDxJfI9uaxA=
+github.com/google/cel-go v0.9.0 h1:u1hg7lcZ/XWw2d3aV1jFS30ijQQ6q0/h1C2ZBeBD1gY=
 github.com/google/cel-go v0.9.0/go.mod h1:U7ayypeSkw23szu4GaQTPJGx66c20mx8JklMSxrmI1w=
 github.com/google/cel-spec v0.6.0/go.mod h1:Nwjgxy5CbjlPrtCWjeDjUyKMl8w41YBYGjsyDdqk0xA=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -560,8 +564,9 @@ github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHX
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o=
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mattn/go-sqlite3 v1.14.10 h1:MLn+5bFRlWMGoSRmJour3CL1w/qL96mvipqpwQW/Sfk=
+github.com/mattn/go-sqlite3 v1.14.10/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI=
 github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
@@ -763,6 +768,7 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
 github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns=
+github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU=
 github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -1286,8 +1292,9 @@ google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG
 google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
 google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
-google.golang.org/grpc v1.40.0 h1:AGJ0Ih4mHjSeibYkFGh1dD9KJ/eOtZ93I6hoHhukQ5Q=
 google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
+google.golang.org/grpc v1.41.0 h1:f+PlOh7QV4iIJkPrx5NQ7qaNGFQ3OTse67yaDHfju4E=
+google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v0.0.0-20200709232328-d8193ee9cc3e h1:4BwkYybqoRhPKm97iNO3ACkxj26G0hC18CaO9QXOxto=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v0.0.0-20200709232328-d8193ee9cc3e/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
diff --git a/staging/operator-registry/pkg/lib/bundle/validate.go b/staging/operator-registry/pkg/lib/bundle/validate.go
index d7a96d11ca..fb8ca0368d 100644
--- a/staging/operator-registry/pkg/lib/bundle/validate.go
+++ b/staging/operator-registry/pkg/lib/bundle/validate.go
@@ -237,6 +237,8 @@ func validateDependencies(dependenciesFile *registry.DependenciesFile) []error {
 				errs = dp.Validate()
 			case registry.LabelDependency:
 				errs = dp.Validate()
+			case registry.CelConstraint:
+				errs = dp.Validate()
 			default:
 				errs = append(errs, fmt.Errorf("unsupported dependency type %s", d.GetType()))
 			}
diff --git a/staging/operator-registry/pkg/registry/types.go b/staging/operator-registry/pkg/registry/types.go
index d7d2585520..42908e5087 100644
--- a/staging/operator-registry/pkg/registry/types.go
+++ b/staging/operator-registry/pkg/registry/types.go
@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/blang/semver/v4"
+	"github.com/operator-framework/api/pkg/constraints"
 )
 
 var (
@@ -55,6 +56,7 @@ const (
 	DeprecatedType = "olm.deprecated"
 	LabelType      = "olm.label"
 	PropertyKey    = "olm.properties"
+	ConstraintType = "olm.constraint"
 )
 
 // APIKey stores GroupVersionKind for use as map keys
@@ -220,6 +222,16 @@ type LabelDependency struct {
 	Label string `json:"label" yaml:"label"`
 }
 
+type CelConstraint struct {
+	// Constraint message that surfaces in resolution
+	// This field is optional
+	Message string `json:"message" yaml:"message"`
+
+	// The cel struct that contraints CEL expression
+	// This field is required
+	Cel *constraints.Cel `json:"cel" yaml:"cel"`
+}
+
 type GVKProperty struct {
 	// The group of GVK based property
 	Group string `json:"group" yaml:"group"`
@@ -289,6 +301,25 @@ func (pd *PackageDependency) Validate() []error {
 	return errs
 }
 
+// Validate will validate constraint type and return error(s)
+func (cc *CelConstraint) Validate() []error {
+	errs := []error{}
+	if cc.Cel == nil {
+		errs = append(errs, fmt.Errorf("The CEL field is missing"))
+	} else {
+		if cc.Cel.Rule == "" {
+			errs = append(errs, fmt.Errorf("The CEL expression is missing"))
+			return errs
+		}
+		validator := constraints.NewCelEnvironment()
+		_, err := validator.Validate(cc.Cel.Rule)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Invalid CEL expression: %s", err.Error()))
+		}
+	}
+	return errs
+}
+
 // GetDependencies returns the list of dependency
 func (d *DependenciesFile) GetDependencies() []*Dependency {
 	var dependencies []*Dependency
@@ -329,6 +360,13 @@ func (e *Dependency) GetTypeValue() interface{} {
 			return nil
 		}
 		return dep
+	case ConstraintType:
+		dep := CelConstraint{}
+		err := json.Unmarshal([]byte(e.GetValue()), &dep)
+		if err != nil {
+			return nil
+		}
+		return dep
 	}
 	return nil
 }
diff --git a/staging/operator-registry/pkg/registry/types_test.go b/staging/operator-registry/pkg/registry/types_test.go
new file mode 100644
index 0000000000..c74275dde3
--- /dev/null
+++ b/staging/operator-registry/pkg/registry/types_test.go
@@ -0,0 +1,65 @@
+package registry
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCelConstraintValidation(t *testing.T) {
+	tests := []struct {
+		name       string
+		constraint string
+		errs       []error
+	}{
+		{
+			name:       "ValidCelConstraint",
+			constraint: `{"cel":{"rule":"properties.exists(p, p.type == 'olm.test' && (semver_compare(p.value, '1.0.0') == 0))"}}`,
+		},
+		{
+			name:       "InvalidCelConstraint/MissingCel",
+			constraint: `{}`,
+			errs: []error{
+				fmt.Errorf("The CEL field is missing"),
+			},
+		},
+		{
+			name:       "InvalidCelConstraint/MissingRule",
+			constraint: `{"cel":{"rule":""}}`,
+			errs: []error{
+				fmt.Errorf("The CEL expression is missing"),
+			},
+		},
+		{
+			name:       "InvalidCelConstraint/NotExistedFunc",
+			constraint: `{"cel":{"rule":"properties.exists(p, p.type == 'olm.test' && (doesnt_exist(p.value, '1.0.0') == 0))"}}`,
+			errs: []error{
+				fmt.Errorf("Invalid CEL expression"),
+			},
+		},
+		{
+			name:       "InvalidCelExpression/NonBoolReturn",
+			constraint: `{"cel":{"rule":"1"}}`,
+			errs: []error{
+				fmt.Errorf("Invalid CEL expression"),
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var dep CelConstraint
+			err := json.Unmarshal([]byte(tt.constraint), &dep)
+			assert.NoError(t, err)
+			errs := dep.Validate()
+			if len(tt.errs) > 0 {
+				assert.Error(t, errs[0])
+				assert.Contains(t, errs[0].Error(), tt.errs[0].Error())
+			} else {
+				assert.Equal(t, len(errs), 0)
+			}
+		})
+	}
+}
diff --git a/vendor/github.com/mattn/go-sqlite3/README.md b/vendor/github.com/mattn/go-sqlite3/README.md
index 746621f9fd..e455133fc9 100644
--- a/vendor/github.com/mattn/go-sqlite3/README.md
+++ b/vendor/github.com/mattn/go-sqlite3/README.md
@@ -7,17 +7,17 @@ go-sqlite3
 [![codecov](https://codecov.io/gh/mattn/go-sqlite3/branch/master/graph/badge.svg)](https://codecov.io/gh/mattn/go-sqlite3)
 [![Go Report Card](https://goreportcard.com/badge/github.com/mattn/go-sqlite3)](https://goreportcard.com/report/github.com/mattn/go-sqlite3)
 
-Latest stable version is v1.14 or later not v2.
+Latest stable version is v1.14 or later, not v2.
 
 ~~**NOTE:** The increase to v2 was an accident. There were no major changes or features.~~
 
 # Description
 
-sqlite3 driver conforming to the built-in database/sql interface
+A sqlite3 driver that conforms to the built-in database/sql interface.
 
-Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go.yaml)
+Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go.yaml).
 
-[This package follows the official Golang Release Policy.](https://golang.org/doc/devel/release.html#policy)
+This package follows the official [Golang Release Policy](https://golang.org/doc/devel/release.html#policy).
 
 ### Overview
 
@@ -64,7 +64,7 @@ Supported Golang version: See [.github/workflows/go.yaml](./.github/workflows/go
 
 # Installation
 
-This package can be installed with the go get command:
+This package can be installed with the `go get` command:
 
     go get github.com/mattn/go-sqlite3
 
@@ -72,28 +72,28 @@ _go-sqlite3_ is *cgo* package.
 If you want to build your app using go-sqlite3, you need gcc.
 However, after you have built and installed _go-sqlite3_ with `go install github.com/mattn/go-sqlite3` (which requires gcc), you can build your app without relying on gcc in future.
 
-***Important: because this is a `CGO` enabled package you are required to set the environment variable `CGO_ENABLED=1` and have a `gcc` compile present within your path.***
+***Important: because this is a `CGO` enabled package, you are required to set the environment variable `CGO_ENABLED=1` and have a `gcc` compile present within your path.***
 
 # API Reference
 
-API documentation can be found here: http://godoc.org/github.com/mattn/go-sqlite3
+API documentation can be found [here](http://godoc.org/github.com/mattn/go-sqlite3).
 
-Examples can be found under the [examples](./_example) directory
+Examples can be found under the [examples](./_example) directory.
 
 # Connection String
 
 When creating a new SQLite database or connection to an existing one, with the file name additional options can be given.
-This is also known as a DSN string. (Data Source Name).
+This is also known as a DSN (Data Source Name) string.
 
 Options are append after the filename of the SQLite database.
-The database filename and options are seperated by an `?` (Question Mark).
+The database filename and options are separated by an `?` (Question Mark).
 Options should be URL-encoded (see [url.QueryEscape](https://golang.org/pkg/net/url/#QueryEscape)).
 
 This also applies when using an in-memory database instead of a file.
 
 Options can be given using the following format: `KEYWORD=VALUE` and multiple options can be combined with the `&` ampersand.
 
-This library supports dsn options of SQLite itself and provides additional options.
+This library supports DSN options of SQLite itself and provides additional options.
 
 Boolean values can be one of:
 * `0` `no` `false` `off`
@@ -138,19 +138,18 @@ file:test.db?cache=shared&mode=memory
 
 This package allows additional configuration of features available within SQLite3 to be enabled or disabled by golang build constraints also known as build `tags`.
 
-[Click here for more information about build tags / constraints.](https://golang.org/pkg/go/build/#hdr-Build_Constraints)
+Click [here](https://golang.org/pkg/go/build/#hdr-Build_Constraints) for more information about build tags / constraints.
 
 ### Usage
 
-If you wish to build this library with additional extensions / features.
-Use the following command.
+If you wish to build this library with additional extensions / features, use the following command:
 
 ```bash
 go build --tags "<FEATURE>"
 ```
 
-For available features see the extension list.
-When using multiple build tags, all the different tags should be space delimted.
+For available features, see the extension list.
+When using multiple build tags, all the different tags should be space delimited.
 
 Example:
 
@@ -181,9 +180,9 @@ go build --tags "icu json1 fts5 secure_delete"
 
 # Compilation
 
-This package requires `CGO_ENABLED=1` ennvironment variable if not set by default, and the presence of the `gcc` compiler.
+This package requires the `CGO_ENABLED=1` ennvironment variable if not set by default, and the presence of the `gcc` compiler.
 
-If you need to add additional CFLAGS or LDFLAGS to the build command, and do not want to modify this package. Then this can be achieved by  using the `CGO_CFLAGS` and `CGO_LDFLAGS` environment variables.
+If you need to add additional CFLAGS or LDFLAGS to the build command, and do not want to modify this package, then this can be achieved by using the `CGO_CFLAGS` and `CGO_LDFLAGS` environment variables.
 
 ## Android
 
@@ -198,7 +197,7 @@ For more information see [#201](https://github.com/mattn/go-sqlite3/issues/201)
 
 # ARM
 
-To compile for `ARM` use the following environment.
+To compile for `ARM` use the following environment:
 
 ```bash
 env CC=arm-linux-gnueabihf-gcc CXX=arm-linux-gnueabihf-g++ \
@@ -234,7 +233,7 @@ Please work only with compiled final binaries.
 
 ## Linux
 
-To compile this package on Linux you must install the development tools for your linux distribution.
+To compile this package on Linux, you must install the development tools for your linux distribution.
 
 To compile under linux use the build tag `linux`.
 
@@ -250,7 +249,7 @@ go build --tags "libsqlite3 linux"
 
 ### Alpine
 
-When building in an `alpine` container run the following command before building.
+When building in an `alpine` container  run the following command before building:
 
 ```
 apk add --update gcc musl-dev
@@ -270,29 +269,29 @@ sudo apt-get install build-essential
 
 ## Mac OSX
 
-OSX should have all the tools present to compile this package, if not install XCode this will add all the developers tools.
+OSX should have all the tools present to compile this package. If not, install XCode to add all the developers tools.
 
-Required dependency
+Required dependency:
 
 ```bash
 brew install sqlite3
 ```
 
-For OSX there is an additional package install which is required if you wish to build the `icu` extension.
+For OSX, there is an additional package to install which is required if you wish to build the `icu` extension.
 
-This additional package can be installed with `homebrew`.
+This additional package can be installed with `homebrew`:
 
 ```bash
 brew upgrade icu4c
 ```
 
-To compile for Mac OSX.
+To compile for Mac OSX:
 
 ```bash
 go build --tags "darwin"
 ```
 
-If you wish to link directly to libsqlite3 then you can use the `libsqlite3` build tag.
+If you wish to link directly to libsqlite3, use the `libsqlite3` build tag:
 
 ```
 go build --tags "libsqlite3 darwin"
@@ -304,14 +303,14 @@ Additional information:
 
 ## Windows
 
-To compile this package on Windows OS you must have the `gcc` compiler installed.
+To compile this package on Windows, you must have the `gcc` compiler installed.
 
 1) Install a Windows `gcc` toolchain.
-2) Add the `bin` folders to the Windows path if the installer did not do this by default.
-3) Open a terminal for the TDM-GCC toolchain, can be found in the Windows Start menu.
+2) Add the `bin` folder to the Windows path, if the installer did not do this by default.
+3) Open a terminal for the TDM-GCC toolchain, which can be found in the Windows Start menu.
 4) Navigate to your project folder and run the `go build ...` command for this package.
 
-For example the TDM-GCC Toolchain can be found [here](https://sourceforge.net/projects/tdm-gcc/).
+For example the TDM-GCC Toolchain can be found [here](https://jmeubank.github.io/tdm-gcc/).
 
 ## Errors
 
@@ -349,28 +348,28 @@ This package supports the SQLite User Authentication module.
 
 ## Compile
 
-To use the User authentication module the package has to be compiled with the tag `sqlite_userauth`. See [Features](#features).
+To use the User authentication module, the package has to be compiled with the tag `sqlite_userauth`. See [Features](#features).
 
 ## Usage
 
 ### Create protected database
 
-To create a database protected by user authentication provide the following argument to the connection string `_auth`.
+To create a database protected by user authentication, provide the following argument to the connection string `_auth`.
 This will enable user authentication within the database. This option however requires two additional arguments:
 
 - `_auth_user`
 - `_auth_pass`
 
-When `_auth` is present on the connection string user authentication will be enabled and the provided user will be created
+When `_auth` is present in the connection string user authentication will be enabled and the provided user will be created
 as an `admin` user. After initial creation, the parameter `_auth` has no effect anymore and can be omitted from the connection string.
 
-Example connection string:
+Example connection strings:
 
-Create an user authentication database with user `admin` and password `admin`.
+Create an user authentication database with user `admin` and password `admin`:
 
 `file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin`
 
-Create an user authentication database with user `admin` and password `admin` and use `SHA1` for the password encoding.
+Create an user authentication database with user `admin` and password `admin` and use `SHA1` for the password encoding:
 
 `file:test.s3db?_auth&_auth_user=admin&_auth_pass=admin&_auth_crypt=sha1`
 
@@ -396,11 +395,11 @@ salt this can be configured with `_auth_salt`.
 
 ### Restrictions
 
-Operations on the database regarding to user management can only be preformed by an administrator user.
+Operations on the database regarding user management can only be preformed by an administrator user.
 
 ### Support
 
-The user authentication supports two kinds of users
+The user authentication supports two kinds of users:
 
 - administrators
 - regular users
@@ -411,7 +410,7 @@ User management can be done by directly using the `*SQLiteConn` or by SQL.
 
 #### SQL
 
-The following sql functions are available for user management.
+The following sql functions are available for user management:
 
 | Function | Arguments | Description |
 |----------|-----------|-------------|
@@ -420,7 +419,7 @@ The following sql functions are available for user management.
 | `auth_user_change` | username `string`, password `string`, admin `int` | Function to modify an user. Users can change their own password, but only an administrator can change the administrator flag. |
 | `authUserDelete` | username `string` | Delete an user from the database. Can only be used by an administrator. The current logged in administrator cannot be deleted. This is to make sure their is always an administrator remaining. |
 
-These functions will return an integer.
+These functions will return an integer:
 
 - 0 (SQLITE_OK)
 - 23 (SQLITE_AUTH) Failed to perform due to authentication or insufficient privileges
@@ -441,7 +440,7 @@ SELECT user_delete('user');
 
 #### *SQLiteConn
 
-The following functions are available for User authentication from the `*SQLiteConn`.
+The following functions are available for User authentication from the `*SQLiteConn`:
 
 | Function | Description |
 |----------|-------------|
@@ -452,16 +451,16 @@ The following functions are available for User authentication from the `*SQLiteC
 
 ### Attached database
 
-When using attached databases. SQLite will use the authentication from the `main` database for the attached database(s).
+When using attached databases, SQLite will use the authentication from the `main` database for the attached database(s).
 
 # Extensions
 
-If you want your own extension to be listed here or you want to add a reference to an extension; please submit an Issue for this.
+If you want your own extension to be listed here, or you want to add a reference to an extension; please submit an Issue for this.
 
 ## Spatialite
 
 Spatialite is available as an extension to SQLite, and can be used in combination with this repository.
-For an example see [shaxbee/go-spatialite](https://github.com/shaxbee/go-spatialite).
+For an example, see [shaxbee/go-spatialite](https://github.com/shaxbee/go-spatialite).
 
 ## extension-functions.c from SQLite3 Contrib
 
@@ -471,7 +470,7 @@ extension-functions.c is available as an extension to SQLite, and provides the f
 - String: replicate, charindex, leftstr, rightstr, ltrim, rtrim, trim, replace, reverse, proper, padl, padr, padc, strfilter.
 - Aggregate: stdev, variance, mode, median, lower_quartile, upper_quartile
 
-For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/dinedal/go-sqlite3-extension-functions).
+For an example, see [dinedal/go-sqlite3-extension-functions](https://github.com/dinedal/go-sqlite3-extension-functions).
 
 # FAQ
 
@@ -491,7 +490,7 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d
 
 - Can I use this in multiple routines concurrently?
 
-    Yes for readonly. But, No for writable. See [#50](https://github.com/mattn/go-sqlite3/issues/50), [#51](https://github.com/mattn/go-sqlite3/issues/51), [#209](https://github.com/mattn/go-sqlite3/issues/209), [#274](https://github.com/mattn/go-sqlite3/issues/274).
+    Yes for readonly. But not for writable. See [#50](https://github.com/mattn/go-sqlite3/issues/50), [#51](https://github.com/mattn/go-sqlite3/issues/51), [#209](https://github.com/mattn/go-sqlite3/issues/209), [#274](https://github.com/mattn/go-sqlite3/issues/274).
 
 - Why I'm getting `no such table` error?
 
@@ -505,7 +504,7 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d
     
     Note that if the last database connection in the pool closes, the in-memory database is deleted. Make sure the [max idle connection limit](https://golang.org/pkg/database/sql/#DB.SetMaxIdleConns) is > 0, and the [connection lifetime](https://golang.org/pkg/database/sql/#DB.SetConnMaxLifetime) is infinite.
     
-    For more information see
+    For more information see:
     * [#204](https://github.com/mattn/go-sqlite3/issues/204)
     * [#511](https://github.com/mattn/go-sqlite3/issues/511)
     * https://www.sqlite.org/sharedcache.html#shared_cache_and_in_memory_databases
@@ -515,20 +514,20 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d
 
     OS X limits OS-wide to not have more than 1000 files open simultaneously by default.
 
-    For more information see [#289](https://github.com/mattn/go-sqlite3/issues/289)
+    For more information, see [#289](https://github.com/mattn/go-sqlite3/issues/289)
 
 - Trying to execute a `.` (dot) command throws an error.
 
     Error: `Error: near ".": syntax error`
-    Dot command are part of SQLite3 CLI not of this library.
+    Dot command are part of SQLite3 CLI, not of this library.
 
     You need to implement the feature or call the sqlite3 cli.
 
-    More information see [#305](https://github.com/mattn/go-sqlite3/issues/305)
+    More information see [#305](https://github.com/mattn/go-sqlite3/issues/305).
 
 - Error: `database is locked`
 
-    When you get a database is locked. Please use the following options.
+    When you get a database is locked, please use the following options.
 
     Add to DSN: `cache=shared`
 
@@ -537,24 +536,24 @@ For an example see [dinedal/go-sqlite3-extension-functions](https://github.com/d
     db, err := sql.Open("sqlite3", "file:locked.sqlite?cache=shared")
     ```
 
-    Second please set the database connections of the SQL package to 1.
+    Next, please set the database connections of the SQL package to 1:
     
     ```go
     db.SetMaxOpenConns(1)
     ```
 
-    More information see [#209](https://github.com/mattn/go-sqlite3/issues/209)
+    For more information, see [#209](https://github.com/mattn/go-sqlite3/issues/209).
 
 ## Contributors
 
 ### Code Contributors
 
-This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+This project exists thanks to all the people who [[contribute](CONTRIBUTING.md)].
 <a href="https://github.com/mattn/go-sqlite3/graphs/contributors"><img src="https://opencollective.com/mattn-go-sqlite3/contributors.svg?width=890&button=false" /></a>
 
 ### Financial Contributors
 
-Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/mattn-go-sqlite3/contribute)]
+Become a financial contributor and help us sustain our community. [[Contribute here](https://opencollective.com/mattn-go-sqlite3/contribute)].
 
 #### Individuals
 
diff --git a/vendor/github.com/mattn/go-sqlite3/backup.go b/vendor/github.com/mattn/go-sqlite3/backup.go
index e222cc8880..ecbb469746 100644
--- a/vendor/github.com/mattn/go-sqlite3/backup.go
+++ b/vendor/github.com/mattn/go-sqlite3/backup.go
@@ -7,7 +7,7 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/callback.go b/vendor/github.com/mattn/go-sqlite3/callback.go
index c3ce75207d..b020fe37c0 100644
--- a/vendor/github.com/mattn/go-sqlite3/callback.go
+++ b/vendor/github.com/mattn/go-sqlite3/callback.go
@@ -12,7 +12,7 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/error.go b/vendor/github.com/mattn/go-sqlite3/error.go
index 696281c733..58ab252e63 100644
--- a/vendor/github.com/mattn/go-sqlite3/error.go
+++ b/vendor/github.com/mattn/go-sqlite3/error.go
@@ -7,7 +7,7 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c
index c1a4d8f92c..bb9dc50ec7 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.c
@@ -1,7 +1,7 @@
 #ifndef USE_LIBSQLITE3
 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
-** version 3.34.0.  By combining all the individual C code files into this
+** version 3.37.0.  By combining all the individual C code files into this
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements
@@ -23,771 +23,6 @@
 #ifndef SQLITE_PRIVATE
 # define SQLITE_PRIVATE static
 #endif
-/************** Begin file ctime.c *******************************************/
-/*
-** 2010 February 23
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-**
-** This file implements routines used to report what compile-time options
-** SQLite was built with.
-*/
-
-#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */
-
-/*
-** Include the configuration header output by 'configure' if we're using the
-** autoconf-based build
-*/
-#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
-#include "config.h"
-#define SQLITECONFIG_H 1
-#endif
-
-/* These macros are provided to "stringify" the value of the define
-** for those options in which the value is meaningful. */
-#define CTIMEOPT_VAL_(opt) #opt
-#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
-
-/* Like CTIMEOPT_VAL, but especially for SQLITE_DEFAULT_LOOKASIDE. This
-** option requires a separate macro because legal values contain a single
-** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */
-#define CTIMEOPT_VAL2_(opt1,opt2) #opt1 "," #opt2
-#define CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt)
-
-/*
-** An array of names of all compile-time options.  This array should
-** be sorted A-Z.
-**
-** This array looks large, but in a typical installation actually uses
-** only a handful of compile-time options, so most times this array is usually
-** rather short and uses little memory space.
-*/
-static const char * const sqlite3azCompileOpt[] = {
-
-/*
-** BEGIN CODE GENERATED BY tool/mkctime.tcl
-*/
-#if SQLITE_32BIT_ROWID
-  "32BIT_ROWID",
-#endif
-#if SQLITE_4_BYTE_ALIGNED_MALLOC
-  "4_BYTE_ALIGNED_MALLOC",
-#endif
-#if SQLITE_64BIT_STATS
-  "64BIT_STATS",
-#endif
-#if SQLITE_ALLOW_COVERING_INDEX_SCAN
-  "ALLOW_COVERING_INDEX_SCAN",
-#endif
-#if SQLITE_ALLOW_URI_AUTHORITY
-  "ALLOW_URI_AUTHORITY",
-#endif
-#ifdef SQLITE_BITMASK_TYPE
-  "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE),
-#endif
-#if SQLITE_BUG_COMPATIBLE_20160819
-  "BUG_COMPATIBLE_20160819",
-#endif
-#if SQLITE_CASE_SENSITIVE_LIKE
-  "CASE_SENSITIVE_LIKE",
-#endif
-#if SQLITE_CHECK_PAGES
-  "CHECK_PAGES",
-#endif
-#if defined(__clang__) && defined(__clang_major__)
-  "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "."
-                    CTIMEOPT_VAL(__clang_minor__) "."
-                    CTIMEOPT_VAL(__clang_patchlevel__),
-#elif defined(_MSC_VER)
-  "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),
-#elif defined(__GNUC__) && defined(__VERSION__)
-  "COMPILER=gcc-" __VERSION__,
-#endif
-#if SQLITE_COVERAGE_TEST
-  "COVERAGE_TEST",
-#endif
-#if SQLITE_DEBUG
-  "DEBUG",
-#endif
-#if SQLITE_DEFAULT_AUTOMATIC_INDEX
-  "DEFAULT_AUTOMATIC_INDEX",
-#endif
-#if SQLITE_DEFAULT_AUTOVACUUM
-  "DEFAULT_AUTOVACUUM",
-#endif
-#ifdef SQLITE_DEFAULT_CACHE_SIZE
-  "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE),
-#endif
-#if SQLITE_DEFAULT_CKPTFULLFSYNC
-  "DEFAULT_CKPTFULLFSYNC",
-#endif
-#ifdef SQLITE_DEFAULT_FILE_FORMAT
-  "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT),
-#endif
-#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS
-  "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS),
-#endif
-#if SQLITE_DEFAULT_FOREIGN_KEYS
-  "DEFAULT_FOREIGN_KEYS",
-#endif
-#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
-  "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT),
-#endif
-#ifdef SQLITE_DEFAULT_LOCKING_MODE
-  "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
-#endif
-#ifdef SQLITE_DEFAULT_LOOKASIDE
-  "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
-#endif
-#if SQLITE_DEFAULT_MEMSTATUS
-  "DEFAULT_MEMSTATUS",
-#endif
-#ifdef SQLITE_DEFAULT_MMAP_SIZE
-  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
-#endif
-#ifdef SQLITE_DEFAULT_PAGE_SIZE
-  "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE),
-#endif
-#ifdef SQLITE_DEFAULT_PCACHE_INITSZ
-  "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ),
-#endif
-#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
-  "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS),
-#endif
-#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
-  "DEFAULT_RECURSIVE_TRIGGERS",
-#endif
-#ifdef SQLITE_DEFAULT_ROWEST
-  "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST),
-#endif
-#ifdef SQLITE_DEFAULT_SECTOR_SIZE
-  "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE),
-#endif
-#ifdef SQLITE_DEFAULT_SYNCHRONOUS
-  "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS),
-#endif
-#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
-  "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT),
-#endif
-#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS
-  "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS),
-#endif
-#ifdef SQLITE_DEFAULT_WORKER_THREADS
-  "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS),
-#endif
-#if SQLITE_DIRECT_OVERFLOW_READ
-  "DIRECT_OVERFLOW_READ",
-#endif
-#if SQLITE_DISABLE_DIRSYNC
-  "DISABLE_DIRSYNC",
-#endif
-#if SQLITE_DISABLE_FTS3_UNICODE
-  "DISABLE_FTS3_UNICODE",
-#endif
-#if SQLITE_DISABLE_FTS4_DEFERRED
-  "DISABLE_FTS4_DEFERRED",
-#endif
-#if SQLITE_DISABLE_INTRINSIC
-  "DISABLE_INTRINSIC",
-#endif
-#if SQLITE_DISABLE_LFS
-  "DISABLE_LFS",
-#endif
-#if SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
-  "DISABLE_PAGECACHE_OVERFLOW_STATS",
-#endif
-#if SQLITE_DISABLE_SKIPAHEAD_DISTINCT
-  "DISABLE_SKIPAHEAD_DISTINCT",
-#endif
-#ifdef SQLITE_ENABLE_8_3_NAMES
-  "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES),
-#endif
-#if SQLITE_ENABLE_API_ARMOR
-  "ENABLE_API_ARMOR",
-#endif
-#if SQLITE_ENABLE_ATOMIC_WRITE
-  "ENABLE_ATOMIC_WRITE",
-#endif
-#if SQLITE_ENABLE_BATCH_ATOMIC_WRITE
-  "ENABLE_BATCH_ATOMIC_WRITE",
-#endif
-#if SQLITE_ENABLE_BYTECODE_VTAB
-  "ENABLE_BYTECODE_VTAB",
-#endif
-#if SQLITE_ENABLE_CEROD
-  "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
-#endif
-#if SQLITE_ENABLE_COLUMN_METADATA
-  "ENABLE_COLUMN_METADATA",
-#endif
-#if SQLITE_ENABLE_COLUMN_USED_MASK
-  "ENABLE_COLUMN_USED_MASK",
-#endif
-#if SQLITE_ENABLE_COSTMULT
-  "ENABLE_COSTMULT",
-#endif
-#if SQLITE_ENABLE_CURSOR_HINTS
-  "ENABLE_CURSOR_HINTS",
-#endif
-#if SQLITE_ENABLE_DBSTAT_VTAB
-  "ENABLE_DBSTAT_VTAB",
-#endif
-#if SQLITE_ENABLE_EXPENSIVE_ASSERT
-  "ENABLE_EXPENSIVE_ASSERT",
-#endif
-#if SQLITE_ENABLE_FTS1
-  "ENABLE_FTS1",
-#endif
-#if SQLITE_ENABLE_FTS2
-  "ENABLE_FTS2",
-#endif
-#if SQLITE_ENABLE_FTS3
-  "ENABLE_FTS3",
-#endif
-#if SQLITE_ENABLE_FTS3_PARENTHESIS
-  "ENABLE_FTS3_PARENTHESIS",
-#endif
-#if SQLITE_ENABLE_FTS3_TOKENIZER
-  "ENABLE_FTS3_TOKENIZER",
-#endif
-#if SQLITE_ENABLE_FTS4
-  "ENABLE_FTS4",
-#endif
-#if SQLITE_ENABLE_FTS5
-  "ENABLE_FTS5",
-#endif
-#if SQLITE_ENABLE_GEOPOLY
-  "ENABLE_GEOPOLY",
-#endif
-#if SQLITE_ENABLE_HIDDEN_COLUMNS
-  "ENABLE_HIDDEN_COLUMNS",
-#endif
-#if SQLITE_ENABLE_ICU
-  "ENABLE_ICU",
-#endif
-#if SQLITE_ENABLE_IOTRACE
-  "ENABLE_IOTRACE",
-#endif
-#if SQLITE_ENABLE_JSON1
-  "ENABLE_JSON1",
-#endif
-#if SQLITE_ENABLE_LOAD_EXTENSION
-  "ENABLE_LOAD_EXTENSION",
-#endif
-#ifdef SQLITE_ENABLE_LOCKING_STYLE
-  "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
-#endif
-#if SQLITE_ENABLE_MEMORY_MANAGEMENT
-  "ENABLE_MEMORY_MANAGEMENT",
-#endif
-#if SQLITE_ENABLE_MEMSYS3
-  "ENABLE_MEMSYS3",
-#endif
-#if SQLITE_ENABLE_MEMSYS5
-  "ENABLE_MEMSYS5",
-#endif
-#if SQLITE_ENABLE_MULTIPLEX
-  "ENABLE_MULTIPLEX",
-#endif
-#if SQLITE_ENABLE_NORMALIZE
-  "ENABLE_NORMALIZE",
-#endif
-#if SQLITE_ENABLE_NULL_TRIM
-  "ENABLE_NULL_TRIM",
-#endif
-#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK
-  "ENABLE_OVERSIZE_CELL_CHECK",
-#endif
-#if SQLITE_ENABLE_PREUPDATE_HOOK
-  "ENABLE_PREUPDATE_HOOK",
-#endif
-#if SQLITE_ENABLE_QPSG
-  "ENABLE_QPSG",
-#endif
-#if SQLITE_ENABLE_RBU
-  "ENABLE_RBU",
-#endif
-#if SQLITE_ENABLE_RTREE
-  "ENABLE_RTREE",
-#endif
-#if SQLITE_ENABLE_SELECTTRACE
-  "ENABLE_SELECTTRACE",
-#endif
-#if SQLITE_ENABLE_SESSION
-  "ENABLE_SESSION",
-#endif
-#if SQLITE_ENABLE_SNAPSHOT
-  "ENABLE_SNAPSHOT",
-#endif
-#if SQLITE_ENABLE_SORTER_REFERENCES
-  "ENABLE_SORTER_REFERENCES",
-#endif
-#if SQLITE_ENABLE_SQLLOG
-  "ENABLE_SQLLOG",
-#endif
-#if defined(SQLITE_ENABLE_STAT4)
-  "ENABLE_STAT4",
-#endif
-#if SQLITE_ENABLE_STMTVTAB
-  "ENABLE_STMTVTAB",
-#endif
-#if SQLITE_ENABLE_STMT_SCANSTATUS
-  "ENABLE_STMT_SCANSTATUS",
-#endif
-#if SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
-  "ENABLE_UNKNOWN_SQL_FUNCTION",
-#endif
-#if SQLITE_ENABLE_UNLOCK_NOTIFY
-  "ENABLE_UNLOCK_NOTIFY",
-#endif
-#if SQLITE_ENABLE_UPDATE_DELETE_LIMIT
-  "ENABLE_UPDATE_DELETE_LIMIT",
-#endif
-#if SQLITE_ENABLE_URI_00_ERROR
-  "ENABLE_URI_00_ERROR",
-#endif
-#if SQLITE_ENABLE_VFSTRACE
-  "ENABLE_VFSTRACE",
-#endif
-#if SQLITE_ENABLE_WHERETRACE
-  "ENABLE_WHERETRACE",
-#endif
-#if SQLITE_ENABLE_ZIPVFS
-  "ENABLE_ZIPVFS",
-#endif
-#if SQLITE_EXPLAIN_ESTIMATED_ROWS
-  "EXPLAIN_ESTIMATED_ROWS",
-#endif
-#if SQLITE_EXTRA_IFNULLROW
-  "EXTRA_IFNULLROW",
-#endif
-#ifdef SQLITE_EXTRA_INIT
-  "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT),
-#endif
-#ifdef SQLITE_EXTRA_SHUTDOWN
-  "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN),
-#endif
-#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH
-  "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH),
-#endif
-#if SQLITE_FTS5_ENABLE_TEST_MI
-  "FTS5_ENABLE_TEST_MI",
-#endif
-#if SQLITE_FTS5_NO_WITHOUT_ROWID
-  "FTS5_NO_WITHOUT_ROWID",
-#endif
-#if HAVE_ISNAN || SQLITE_HAVE_ISNAN
-  "HAVE_ISNAN",
-#endif
-#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX
-  "HOMEGROWN_RECURSIVE_MUTEX",
-#endif
-#if SQLITE_IGNORE_AFP_LOCK_ERRORS
-  "IGNORE_AFP_LOCK_ERRORS",
-#endif
-#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS
-  "IGNORE_FLOCK_LOCK_ERRORS",
-#endif
-#if SQLITE_INLINE_MEMCPY
-  "INLINE_MEMCPY",
-#endif
-#if SQLITE_INT64_TYPE
-  "INT64_TYPE",
-#endif
-#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX
-  "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX),
-#endif
-#if SQLITE_LIKE_DOESNT_MATCH_BLOBS
-  "LIKE_DOESNT_MATCH_BLOBS",
-#endif
-#if SQLITE_LOCK_TRACE
-  "LOCK_TRACE",
-#endif
-#if SQLITE_LOG_CACHE_SPILL
-  "LOG_CACHE_SPILL",
-#endif
-#ifdef SQLITE_MALLOC_SOFT_LIMIT
-  "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT),
-#endif
-#ifdef SQLITE_MAX_ATTACHED
-  "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED),
-#endif
-#ifdef SQLITE_MAX_COLUMN
-  "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN),
-#endif
-#ifdef SQLITE_MAX_COMPOUND_SELECT
-  "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT),
-#endif
-#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE
-  "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE),
-#endif
-#ifdef SQLITE_MAX_EXPR_DEPTH
-  "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH),
-#endif
-#ifdef SQLITE_MAX_FUNCTION_ARG
-  "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG),
-#endif
-#ifdef SQLITE_MAX_LENGTH
-  "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH),
-#endif
-#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH
-  "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH),
-#endif
-#ifdef SQLITE_MAX_MEMORY
-  "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY),
-#endif
-#ifdef SQLITE_MAX_MMAP_SIZE
-  "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),
-#endif
-#ifdef SQLITE_MAX_MMAP_SIZE_
-  "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_),
-#endif
-#ifdef SQLITE_MAX_PAGE_COUNT
-  "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT),
-#endif
-#ifdef SQLITE_MAX_PAGE_SIZE
-  "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE),
-#endif
-#ifdef SQLITE_MAX_SCHEMA_RETRY
-  "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
-#endif
-#ifdef SQLITE_MAX_SQL_LENGTH
-  "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH),
-#endif
-#ifdef SQLITE_MAX_TRIGGER_DEPTH
-  "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH),
-#endif
-#ifdef SQLITE_MAX_VARIABLE_NUMBER
-  "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER),
-#endif
-#ifdef SQLITE_MAX_VDBE_OP
-  "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP),
-#endif
-#ifdef SQLITE_MAX_WORKER_THREADS
-  "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS),
-#endif
-#if SQLITE_MEMDEBUG
-  "MEMDEBUG",
-#endif
-#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT
-  "MIXED_ENDIAN_64BIT_FLOAT",
-#endif
-#if SQLITE_MMAP_READWRITE
-  "MMAP_READWRITE",
-#endif
-#if SQLITE_MUTEX_NOOP
-  "MUTEX_NOOP",
-#endif
-#if SQLITE_MUTEX_NREF
-  "MUTEX_NREF",
-#endif
-#if SQLITE_MUTEX_OMIT
-  "MUTEX_OMIT",
-#endif
-#if SQLITE_MUTEX_PTHREADS
-  "MUTEX_PTHREADS",
-#endif
-#if SQLITE_MUTEX_W32
-  "MUTEX_W32",
-#endif
-#if SQLITE_NEED_ERR_NAME
-  "NEED_ERR_NAME",
-#endif
-#if SQLITE_NOINLINE
-  "NOINLINE",
-#endif
-#if SQLITE_NO_SYNC
-  "NO_SYNC",
-#endif
-#if SQLITE_OMIT_ALTERTABLE
-  "OMIT_ALTERTABLE",
-#endif
-#if SQLITE_OMIT_ANALYZE
-  "OMIT_ANALYZE",
-#endif
-#if SQLITE_OMIT_ATTACH
-  "OMIT_ATTACH",
-#endif
-#if SQLITE_OMIT_AUTHORIZATION
-  "OMIT_AUTHORIZATION",
-#endif
-#if SQLITE_OMIT_AUTOINCREMENT
-  "OMIT_AUTOINCREMENT",
-#endif
-#if SQLITE_OMIT_AUTOINIT
-  "OMIT_AUTOINIT",
-#endif
-#if SQLITE_OMIT_AUTOMATIC_INDEX
-  "OMIT_AUTOMATIC_INDEX",
-#endif
-#if SQLITE_OMIT_AUTORESET
-  "OMIT_AUTORESET",
-#endif
-#if SQLITE_OMIT_AUTOVACUUM
-  "OMIT_AUTOVACUUM",
-#endif
-#if SQLITE_OMIT_BETWEEN_OPTIMIZATION
-  "OMIT_BETWEEN_OPTIMIZATION",
-#endif
-#if SQLITE_OMIT_BLOB_LITERAL
-  "OMIT_BLOB_LITERAL",
-#endif
-#if SQLITE_OMIT_CAST
-  "OMIT_CAST",
-#endif
-#if SQLITE_OMIT_CHECK
-  "OMIT_CHECK",
-#endif
-#if SQLITE_OMIT_COMPLETE
-  "OMIT_COMPLETE",
-#endif
-#if SQLITE_OMIT_COMPOUND_SELECT
-  "OMIT_COMPOUND_SELECT",
-#endif
-#if SQLITE_OMIT_CONFLICT_CLAUSE
-  "OMIT_CONFLICT_CLAUSE",
-#endif
-#if SQLITE_OMIT_CTE
-  "OMIT_CTE",
-#endif
-#if SQLITE_OMIT_DATETIME_FUNCS
-  "OMIT_DATETIME_FUNCS",
-#endif
-#if SQLITE_OMIT_DECLTYPE
-  "OMIT_DECLTYPE",
-#endif
-#if SQLITE_OMIT_DEPRECATED
-  "OMIT_DEPRECATED",
-#endif
-#if SQLITE_OMIT_DISKIO
-  "OMIT_DISKIO",
-#endif
-#if SQLITE_OMIT_EXPLAIN
-  "OMIT_EXPLAIN",
-#endif
-#if SQLITE_OMIT_FLAG_PRAGMAS
-  "OMIT_FLAG_PRAGMAS",
-#endif
-#if SQLITE_OMIT_FLOATING_POINT
-  "OMIT_FLOATING_POINT",
-#endif
-#if SQLITE_OMIT_FOREIGN_KEY
-  "OMIT_FOREIGN_KEY",
-#endif
-#if SQLITE_OMIT_GET_TABLE
-  "OMIT_GET_TABLE",
-#endif
-#if SQLITE_OMIT_HEX_INTEGER
-  "OMIT_HEX_INTEGER",
-#endif
-#if SQLITE_OMIT_INCRBLOB
-  "OMIT_INCRBLOB",
-#endif
-#if SQLITE_OMIT_INTEGRITY_CHECK
-  "OMIT_INTEGRITY_CHECK",
-#endif
-#if SQLITE_OMIT_LIKE_OPTIMIZATION
-  "OMIT_LIKE_OPTIMIZATION",
-#endif
-#if SQLITE_OMIT_LOAD_EXTENSION
-  "OMIT_LOAD_EXTENSION",
-#endif
-#if SQLITE_OMIT_LOCALTIME
-  "OMIT_LOCALTIME",
-#endif
-#if SQLITE_OMIT_LOOKASIDE
-  "OMIT_LOOKASIDE",
-#endif
-#if SQLITE_OMIT_MEMORYDB
-  "OMIT_MEMORYDB",
-#endif
-#if SQLITE_OMIT_OR_OPTIMIZATION
-  "OMIT_OR_OPTIMIZATION",
-#endif
-#if SQLITE_OMIT_PAGER_PRAGMAS
-  "OMIT_PAGER_PRAGMAS",
-#endif
-#if SQLITE_OMIT_PARSER_TRACE
-  "OMIT_PARSER_TRACE",
-#endif
-#if SQLITE_OMIT_POPEN
-  "OMIT_POPEN",
-#endif
-#if SQLITE_OMIT_PRAGMA
-  "OMIT_PRAGMA",
-#endif
-#if SQLITE_OMIT_PROGRESS_CALLBACK
-  "OMIT_PROGRESS_CALLBACK",
-#endif
-#if SQLITE_OMIT_QUICKBALANCE
-  "OMIT_QUICKBALANCE",
-#endif
-#if SQLITE_OMIT_REINDEX
-  "OMIT_REINDEX",
-#endif
-#if SQLITE_OMIT_SCHEMA_PRAGMAS
-  "OMIT_SCHEMA_PRAGMAS",
-#endif
-#if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
-  "OMIT_SCHEMA_VERSION_PRAGMAS",
-#endif
-#if SQLITE_OMIT_SHARED_CACHE
-  "OMIT_SHARED_CACHE",
-#endif
-#if SQLITE_OMIT_SHUTDOWN_DIRECTORIES
-  "OMIT_SHUTDOWN_DIRECTORIES",
-#endif
-#if SQLITE_OMIT_SUBQUERY
-  "OMIT_SUBQUERY",
-#endif
-#if SQLITE_OMIT_TCL_VARIABLE
-  "OMIT_TCL_VARIABLE",
-#endif
-#if SQLITE_OMIT_TEMPDB
-  "OMIT_TEMPDB",
-#endif
-#if SQLITE_OMIT_TEST_CONTROL
-  "OMIT_TEST_CONTROL",
-#endif
-#if SQLITE_OMIT_TRACE
-  "OMIT_TRACE",
-#endif
-#if SQLITE_OMIT_TRIGGER
-  "OMIT_TRIGGER",
-#endif
-#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION
-  "OMIT_TRUNCATE_OPTIMIZATION",
-#endif
-#if SQLITE_OMIT_UTF16
-  "OMIT_UTF16",
-#endif
-#if SQLITE_OMIT_VACUUM
-  "OMIT_VACUUM",
-#endif
-#if SQLITE_OMIT_VIEW
-  "OMIT_VIEW",
-#endif
-#if SQLITE_OMIT_VIRTUALTABLE
-  "OMIT_VIRTUALTABLE",
-#endif
-#if SQLITE_OMIT_WAL
-  "OMIT_WAL",
-#endif
-#if SQLITE_OMIT_WSD
-  "OMIT_WSD",
-#endif
-#if SQLITE_OMIT_XFER_OPT
-  "OMIT_XFER_OPT",
-#endif
-#if SQLITE_PCACHE_SEPARATE_HEADER
-  "PCACHE_SEPARATE_HEADER",
-#endif
-#if SQLITE_PERFORMANCE_TRACE
-  "PERFORMANCE_TRACE",
-#endif
-#if SQLITE_POWERSAFE_OVERWRITE
-  "POWERSAFE_OVERWRITE",
-#endif
-#if SQLITE_PREFER_PROXY_LOCKING
-  "PREFER_PROXY_LOCKING",
-#endif
-#if SQLITE_PROXY_DEBUG
-  "PROXY_DEBUG",
-#endif
-#if SQLITE_REVERSE_UNORDERED_SELECTS
-  "REVERSE_UNORDERED_SELECTS",
-#endif
-#if SQLITE_RTREE_INT_ONLY
-  "RTREE_INT_ONLY",
-#endif
-#if SQLITE_SECURE_DELETE
-  "SECURE_DELETE",
-#endif
-#if SQLITE_SMALL_STACK
-  "SMALL_STACK",
-#endif
-#ifdef SQLITE_SORTER_PMASZ
-  "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ),
-#endif
-#if SQLITE_SOUNDEX
-  "SOUNDEX",
-#endif
-#ifdef SQLITE_STAT4_SAMPLES
-  "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES),
-#endif
-#ifdef SQLITE_STMTJRNL_SPILL
-  "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
-#endif
-#if SQLITE_SUBSTR_COMPATIBILITY
-  "SUBSTR_COMPATIBILITY",
-#endif
-#if SQLITE_SYSTEM_MALLOC
-  "SYSTEM_MALLOC",
-#endif
-#if SQLITE_TCL
-  "TCL",
-#endif
-#ifdef SQLITE_TEMP_STORE
-  "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
-#endif
-#if SQLITE_TEST
-  "TEST",
-#endif
-#if defined(SQLITE_THREADSAFE)
-  "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
-#elif defined(THREADSAFE)
-  "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE),
-#else
-  "THREADSAFE=1",
-#endif
-#if SQLITE_UNLINK_AFTER_CLOSE
-  "UNLINK_AFTER_CLOSE",
-#endif
-#if SQLITE_UNTESTABLE
-  "UNTESTABLE",
-#endif
-#if SQLITE_USER_AUTHENTICATION
-  "USER_AUTHENTICATION",
-#endif
-#if SQLITE_USE_ALLOCA
-  "USE_ALLOCA",
-#endif
-#if SQLITE_USE_FCNTL_TRACE
-  "USE_FCNTL_TRACE",
-#endif
-#if SQLITE_USE_URI
-  "USE_URI",
-#endif
-#if SQLITE_VDBE_COVERAGE
-  "VDBE_COVERAGE",
-#endif
-#if SQLITE_WIN32_MALLOC
-  "WIN32_MALLOC",
-#endif
-#if SQLITE_ZERO_MALLOC
-  "ZERO_MALLOC",
-#endif
-/*
-** END CODE GENERATED BY tool/mkctime.tcl
-*/
-};
-
-SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){
-  *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]);
-  return (const char**)sqlite3azCompileOpt;
-}
-
-#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
-
-/************** End of ctime.c ***********************************************/
 /************** Begin file sqliteInt.h ***************************************/
 /*
 ** 2001 September 15
@@ -991,6 +226,18 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){
 # define MSVC_VERSION 0
 #endif
 
+/*
+** Some C99 functions in "math.h" are only present for MSVC when its version
+** is associated with Visual Studio 2013 or higher.
+*/
+#ifndef SQLITE_HAVE_C99_MATH_FUNCS
+# if MSVC_VERSION==0 || MSVC_VERSION>=1800
+#  define SQLITE_HAVE_C99_MATH_FUNCS (1)
+# else
+#  define SQLITE_HAVE_C99_MATH_FUNCS (0)
+# endif
+#endif
+
 /* Needed for various definitions... */
 #if defined(__GNUC__) && !defined(_GNU_SOURCE)
 # define _GNU_SOURCE
@@ -1041,6 +288,17 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){
 # define _USE_32BIT_TIME_T
 #endif
 
+/* Optionally #include a user-defined header, whereby compilation options
+** may be set prior to where they take effect, but after platform setup.
+** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include
+** file.
+*/
+#ifdef SQLITE_CUSTOM_INCLUDE
+# define INC_STRINGIFY_(f) #f
+# define INC_STRINGIFY(f) INC_STRINGIFY_(f)
+# include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE)
+#endif
+
 /* The public SQLite interface.  The _FILE_OFFSET_BITS macro must appear
 ** first in QNX.  Also, the _USE_32BIT_TIME_T macro must appear first for
 ** MinGW.
@@ -1092,7 +350,30 @@ extern "C" {
 
 
 /*
-** Provide the ability to override linkage features of the interface.
+** Facilitate override of interface linkage and calling conventions.
+** Be aware that these macros may not be used within this particular
+** translation of the amalgamation and its associated header file.
+**
+** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the
+** compiler that the target identifier should have external linkage.
+**
+** The SQLITE_CDECL macro is used to set the calling convention for
+** public functions that accept a variable number of arguments.
+**
+** The SQLITE_APICALL macro is used to set the calling convention for
+** public functions that accept a fixed number of arguments.
+**
+** The SQLITE_STDCALL macro is no longer used and is now deprecated.
+**
+** The SQLITE_CALLBACK macro is used to set the calling convention for
+** function pointers.
+**
+** The SQLITE_SYSAPI macro is used to set the calling convention for
+** functions provided by the operating system.
+**
+** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and
+** SQLITE_SYSAPI macros are used only when building for environments
+** that require non-default calling conventions.
 */
 #ifndef SQLITE_EXTERN
 # define SQLITE_EXTERN extern
@@ -1172,9 +453,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.34.0"
-#define SQLITE_VERSION_NUMBER 3034000
-#define SQLITE_SOURCE_ID      "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b"
+#define SQLITE_VERSION        "3.37.0"
+#define SQLITE_VERSION_NUMBER 3037000
+#define SQLITE_SOURCE_ID      "2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -1586,6 +867,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
 #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
 #define SQLITE_CONSTRAINT_PINNED       (SQLITE_CONSTRAINT |(11<<8))
+#define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))
 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
@@ -1599,6 +881,19 @@ SQLITE_API int sqlite3_exec(
 ** These bit values are intended for use in the
 ** 3rd parameter to the [sqlite3_open_v2()] interface and
 ** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
+**
+** Only those flags marked as "Ok for sqlite3_open_v2()" may be
+** used as the third argument to the [sqlite3_open_v2()] interface.
+** The other flags have historically been ignored by sqlite3_open_v2(),
+** though future versions of SQLite might change so that an error is
+** raised if any of the disallowed bits are passed into sqlite3_open_v2().
+** Applications should not depend on the historical behavior.
+**
+** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into
+** [sqlite3_open_v2()] does *not* cause the underlying database file
+** to be opened using O_EXCL.  Passing SQLITE_OPEN_EXCLUSIVE into
+** [sqlite3_open_v2()] has historically be a no-op and might become an
+** error in future versions of SQLite.
 */
 #define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
@@ -1621,6 +916,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
 #define SQLITE_OPEN_NOFOLLOW         0x01000000  /* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_EXRESCODE        0x02000000  /* Extended result codes */
 
 /* Reserved:                         0x00F00000 */
 /* Legacy compatibility: */
@@ -2177,6 +1473,23 @@ struct sqlite3_io_methods {
 ** file to the database file, but before the *-shm file is updated to
 ** record the fact that the pages have been checkpointed.
 ** </ul>
+**
+** <li>[[SQLITE_FCNTL_EXTERNAL_READER]]
+** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect
+** whether or not there is a database client in another process with a wal-mode
+** transaction open on the database or not. It is only available on unix.The
+** (void*) argument passed with this file-control should be a pointer to a
+** value of type (int). The integer value is set to 1 if the database is a wal
+** mode database and there exists at least one client in another process that
+** currently has an SQL transaction open on the database. It is set to 0 if
+** the database is not a wal-mode db, or if there is no such connection in any
+** other process. This opcode cannot be used to detect transactions opened
+** by clients within the current process, only within other processes.
+** </ul>
+**
+** <li>[[SQLITE_FCNTL_CKSM_FILE]]
+** Used by the cksmvfs VFS module only.
+** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
@@ -2216,6 +1529,8 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_CKPT_DONE              37
 #define SQLITE_FCNTL_RESERVE_BYTES          38
 #define SQLITE_FCNTL_CKPT_START             39
+#define SQLITE_FCNTL_EXTERNAL_READER        40
+#define SQLITE_FCNTL_CKSM_FILE              41
 
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -3164,7 +2479,13 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether triggers are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the trigger setting is not reported back. </dd>
+** which case the trigger setting is not reported back.
+**
+** <p>Originally this option disabled all triggers.  ^(However, since
+** SQLite version 3.35.0, TEMP triggers are still allowed even if
+** this option is off.  So, in other words, this option now only disables
+** triggers in the main database schema or in the schemas of ATTACH-ed
+** databases.)^ </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_VIEW]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_VIEW</dt>
@@ -3175,7 +2496,13 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether views are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the view setting is not reported back. </dd>
+** which case the view setting is not reported back.
+**
+** <p>Originally this option disabled all views.  ^(However, since
+** SQLite version 3.35.0, TEMP views are still allowed even if
+** this option is off.  So, in other words, this option now only disables
+** views in the main database schema or in the schemas of ATTACH-ed
+** databases.)^ </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
@@ -3482,11 +2809,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** CAPI3REF: Count The Number Of Rows Modified
 ** METHOD: sqlite3
 **
-** ^This function returns the number of rows modified, inserted or
+** ^These functions return the number of rows modified, inserted or
 ** deleted by the most recently completed INSERT, UPDATE or DELETE
 ** statement on the database connection specified by the only parameter.
-** ^Executing any other type of SQL statement does not modify the value
-** returned by this function.
+** The two functions are identical except for the type of the return value
+** and that if the number of rows modified by the most recent INSERT, UPDATE
+** or DELETE is greater than the maximum value supported by type "int", then
+** the return value of sqlite3_changes() is undefined. ^Executing any other
+** type of SQL statement does not modify the value returned by these functions.
 **
 ** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are
 ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
@@ -3535,16 +2865,21 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** </ul>
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
+SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
 
 /*
 ** CAPI3REF: Total Number Of Rows Modified
 ** METHOD: sqlite3
 **
-** ^This function returns the total number of rows inserted, modified or
+** ^These functions return the total number of rows inserted, modified or
 ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
 ** since the database connection was opened, including those executed as
-** part of trigger programs. ^Executing any other type of SQL statement
-** does not affect the value returned by sqlite3_total_changes().
+** part of trigger programs. The two functions are identical except for the
+** type of the return value and that if the number of rows modified by the
+** connection exceeds the maximum value supported by type "int", then
+** the return value of sqlite3_total_changes() is undefined. ^Executing
+** any other type of SQL statement does not affect the value returned by
+** sqlite3_total_changes().
 **
 ** ^Changes made as part of [foreign key actions] are included in the
 ** count, but those made as part of REPLACE constraint resolution are
@@ -3572,6 +2907,7 @@ SQLITE_API int sqlite3_changes(sqlite3*);
 ** </ul>
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
+SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
 
 /*
 ** CAPI3REF: Interrupt A Long-Running Query
@@ -4401,6 +3737,14 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** the default shared cache setting provided by
 ** [sqlite3_enable_shared_cache()].)^
 **
+** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
+** <dd>The database connection comes up in "extended result code mode".
+** In other words, the database behaves has if
+** [sqlite3_extended_result_codes(db,1)] where called on the database
+** connection as soon as the connection is created. In addition to setting
+** the extended result code mode, this flag also causes [sqlite3_open_v2()]
+** to return an extended result code.</dd>
+**
 ** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
 ** <dd>The database filename is not allowed to be a symbolic link</dd>
 ** </dl>)^
@@ -4408,7 +3752,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
 ** required combinations shown above optionally combined with other
 ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
-** then the behavior is undefined.
+** then the behavior is undefined.  Historic versions of SQLite
+** have silently ignored surplus bits in the flags parameter to
+** sqlite3_open_v2(), however that behavior might not be carried through
+** into future versions of SQLite and so applications should not rely
+** upon it.  Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op
+** for sqlite3_open_v2().  The SQLITE_OPEN_EXCLUSIVE does *not* cause
+** the open to fail if the database already exists.  The SQLITE_OPEN_EXCLUSIVE
+** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not
+** by sqlite3_open_v2().
 **
 ** ^The fourth parameter to sqlite3_open_v2() is the name of the
 ** [sqlite3_vfs] object that defines the operating system interface that
@@ -4548,6 +3900,7 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **          that uses dot-files in place of posix advisory locking.
 ** <tr><td> file:data.db?mode=readonly <td>
 **          An error. "readonly" is not a valid option for the "mode" parameter.
+**          Use "ro" instead:  "file:data.db?mode=ro".
 ** </table>
 **
 ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
@@ -4746,7 +4099,7 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*);
 ** If the Y parameter to sqlite3_free_filename(Y) is anything other
 ** than a NULL pointer or a pointer previously acquired from
 ** sqlite3_create_filename(), then bad things such as heap
-** corruption or segfaults may occur. The value Y should be
+** corruption or segfaults may occur. The value Y should not be
 ** used again after sqlite3_free_filename(Y) has been called.  This means
 ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y,
 ** then the corresponding [sqlite3_module.xClose() method should also be
@@ -5175,12 +4528,17 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** are managed by SQLite and are automatically freed when the prepared
 ** statement is finalized.
 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
-** is obtained from [sqlite3_malloc()] and must be free by the application
+** is obtained from [sqlite3_malloc()] and must be freed by the application
 ** by passing it to [sqlite3_free()].
+**
+** ^The sqlite3_normalized_sql() interface is only available if
+** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined.
 */
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
+#ifdef SQLITE_ENABLE_NORMALIZE
 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
+#endif
 
 /*
 ** CAPI3REF: Determine If An SQL Statement Writes The Database
@@ -5215,6 +4573,15 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and
 ** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so
 ** sqlite3_stmt_readonly() returns false for those commands.
+**
+** ^This routine returns false if there is any possibility that the
+** statement might change the database file.  ^A false return does
+** not guarantee that the statement will change the database file.
+** ^For example, an UPDATE statement might have a WHERE clause that
+** makes it a no-op, but the sqlite3_stmt_readonly() result would still
+** be false.  ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a
+** read-only no-op if the table already exists, but
+** sqlite3_stmt_readonly() still returns false for such a statement.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 
@@ -5384,18 +4751,22 @@ typedef struct sqlite3_context sqlite3_context;
 ** contain embedded NULs.  The result of expressions involving strings
 ** with embedded NULs is undefined.
 **
-** ^The fifth argument to the BLOB and string binding interfaces
-** is a destructor used to dispose of the BLOB or
-** string after SQLite has finished with it.  ^The destructor is called
-** to dispose of the BLOB or string even if the call to the bind API fails,
-** except the destructor is not called if the third parameter is a NULL
-** pointer or the fourth parameter is negative.
-** ^If the fifth argument is
-** the special value [SQLITE_STATIC], then SQLite assumes that the
-** information is in static, unmanaged space and does not need to be freed.
-** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
-** SQLite makes its own private copy of the data immediately, before
-** the sqlite3_bind_*() routine returns.
+** ^The fifth argument to the BLOB and string binding interfaces controls
+** or indicates the lifetime of the object referenced by the third parameter.
+** These three options exist:
+** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
+** with it may be passed. ^It is called to dispose of the BLOB or string even
+** if the call to the bind API fails, except the destructor is not called if
+** the third parameter is a NULL pointer or the fourth parameter is negative.
+** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
+** the application remains responsible for disposing of the object. ^In this
+** case, the object and the provided pointer to it must remain valid until
+** either the prepared statement is finalized or the same SQL parameter is
+** bound to something else, whichever occurs sooner.
+** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
+** object is to be copied prior to the return from sqlite3_bind_*(). ^The
+** object and pointer to it must remain valid until then. ^SQLite will then
+** manage the lifetime of its private copy.
 **
 ** ^The sixth argument to sqlite3_bind_text64() must be one of
 ** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
@@ -6137,7 +5508,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions,
 ** index expressions, or the WHERE clause of partial indexes.
 **
-** <span style="background-color:#ffff90;">
 ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for
 ** all application-defined SQL functions that do not need to be
 ** used inside of triggers, view, CHECK constraints, or other elements of
@@ -6147,7 +5517,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** a database file to include invocations of the function with parameters
 ** chosen by the attacker, which the application will then execute when
 ** the database file is opened and read.
-** </span>
 **
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^
@@ -7353,6 +6722,72 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 
+/*
+** CAPI3REF: Autovacuum Compaction Amount Callback
+** METHOD: sqlite3
+**
+** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback
+** function C that is invoked prior to each autovacuum of the database
+** file.  ^The callback is passed a copy of the generic data pointer (P),
+** the schema-name of the attached database that is being autovacuumed,
+** the the size of the database file in pages, the number of free pages,
+** and the number of bytes per page, respectively.  The callback should
+** return the number of free pages that should be removed by the
+** autovacuum.  ^If the callback returns zero, then no autovacuum happens.
+** ^If the value returned is greater than or equal to the number of
+** free pages, then a complete autovacuum happens.
+**
+** <p>^If there are multiple ATTACH-ed database files that are being
+** modified as part of a transaction commit, then the autovacuum pages
+** callback is invoked separately for each file.
+**
+** <p><b>The callback is not reentrant.</b> The callback function should
+** not attempt to invoke any other SQLite interface.  If it does, bad
+** things may happen, including segmentation faults and corrupt database
+** files.  The callback function should be a simple function that
+** does some arithmetic on its input parameters and returns a result.
+**
+** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional
+** destructor for the P parameter.  ^If X is not NULL, then X(P) is
+** invoked whenever the database connection closes or when the callback
+** is overwritten by another invocation of sqlite3_autovacuum_pages().
+**
+** <p>^There is only one autovacuum pages callback per database connection.
+** ^Each call to the sqlite3_autovacuum_pages() interface overrides all
+** previous invocations for that database connection.  ^If the callback
+** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer,
+** then the autovacuum steps callback is cancelled.  The return value
+** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might
+** be some other error code if something goes wrong.  The current
+** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other
+** return codes might be added in future releases.
+**
+** <p>If no autovacuum pages callback is specified (the usual case) or
+** a NULL pointer is provided for the callback,
+** then the default behavior is to vacuum all free pages.  So, in other
+** words, the default behavior is the same as if the callback function
+** were something like this:
+**
+** <blockquote><pre>
+** &nbsp;   unsigned int demonstration_autovac_pages_callback(
+** &nbsp;     void *pClientData,
+** &nbsp;     const char *zSchema,
+** &nbsp;     unsigned int nDbPage,
+** &nbsp;     unsigned int nFreePage,
+** &nbsp;     unsigned int nBytePerPage
+** &nbsp;   ){
+** &nbsp;     return nFreePage;
+** &nbsp;   }
+** </pre></blockquote>
+*/
+SQLITE_API int sqlite3_autovacuum_pages(
+  sqlite3 *db,
+  unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+  void*,
+  void(*)(void*)
+);
+
+
 /*
 ** CAPI3REF: Data Change Notification Callbacks
 ** METHOD: sqlite3
@@ -8814,7 +8249,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_PRNG_SEED               28
 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
 #define SQLITE_TESTCTRL_SEEK_COUNT              30
-#define SQLITE_TESTCTRL_LAST                    30  /* Largest TESTCTRL */
+#define SQLITE_TESTCTRL_TRACEFLAGS              31
+#define SQLITE_TESTCTRL_TUNE                    32
+#define SQLITE_TESTCTRL_LAST                    32  /* Largest TESTCTRL */
 
 /*
 ** CAPI3REF: SQL Keyword Checking
@@ -10014,8 +9451,9 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
 **
 ** A single database handle may have at most a single write-ahead log callback
 ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
-** previously registered write-ahead log callback. ^Note that the
-** [sqlite3_wal_autocheckpoint()] interface and the
+** previously registered write-ahead log callback. ^The return value is
+** a copy of the third parameter from the previous call, if any, or 0.
+** ^Note that the [sqlite3_wal_autocheckpoint()] interface and the
 ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
 ** overwrite any prior [sqlite3_wal_hook()] settings.
 */
@@ -10566,6 +10004,15 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** triggers; or 2 for changes resulting from triggers called by top-level
 ** triggers; and so forth.
 **
+** When the [sqlite3_blob_write()] API is used to update a blob column,
+** the pre-update hook is invoked with SQLITE_DELETE. This is because the
+** in this case the new values are not available. In this case, when a
+** callback made with op==SQLITE_DELETE is actuall a write using the
+** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns
+** the index of the column being written. In other cases, where the
+** pre-update hook is being invoked for some other reason, including a
+** regular DELETE, sqlite3_preupdate_blobwrite() returns -1.
+**
 ** See also:  [sqlite3_update_hook()]
 */
 #if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
@@ -10586,6 +10033,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);
 SQLITE_API int sqlite3_preupdate_count(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_depth(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);
+SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *);
 #endif
 
 /*
@@ -10824,8 +10272,8 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const c
 ** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory
 ** allocation error occurs.
 **
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_DESERIALIZE] option.
+** This interface is omitted if SQLite is compiled with the
+** [SQLITE_OMIT_DESERIALIZE] option.
 */
 SQLITE_API unsigned char *sqlite3_serialize(
   sqlite3 *db,           /* The database connection */
@@ -10872,12 +10320,16 @@ SQLITE_API unsigned char *sqlite3_serialize(
 ** database is currently in a read transaction or is involved in a backup
 ** operation.
 **
+** It is not possible to deserialized into the TEMP database.  If the
+** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the
+** function returns SQLITE_ERROR.
+**
 ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the
 ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
 ** [sqlite3_free()] is invoked on argument P prior to returning.
 **
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_DESERIALIZE] option.
+** This interface is omitted if SQLite is compiled with the
+** [SQLITE_OMIT_DESERIALIZE] option.
 */
 SQLITE_API int sqlite3_deserialize(
   sqlite3 *db,            /* The database connection */
@@ -11126,6 +10578,38 @@ SQLITE_API int sqlite3session_create(
 */
 SQLITE_API void sqlite3session_delete(sqlite3_session *pSession);
 
+/*
+** CAPIREF: Conigure a Session Object
+** METHOD: sqlite3_session
+**
+** This method is used to configure a session object after it has been
+** created. At present the only valid value for the second parameter is
+** [SQLITE_SESSION_OBJCONFIG_SIZE].
+**
+** Arguments for sqlite3session_object_config()
+**
+** The following values may passed as the the 4th parameter to
+** sqlite3session_object_config().
+**
+** <dt>SQLITE_SESSION_OBJCONFIG_SIZE <dd>
+**   This option is used to set, clear or query the flag that enables
+**   the [sqlite3session_changeset_size()] API. Because it imposes some
+**   computational overhead, this API is disabled by default. Argument
+**   pArg must point to a value of type (int). If the value is initially
+**   0, then the sqlite3session_changeset_size() API is disabled. If it
+**   is greater than 0, then the same API is enabled. Or, if the initial
+**   value is less than zero, no change is made. In all cases the (int)
+**   variable is set to 1 if the sqlite3session_changeset_size() API is
+**   enabled following the current call, or 0 otherwise.
+**
+**   It is an error (SQLITE_MISUSE) to attempt to modify this setting after
+**   the first table has been attached to the session object.
+*/
+SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg);
+
+/*
+*/
+#define SQLITE_SESSION_OBJCONFIG_SIZE 1
 
 /*
 ** CAPI3REF: Enable Or Disable A Session Object
@@ -11370,6 +10854,22 @@ SQLITE_API int sqlite3session_changeset(
   void **ppChangeset              /* OUT: Buffer containing changeset */
 );
 
+/*
+** CAPI3REF: Return An Upper-limit For The Size Of The Changeset
+** METHOD: sqlite3_session
+**
+** By default, this function always returns 0. For it to return
+** a useful result, the sqlite3_session object must have been configured
+** to enable this API using sqlite3session_object_config() with the
+** SQLITE_SESSION_OBJCONFIG_SIZE verb.
+**
+** When enabled, this function returns an upper limit, in bytes, for the size
+** of the changeset that might be produced if sqlite3session_changeset() were
+** called. The final changeset size might be equal to or smaller than the
+** size in bytes returned by this function.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession);
+
 /*
 ** CAPI3REF: Load The Difference Between Tables Into A Session
 ** METHOD: sqlite3_session
@@ -11487,6 +10987,14 @@ SQLITE_API int sqlite3session_patchset(
 */
 SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession);
 
+/*
+** CAPI3REF: Query for the amount of heap memory used by a session object.
+**
+** This API returns the total amount of heap memory in bytes currently
+** used by the session object passed as the only argument.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
+
 /*
 ** CAPI3REF: Create An Iterator To Traverse A Changeset
 ** CONSTRUCTOR: sqlite3_changeset_iter
@@ -11589,18 +11097,23 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
 ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this
 ** is not the case, this function returns [SQLITE_MISUSE].
 **
-** If argument pzTab is not NULL, then *pzTab is set to point to a
-** nul-terminated utf-8 encoded string containing the name of the table
-** affected by the current change. The buffer remains valid until either
-** sqlite3changeset_next() is called on the iterator or until the
-** conflict-handler function returns. If pnCol is not NULL, then *pnCol is
-** set to the number of columns in the table affected by the change. If
-** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
+** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three
+** outputs are set through these pointers:
+**
+** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
+** depending on the type of change that the iterator currently points to;
+**
+** *pnCol is set to the number of columns in the table affected by the change; and
+**
+** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
+** the name of the table affected by the current change. The buffer remains
+** valid until either sqlite3changeset_next() is called on the iterator
+** or until the conflict-handler function returns.
+**
+** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
 ** is an indirect change, or false (0) otherwise. See the documentation for
 ** [sqlite3session_indirect()] for a description of direct and indirect
-** changes. Finally, if pOp is not NULL, then *pOp is set to one of
-** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the
-** type of change that the iterator currently points to.
+** changes.
 **
 ** If no error occurs, SQLITE_OK is returned. If an error does occur, an
 ** SQLite error code is returned. The values of the output variables may not
@@ -13293,7 +12806,7 @@ struct fts5_api {
 ** autoconf-based build
 */
 #if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
-/* #include "config.h" */
+#include "config.h"
 #define SQLITECONFIG_H 1
 #endif
 
@@ -13530,9 +13043,11 @@ struct fts5_api {
 # define __has_extension(x) 0     /* compatibility with non-clang compilers */
 #endif
 #if GCC_VERSION>=4007000 || __has_extension(c_atomic)
+# define SQLITE_ATOMIC_INTRINSICS 1
 # define AtomicLoad(PTR)       __atomic_load_n((PTR),__ATOMIC_RELAXED)
 # define AtomicStore(PTR,VAL)  __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED)
 #else
+# define SQLITE_ATOMIC_INTRINSICS 0
 # define AtomicLoad(PTR)       (*(PTR))
 # define AtomicStore(PTR,VAL)  (*(PTR) = (VAL))
 #endif
@@ -13737,11 +13252,12 @@ struct fts5_api {
 ** is significant and used at least once.  On switch statements
 ** where multiple cases go to the same block of code, testcase()
 ** can insure that all cases are evaluated.
-**
 */
-#ifdef SQLITE_COVERAGE_TEST
-SQLITE_PRIVATE   void sqlite3Coverage(int);
-# define testcase(X)  if( X ){ sqlite3Coverage(__LINE__); }
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
+# ifndef SQLITE_AMALGAMATION
+    extern unsigned int sqlite3CoverageCounter;
+# endif
+# define testcase(X)  if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; }
 #else
 # define testcase(X)
 #endif
@@ -13771,6 +13287,14 @@ SQLITE_PRIVATE   void sqlite3Coverage(int);
 # define VVA_ONLY(X)
 #endif
 
+/*
+** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage
+** and mutation testing
+*/
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS  1
+#endif
+
 /*
 ** The ALWAYS and NEVER macros surround boolean expressions which
 ** are intended to always be true or false, respectively.  Such
@@ -13786,7 +13310,7 @@ SQLITE_PRIVATE   void sqlite3Coverage(int);
 ** be true and false so that the unreachable code they specify will
 ** not be counted as untested code.
 */
-#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
 # define ALWAYS(X)      (1)
 # define NEVER(X)       (0)
 #elif !defined(NDEBUG)
@@ -13797,26 +13321,6 @@ SQLITE_PRIVATE   void sqlite3Coverage(int);
 # define NEVER(X)       (X)
 #endif
 
-/*
-** The harmless(X) macro indicates that expression X is usually false
-** but can be true without causing any problems, but we don't know of
-** any way to cause X to be true.
-**
-** In debugging and testing builds, this macro will abort if X is ever
-** true.  In this way, developers are alerted to a possible test case
-** that causes X to be true.  If a harmless macro ever fails, that is
-** an opportunity to change the macro into a testcase() and add a new
-** test case to the test suite.
-**
-** For normal production builds, harmless(X) is a no-op, since it does
-** not matter whether expression X is true or false.
-*/
-#ifdef SQLITE_DEBUG
-# define harmless(X)  assert(!(X));
-#else
-# define harmless(X)
-#endif
-
 /*
 ** Some conditionals are optimizations only.  In other words, if the
 ** conditionals are replaced with a constant 1 (true) or 0 (false) then
@@ -13880,6 +13384,13 @@ SQLITE_PRIVATE   void sqlite3Coverage(int);
 # undef SQLITE_ENABLE_EXPLAIN_COMMENTS
 #endif
 
+/*
+** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE
+*/
+#if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE)
+# define SQLITE_OMIT_ALTERTABLE
+#endif
+
 /*
 ** Return true (non-zero) if the input is an integer that is too large
 ** to fit in 32-bits.  This macro is used inside of various testcase()
@@ -13992,7 +13503,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 /*
 ** Number of entries in a hash table
 */
-/* #define sqliteHashCount(H)  ((H)->count) // NOT USED */
+#define sqliteHashCount(H)  ((H)->count)
 
 #endif /* SQLITE_HASH_H */
 
@@ -14024,8 +13535,8 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #define TK_LP                              22
 #define TK_RP                              23
 #define TK_AS                              24
-#define TK_WITHOUT                         25
-#define TK_COMMA                           26
+#define TK_COMMA                           25
+#define TK_WITHOUT                         26
 #define TK_ABORT                           27
 #define TK_ACTION                          28
 #define TK_AFTER                           29
@@ -14096,90 +13607,93 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #define TK_TIES                            94
 #define TK_GENERATED                       95
 #define TK_ALWAYS                          96
-#define TK_REINDEX                         97
-#define TK_RENAME                          98
-#define TK_CTIME_KW                        99
-#define TK_ANY                            100
-#define TK_BITAND                         101
-#define TK_BITOR                          102
-#define TK_LSHIFT                         103
-#define TK_RSHIFT                         104
-#define TK_PLUS                           105
-#define TK_MINUS                          106
-#define TK_STAR                           107
-#define TK_SLASH                          108
-#define TK_REM                            109
-#define TK_CONCAT                         110
-#define TK_COLLATE                        111
-#define TK_BITNOT                         112
-#define TK_ON                             113
-#define TK_INDEXED                        114
-#define TK_STRING                         115
-#define TK_JOIN_KW                        116
-#define TK_CONSTRAINT                     117
-#define TK_DEFAULT                        118
-#define TK_NULL                           119
-#define TK_PRIMARY                        120
-#define TK_UNIQUE                         121
-#define TK_CHECK                          122
-#define TK_REFERENCES                     123
-#define TK_AUTOINCR                       124
-#define TK_INSERT                         125
-#define TK_DELETE                         126
-#define TK_UPDATE                         127
-#define TK_SET                            128
-#define TK_DEFERRABLE                     129
-#define TK_FOREIGN                        130
-#define TK_DROP                           131
-#define TK_UNION                          132
-#define TK_ALL                            133
-#define TK_EXCEPT                         134
-#define TK_INTERSECT                      135
-#define TK_SELECT                         136
-#define TK_VALUES                         137
-#define TK_DISTINCT                       138
-#define TK_DOT                            139
-#define TK_FROM                           140
-#define TK_JOIN                           141
-#define TK_USING                          142
-#define TK_ORDER                          143
-#define TK_GROUP                          144
-#define TK_HAVING                         145
-#define TK_LIMIT                          146
-#define TK_WHERE                          147
-#define TK_INTO                           148
-#define TK_NOTHING                        149
-#define TK_FLOAT                          150
-#define TK_BLOB                           151
-#define TK_INTEGER                        152
-#define TK_VARIABLE                       153
-#define TK_CASE                           154
-#define TK_WHEN                           155
-#define TK_THEN                           156
-#define TK_ELSE                           157
-#define TK_INDEX                          158
-#define TK_ALTER                          159
-#define TK_ADD                            160
-#define TK_WINDOW                         161
-#define TK_OVER                           162
-#define TK_FILTER                         163
-#define TK_COLUMN                         164
-#define TK_AGG_FUNCTION                   165
-#define TK_AGG_COLUMN                     166
-#define TK_TRUEFALSE                      167
-#define TK_ISNOT                          168
-#define TK_FUNCTION                       169
-#define TK_UMINUS                         170
-#define TK_UPLUS                          171
-#define TK_TRUTH                          172
-#define TK_REGISTER                       173
-#define TK_VECTOR                         174
-#define TK_SELECT_COLUMN                  175
-#define TK_IF_NULL_ROW                    176
-#define TK_ASTERISK                       177
-#define TK_SPAN                           178
-#define TK_SPACE                          179
-#define TK_ILLEGAL                        180
+#define TK_MATERIALIZED                    97
+#define TK_REINDEX                         98
+#define TK_RENAME                          99
+#define TK_CTIME_KW                       100
+#define TK_ANY                            101
+#define TK_BITAND                         102
+#define TK_BITOR                          103
+#define TK_LSHIFT                         104
+#define TK_RSHIFT                         105
+#define TK_PLUS                           106
+#define TK_MINUS                          107
+#define TK_STAR                           108
+#define TK_SLASH                          109
+#define TK_REM                            110
+#define TK_CONCAT                         111
+#define TK_COLLATE                        112
+#define TK_BITNOT                         113
+#define TK_ON                             114
+#define TK_INDEXED                        115
+#define TK_STRING                         116
+#define TK_JOIN_KW                        117
+#define TK_CONSTRAINT                     118
+#define TK_DEFAULT                        119
+#define TK_NULL                           120
+#define TK_PRIMARY                        121
+#define TK_UNIQUE                         122
+#define TK_CHECK                          123
+#define TK_REFERENCES                     124
+#define TK_AUTOINCR                       125
+#define TK_INSERT                         126
+#define TK_DELETE                         127
+#define TK_UPDATE                         128
+#define TK_SET                            129
+#define TK_DEFERRABLE                     130
+#define TK_FOREIGN                        131
+#define TK_DROP                           132
+#define TK_UNION                          133
+#define TK_ALL                            134
+#define TK_EXCEPT                         135
+#define TK_INTERSECT                      136
+#define TK_SELECT                         137
+#define TK_VALUES                         138
+#define TK_DISTINCT                       139
+#define TK_DOT                            140
+#define TK_FROM                           141
+#define TK_JOIN                           142
+#define TK_USING                          143
+#define TK_ORDER                          144
+#define TK_GROUP                          145
+#define TK_HAVING                         146
+#define TK_LIMIT                          147
+#define TK_WHERE                          148
+#define TK_RETURNING                      149
+#define TK_INTO                           150
+#define TK_NOTHING                        151
+#define TK_FLOAT                          152
+#define TK_BLOB                           153
+#define TK_INTEGER                        154
+#define TK_VARIABLE                       155
+#define TK_CASE                           156
+#define TK_WHEN                           157
+#define TK_THEN                           158
+#define TK_ELSE                           159
+#define TK_INDEX                          160
+#define TK_ALTER                          161
+#define TK_ADD                            162
+#define TK_WINDOW                         163
+#define TK_OVER                           164
+#define TK_FILTER                         165
+#define TK_COLUMN                         166
+#define TK_AGG_FUNCTION                   167
+#define TK_AGG_COLUMN                     168
+#define TK_TRUEFALSE                      169
+#define TK_ISNOT                          170
+#define TK_FUNCTION                       171
+#define TK_UMINUS                         172
+#define TK_UPLUS                          173
+#define TK_TRUTH                          174
+#define TK_REGISTER                       175
+#define TK_VECTOR                         176
+#define TK_SELECT_COLUMN                  177
+#define TK_IF_NULL_ROW                    178
+#define TK_ASTERISK                       179
+#define TK_SPAN                           180
+#define TK_ERROR                          181
+#define TK_SPACE                          182
+#define TK_ILLEGAL                        183
 
 /************** End of parse.h ***********************************************/
 /************** Continuing where we left off in sqliteInt.h ******************/
@@ -14285,7 +13799,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 ** number of pages.  A negative number N translations means that a buffer
 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
 **
-** The default value of "20" was choosen to minimize the run-time of the
+** The default value of "20" was chosen to minimize the run-time of the
 ** speedtest1 test program with options: --shrink-memory --reprepare
 */
 #ifndef SQLITE_DEFAULT_PCACHE_INITSZ
@@ -14447,6 +13961,7 @@ typedef INT16_TYPE LogEst;
 #   define SQLITE_PTRSIZE __SIZEOF_POINTER__
 # elif defined(i386)     || defined(__i386__)   || defined(_M_IX86) ||    \
        defined(_M_ARM)   || defined(__arm__)    || defined(__x86)   ||    \
+      (defined(__APPLE__) && defined(__POWERPC__)) ||                     \
       (defined(__TOS_AIX__) && !defined(__64BIT__))
 #   define SQLITE_PTRSIZE 4
 # else
@@ -14595,15 +14110,14 @@ typedef INT16_TYPE LogEst;
 ** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
 ** the Select query generator tracing logic is turned on.
 */
-#if defined(SQLITE_ENABLE_SELECTTRACE)
-# define SELECTTRACE_ENABLED 1
-#else
-# define SELECTTRACE_ENABLED 0
+#if !defined(SQLITE_AMALGAMATION)
+SQLITE_PRIVATE u32 sqlite3SelectTrace;
 #endif
-#if defined(SQLITE_ENABLE_SELECTTRACE)
+#if defined(SQLITE_DEBUG) \
+    && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE))
 # define SELECTTRACE_ENABLED 1
 # define SELECTTRACE(K,P,S,X)  \
-  if(sqlite3_unsupported_selecttrace&(K))   \
+  if(sqlite3SelectTrace&(K))   \
     sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
     sqlite3DebugPrintf X
 #else
@@ -14611,6 +14125,19 @@ typedef INT16_TYPE LogEst;
 # define SELECTTRACE_ENABLED 0
 #endif
 
+/*
+** Macros for "wheretrace"
+*/
+SQLITE_PRIVATE u32 sqlite3WhereTrace;
+#if defined(SQLITE_DEBUG) \
+    && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE))
+# define WHERETRACE(K,X)  if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X
+# define WHERETRACE_ENABLED 1
+#else
+# define WHERETRACE(K,X)
+#endif
+
+
 /*
 ** An instance of the following structure is used to store the busy-handler
 ** callback for a given sqlite handle.
@@ -14629,11 +14156,25 @@ struct BusyHandler {
 
 /*
 ** Name of table that holds the database schema.
+**
+** The PREFERRED names are used whereever possible.  But LEGACY is also
+** used for backwards compatibility.
+**
+**  1.  Queries can use either the PREFERRED or the LEGACY names
+**  2.  The sqlite3_set_authorizer() callback uses the LEGACY name
+**  3.  The PRAGMA table_list statement uses the PREFERRED name
+**
+** The LEGACY names are stored in the internal symbol hash table
+** in support of (2).  Names are translated using sqlite3PreferredTableName()
+** for (3).  The sqlite3FindTable() function takes care of translating
+** names for (1).
+**
+** Note that "sqlite_temp_schema" can also be called "temp.sqlite_schema".
 */
-#define DFLT_SCHEMA_TABLE          "sqlite_master"
-#define DFLT_TEMP_SCHEMA_TABLE     "sqlite_temp_master"
-#define ALT_SCHEMA_TABLE           "sqlite_schema"
-#define ALT_TEMP_SCHEMA_TABLE      "sqlite_temp_schema"
+#define LEGACY_SCHEMA_TABLE          "sqlite_master"
+#define LEGACY_TEMP_SCHEMA_TABLE     "sqlite_temp_master"
+#define PREFERRED_SCHEMA_TABLE       "sqlite_schema"
+#define PREFERRED_TEMP_SCHEMA_TABLE  "sqlite_temp_schema"
 
 
 /*
@@ -14645,7 +14186,7 @@ struct BusyHandler {
 ** The name of the schema table.  The name is different for TEMP.
 */
 #define SCHEMA_TABLE(x) \
-    ((!OMIT_TEMPDB)&&(x==1)?DFLT_TEMP_SCHEMA_TABLE:DFLT_SCHEMA_TABLE)
+    ((!OMIT_TEMPDB)&&(x==1)?LEGACY_TEMP_SCHEMA_TABLE:LEGACY_SCHEMA_TABLE)
 
 /*
 ** A convenience macro that returns the number of elements in
@@ -14722,7 +14263,10 @@ typedef struct AutoincInfo AutoincInfo;
 typedef struct Bitvec Bitvec;
 typedef struct CollSeq CollSeq;
 typedef struct Column Column;
+typedef struct Cte Cte;
+typedef struct CteUse CteUse;
 typedef struct Db Db;
+typedef struct DbFixer DbFixer;
 typedef struct Schema Schema;
 typedef struct Expr Expr;
 typedef struct ExprList ExprList;
@@ -14740,14 +14284,17 @@ typedef struct LookasideSlot LookasideSlot;
 typedef struct Module Module;
 typedef struct NameContext NameContext;
 typedef struct Parse Parse;
+typedef struct ParseCleanup ParseCleanup;
 typedef struct PreUpdate PreUpdate;
 typedef struct PrintfArguments PrintfArguments;
 typedef struct RenameToken RenameToken;
+typedef struct Returning Returning;
 typedef struct RowSet RowSet;
 typedef struct Savepoint Savepoint;
 typedef struct Select Select;
 typedef struct SQLiteThread SQLiteThread;
 typedef struct SelectDest SelectDest;
+typedef struct SrcItem SrcItem;
 typedef struct SrcList SrcList;
 typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */
 typedef struct Table Table;
@@ -15180,7 +14727,7 @@ SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *);
 #define BTREE_BLOBKEY    2    /* Table has keys only - no data */
 
 SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*);
-SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*);
+SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, i64*);
 SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor*);
 SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree*, int, int);
 
@@ -15304,13 +14851,17 @@ SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor*, int, ...);
 #endif
 
 SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*);
-SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
+SQLITE_PRIVATE int sqlite3BtreeTableMoveto(
   BtCursor*,
-  UnpackedRecord *pUnKey,
   i64 intKey,
   int bias,
   int *pRes
 );
+SQLITE_PRIVATE int sqlite3BtreeIndexMoveto(
+  BtCursor*,
+  UnpackedRecord *pUnKey,
+  int *pRes
+);
 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*);
 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*);
 SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
@@ -15319,6 +14870,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
 #define BTREE_SAVEPOSITION 0x02  /* Leave cursor pointing at NEXT or PREV */
 #define BTREE_AUXDELETE    0x04  /* not the primary delete operation */
 #define BTREE_APPEND       0x08  /* Insert is likely an append */
+#define BTREE_PREFORMAT    0x80  /* Inserted data is a preformated cell */
 
 /* An instance of the BtreePayload object describes the content of a single
 ** entry in either an index or table btree.
@@ -15418,6 +14970,8 @@ SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
 SQLITE_PRIVATE   int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
 #endif
 
+SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor*, BtCursor*, i64);
+
 /*
 ** If we are not using shared cache, then there is no need to
 ** use mutexes to access the BtShared structures.  So make the
@@ -15658,35 +15212,35 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_If             18 /* jump                                       */
 #define OP_Not            19 /* same as TK_NOT, synopsis: r[P2]= !r[P1]    */
 #define OP_IfNot          20 /* jump                                       */
-#define OP_IfNullRow      21 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */
-#define OP_SeekLT         22 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekLE         23 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekGE         24 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekGT         25 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IfNotOpen      26 /* jump, synopsis: if( !csr[P1] ) goto P2     */
-#define OP_IfNoHope       27 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_NoConflict     28 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_NotFound       29 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_Found          30 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_SeekRowid      31 /* jump, synopsis: intkey=r[P3]               */
-#define OP_NotExists      32 /* jump, synopsis: intkey=r[P3]               */
-#define OP_Last           33 /* jump                                       */
-#define OP_IfSmaller      34 /* jump                                       */
-#define OP_SorterSort     35 /* jump                                       */
-#define OP_Sort           36 /* jump                                       */
-#define OP_Rewind         37 /* jump                                       */
-#define OP_IdxLE          38 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IdxGT          39 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IdxLT          40 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_IdxGE          41 /* jump, synopsis: key=r[P3@P4]               */
-#define OP_RowSetRead     42 /* jump, synopsis: r[P3]=rowset(P1)           */
+#define OP_IsNullOrType   21 /* jump, synopsis: if typeof(r[P1]) IN (P3,5) goto P2 */
+#define OP_IfNullRow      22 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */
+#define OP_SeekLT         23 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_SeekLE         24 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_SeekGE         25 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_SeekGT         26 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_IfNotOpen      27 /* jump, synopsis: if( !csr[P1] ) goto P2     */
+#define OP_IfNoHope       28 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_NoConflict     29 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_NotFound       30 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_Found          31 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_SeekRowid      32 /* jump, synopsis: intkey=r[P3]               */
+#define OP_NotExists      33 /* jump, synopsis: intkey=r[P3]               */
+#define OP_Last           34 /* jump                                       */
+#define OP_IfSmaller      35 /* jump                                       */
+#define OP_SorterSort     36 /* jump                                       */
+#define OP_Sort           37 /* jump                                       */
+#define OP_Rewind         38 /* jump                                       */
+#define OP_IdxLE          39 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_IdxGT          40 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_IdxLT          41 /* jump, synopsis: key=r[P3@P4]               */
+#define OP_IdxGE          42 /* jump, synopsis: key=r[P3@P4]               */
 #define OP_Or             43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */
 #define OP_And            44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */
-#define OP_RowSetTest     45 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */
-#define OP_Program        46 /* jump                                       */
-#define OP_FkIfZero       47 /* jump, synopsis: if fkctr[P1]==0 goto P2    */
-#define OP_IfPos          48 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
-#define OP_IfNotZero      49 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
+#define OP_RowSetRead     45 /* jump, synopsis: r[P3]=rowset(P1)           */
+#define OP_RowSetTest     46 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */
+#define OP_Program        47 /* jump                                       */
+#define OP_FkIfZero       48 /* jump, synopsis: if fkctr[P1]==0 goto P2    */
+#define OP_IfPos          49 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
 #define OP_IsNull         50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
 #define OP_NotNull        51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
 #define OP_Ne             52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */
@@ -15695,125 +15249,130 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_Le             55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */
 #define OP_Lt             56 /* jump, same as TK_LT, synopsis: IF r[P3]<r[P1] */
 #define OP_Ge             57 /* jump, same as TK_GE, synopsis: IF r[P3]>=r[P1] */
-#define OP_ElseNotEq      58 /* jump, same as TK_ESCAPE                    */
-#define OP_DecrJumpZero   59 /* jump, synopsis: if (--r[P1])==0 goto P2    */
-#define OP_IncrVacuum     60 /* jump                                       */
-#define OP_VNext          61 /* jump                                       */
-#define OP_Init           62 /* jump, synopsis: Start at P2                */
-#define OP_PureFunc       63 /* synopsis: r[P3]=func(r[P2@NP])             */
-#define OP_Function       64 /* synopsis: r[P3]=func(r[P2@NP])             */
-#define OP_Return         65
-#define OP_EndCoroutine   66
-#define OP_HaltIfNull     67 /* synopsis: if r[P3]=null halt               */
-#define OP_Halt           68
-#define OP_Integer        69 /* synopsis: r[P2]=P1                         */
-#define OP_Int64          70 /* synopsis: r[P2]=P4                         */
-#define OP_String         71 /* synopsis: r[P2]='P4' (len=P1)              */
-#define OP_Null           72 /* synopsis: r[P2..P3]=NULL                   */
-#define OP_SoftNull       73 /* synopsis: r[P1]=NULL                       */
-#define OP_Blob           74 /* synopsis: r[P2]=P4 (len=P1)                */
-#define OP_Variable       75 /* synopsis: r[P2]=parameter(P1,P4)           */
-#define OP_Move           76 /* synopsis: r[P2@P3]=r[P1@P3]                */
-#define OP_Copy           77 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
-#define OP_SCopy          78 /* synopsis: r[P2]=r[P1]                      */
-#define OP_IntCopy        79 /* synopsis: r[P2]=r[P1]                      */
-#define OP_ResultRow      80 /* synopsis: output=r[P1@P2]                  */
-#define OP_CollSeq        81
-#define OP_AddImm         82 /* synopsis: r[P1]=r[P1]+P2                   */
-#define OP_RealAffinity   83
-#define OP_Cast           84 /* synopsis: affinity(r[P1])                  */
-#define OP_Permutation    85
-#define OP_Compare        86 /* synopsis: r[P1@P3] <-> r[P2@P3]            */
-#define OP_IsTrue         87 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */
-#define OP_Offset         88 /* synopsis: r[P3] = sqlite_offset(P1)        */
-#define OP_Column         89 /* synopsis: r[P3]=PX                         */
-#define OP_Affinity       90 /* synopsis: affinity(r[P1@P2])               */
-#define OP_MakeRecord     91 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
-#define OP_Count          92 /* synopsis: r[P2]=count()                    */
-#define OP_ReadCookie     93
-#define OP_SetCookie      94
-#define OP_ReopenIdx      95 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenRead       96 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenWrite      97 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenDup        98
-#define OP_OpenAutoindex  99 /* synopsis: nColumn=P2                       */
-#define OP_OpenEphemeral 100 /* synopsis: nColumn=P2                       */
-#define OP_BitAnd        101 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
-#define OP_BitOr         102 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
-#define OP_ShiftLeft     103 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
-#define OP_ShiftRight    104 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
-#define OP_Add           105 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
-#define OP_Subtract      106 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
-#define OP_Multiply      107 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
-#define OP_Divide        108 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
-#define OP_Remainder     109 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
-#define OP_Concat        110 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
-#define OP_SorterOpen    111
-#define OP_BitNot        112 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */
-#define OP_SequenceTest  113 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
-#define OP_OpenPseudo    114 /* synopsis: P3 columns in r[P2]              */
-#define OP_String8       115 /* same as TK_STRING, synopsis: r[P2]='P4'    */
-#define OP_Close         116
-#define OP_ColumnsUsed   117
-#define OP_SeekScan      118 /* synopsis: Scan-ahead up to P1 rows         */
-#define OP_SeekHit       119 /* synopsis: set P2<=seekHit<=P3              */
-#define OP_Sequence      120 /* synopsis: r[P2]=cursor[P1].ctr++           */
-#define OP_NewRowid      121 /* synopsis: r[P2]=rowid                      */
-#define OP_Insert        122 /* synopsis: intkey=r[P3] data=r[P2]          */
-#define OP_Delete        123
-#define OP_ResetCount    124
-#define OP_SorterCompare 125 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
-#define OP_SorterData    126 /* synopsis: r[P2]=data                       */
-#define OP_RowData       127 /* synopsis: r[P2]=data                       */
-#define OP_Rowid         128 /* synopsis: r[P2]=rowid                      */
-#define OP_NullRow       129
-#define OP_SeekEnd       130
-#define OP_IdxInsert     131 /* synopsis: key=r[P2]                        */
-#define OP_SorterInsert  132 /* synopsis: key=r[P2]                        */
-#define OP_IdxDelete     133 /* synopsis: key=r[P2@P3]                     */
-#define OP_DeferredSeek  134 /* synopsis: Move P3 to P1.rowid if needed    */
-#define OP_IdxRowid      135 /* synopsis: r[P2]=rowid                      */
-#define OP_FinishSeek    136
-#define OP_Destroy       137
-#define OP_Clear         138
-#define OP_ResetSorter   139
-#define OP_CreateBtree   140 /* synopsis: r[P2]=root iDb=P1 flags=P3       */
-#define OP_SqlExec       141
-#define OP_ParseSchema   142
-#define OP_LoadAnalysis  143
-#define OP_DropTable     144
-#define OP_DropIndex     145
-#define OP_DropTrigger   146
-#define OP_IntegrityCk   147
-#define OP_RowSetAdd     148 /* synopsis: rowset(P1)=r[P2]                 */
-#define OP_Param         149
-#define OP_Real          150 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
-#define OP_FkCounter     151 /* synopsis: fkctr[P1]+=P2                    */
-#define OP_MemMax        152 /* synopsis: r[P1]=max(r[P1],r[P2])           */
-#define OP_OffsetLimit   153 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
-#define OP_AggInverse    154 /* synopsis: accum=r[P3] inverse(r[P2@P5])    */
-#define OP_AggStep       155 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggStep1      156 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggValue      157 /* synopsis: r[P3]=value N=P2                 */
-#define OP_AggFinal      158 /* synopsis: accum=r[P1] N=P2                 */
-#define OP_Expire        159
-#define OP_CursorLock    160
-#define OP_CursorUnlock  161
-#define OP_TableLock     162 /* synopsis: iDb=P1 root=P2 write=P3          */
-#define OP_VBegin        163
-#define OP_VCreate       164
-#define OP_VDestroy      165
-#define OP_VOpen         166
-#define OP_VColumn       167 /* synopsis: r[P3]=vcolumn(P2)                */
-#define OP_VRename       168
-#define OP_Pagecount     169
-#define OP_MaxPgcnt      170
-#define OP_Trace         171
-#define OP_CursorHint    172
-#define OP_ReleaseReg    173 /* synopsis: release r[P1@P2] mask P3         */
-#define OP_Noop          174
-#define OP_Explain       175
-#define OP_Abortable     176
+#define OP_ElseEq         58 /* jump, same as TK_ESCAPE                    */
+#define OP_IfNotZero      59 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */
+#define OP_DecrJumpZero   60 /* jump, synopsis: if (--r[P1])==0 goto P2    */
+#define OP_IncrVacuum     61 /* jump                                       */
+#define OP_VNext          62 /* jump                                       */
+#define OP_Init           63 /* jump, synopsis: Start at P2                */
+#define OP_PureFunc       64 /* synopsis: r[P3]=func(r[P2@NP])             */
+#define OP_Function       65 /* synopsis: r[P3]=func(r[P2@NP])             */
+#define OP_Return         66
+#define OP_EndCoroutine   67
+#define OP_HaltIfNull     68 /* synopsis: if r[P3]=null halt               */
+#define OP_Halt           69
+#define OP_Integer        70 /* synopsis: r[P2]=P1                         */
+#define OP_Int64          71 /* synopsis: r[P2]=P4                         */
+#define OP_String         72 /* synopsis: r[P2]='P4' (len=P1)              */
+#define OP_Null           73 /* synopsis: r[P2..P3]=NULL                   */
+#define OP_SoftNull       74 /* synopsis: r[P1]=NULL                       */
+#define OP_Blob           75 /* synopsis: r[P2]=P4 (len=P1)                */
+#define OP_Variable       76 /* synopsis: r[P2]=parameter(P1,P4)           */
+#define OP_Move           77 /* synopsis: r[P2@P3]=r[P1@P3]                */
+#define OP_Copy           78 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
+#define OP_SCopy          79 /* synopsis: r[P2]=r[P1]                      */
+#define OP_IntCopy        80 /* synopsis: r[P2]=r[P1]                      */
+#define OP_ChngCntRow     81 /* synopsis: output=r[P1]                     */
+#define OP_ResultRow      82 /* synopsis: output=r[P1@P2]                  */
+#define OP_CollSeq        83
+#define OP_AddImm         84 /* synopsis: r[P1]=r[P1]+P2                   */
+#define OP_RealAffinity   85
+#define OP_Cast           86 /* synopsis: affinity(r[P1])                  */
+#define OP_Permutation    87
+#define OP_Compare        88 /* synopsis: r[P1@P3] <-> r[P2@P3]            */
+#define OP_IsTrue         89 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */
+#define OP_ZeroOrNull     90 /* synopsis: r[P2] = 0 OR NULL                */
+#define OP_Offset         91 /* synopsis: r[P3] = sqlite_offset(P1)        */
+#define OP_Column         92 /* synopsis: r[P3]=PX                         */
+#define OP_TypeCheck      93 /* synopsis: typecheck(r[P1@P2])              */
+#define OP_Affinity       94 /* synopsis: affinity(r[P1@P2])               */
+#define OP_MakeRecord     95 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
+#define OP_Count          96 /* synopsis: r[P2]=count()                    */
+#define OP_ReadCookie     97
+#define OP_SetCookie      98
+#define OP_ReopenIdx      99 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenRead      100 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenWrite     101 /* synopsis: root=P2 iDb=P3                   */
+#define OP_BitAnd        102 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
+#define OP_BitOr         103 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
+#define OP_ShiftLeft     104 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
+#define OP_ShiftRight    105 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
+#define OP_Add           106 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
+#define OP_Subtract      107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
+#define OP_Multiply      108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
+#define OP_Divide        109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
+#define OP_Remainder     110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
+#define OP_Concat        111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
+#define OP_OpenDup       112
+#define OP_BitNot        113 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */
+#define OP_OpenAutoindex 114 /* synopsis: nColumn=P2                       */
+#define OP_OpenEphemeral 115 /* synopsis: nColumn=P2                       */
+#define OP_String8       116 /* same as TK_STRING, synopsis: r[P2]='P4'    */
+#define OP_SorterOpen    117
+#define OP_SequenceTest  118 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
+#define OP_OpenPseudo    119 /* synopsis: P3 columns in r[P2]              */
+#define OP_Close         120
+#define OP_ColumnsUsed   121
+#define OP_SeekScan      122 /* synopsis: Scan-ahead up to P1 rows         */
+#define OP_SeekHit       123 /* synopsis: set P2<=seekHit<=P3              */
+#define OP_Sequence      124 /* synopsis: r[P2]=cursor[P1].ctr++           */
+#define OP_NewRowid      125 /* synopsis: r[P2]=rowid                      */
+#define OP_Insert        126 /* synopsis: intkey=r[P3] data=r[P2]          */
+#define OP_RowCell       127
+#define OP_Delete        128
+#define OP_ResetCount    129
+#define OP_SorterCompare 130 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
+#define OP_SorterData    131 /* synopsis: r[P2]=data                       */
+#define OP_RowData       132 /* synopsis: r[P2]=data                       */
+#define OP_Rowid         133 /* synopsis: r[P2]=rowid                      */
+#define OP_NullRow       134
+#define OP_SeekEnd       135
+#define OP_IdxInsert     136 /* synopsis: key=r[P2]                        */
+#define OP_SorterInsert  137 /* synopsis: key=r[P2]                        */
+#define OP_IdxDelete     138 /* synopsis: key=r[P2@P3]                     */
+#define OP_DeferredSeek  139 /* synopsis: Move P3 to P1.rowid if needed    */
+#define OP_IdxRowid      140 /* synopsis: r[P2]=rowid                      */
+#define OP_FinishSeek    141
+#define OP_Destroy       142
+#define OP_Clear         143
+#define OP_ResetSorter   144
+#define OP_CreateBtree   145 /* synopsis: r[P2]=root iDb=P1 flags=P3       */
+#define OP_SqlExec       146
+#define OP_ParseSchema   147
+#define OP_LoadAnalysis  148
+#define OP_DropTable     149
+#define OP_DropIndex     150
+#define OP_DropTrigger   151
+#define OP_Real          152 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
+#define OP_IntegrityCk   153
+#define OP_RowSetAdd     154 /* synopsis: rowset(P1)=r[P2]                 */
+#define OP_Param         155
+#define OP_FkCounter     156 /* synopsis: fkctr[P1]+=P2                    */
+#define OP_MemMax        157 /* synopsis: r[P1]=max(r[P1],r[P2])           */
+#define OP_OffsetLimit   158 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
+#define OP_AggInverse    159 /* synopsis: accum=r[P3] inverse(r[P2@P5])    */
+#define OP_AggStep       160 /* synopsis: accum=r[P3] step(r[P2@P5])       */
+#define OP_AggStep1      161 /* synopsis: accum=r[P3] step(r[P2@P5])       */
+#define OP_AggValue      162 /* synopsis: r[P3]=value N=P2                 */
+#define OP_AggFinal      163 /* synopsis: accum=r[P1] N=P2                 */
+#define OP_Expire        164
+#define OP_CursorLock    165
+#define OP_CursorUnlock  166
+#define OP_TableLock     167 /* synopsis: iDb=P1 root=P2 write=P3          */
+#define OP_VBegin        168
+#define OP_VCreate       169
+#define OP_VDestroy      170
+#define OP_VOpen         171
+#define OP_VColumn       172 /* synopsis: r[P3]=vcolumn(P2)                */
+#define OP_VRename       173
+#define OP_Pagecount     174
+#define OP_MaxPgcnt      175
+#define OP_Trace         176
+#define OP_CursorHint    177
+#define OP_ReleaseReg    178 /* synopsis: release r[P1@P2] mask P3         */
+#define OP_Noop          179
+#define OP_Explain       180
+#define OP_Abortable     181
 
 /* Properties such as "out2" or "jump" that are specified in
 ** comments following the "case" for each opcode in the vdbe.c
@@ -15828,35 +15387,35 @@ typedef struct VdbeOpList VdbeOpList;
 #define OPFLG_INITIALIZER {\
 /*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\
 /*   8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\
-/*  16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x01, 0x09, 0x09,\
-/*  24 */ 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09,\
-/*  32 */ 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\
-/*  40 */ 0x01, 0x01, 0x23, 0x26, 0x26, 0x0b, 0x01, 0x01,\
-/*  48 */ 0x03, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
-/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00,\
-/*  64 */ 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10, 0x10,\
-/*  72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
-/*  80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\
-/*  88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
-/*  96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\
-/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
-/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\
-/* 120 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/* 128 */ 0x10, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10,\
-/* 136 */ 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\
-/* 144 */ 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x10, 0x00,\
-/* 152 */ 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
+/*  16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x03, 0x01, 0x09,\
+/*  24 */ 0x09, 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09,\
+/*  32 */ 0x09, 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\
+/*  40 */ 0x01, 0x01, 0x01, 0x26, 0x26, 0x23, 0x0b, 0x01,\
+/*  48 */ 0x01, 0x03, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\
+/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x01, 0x01, 0x01,\
+/*  64 */ 0x00, 0x00, 0x02, 0x02, 0x08, 0x00, 0x10, 0x10,\
+/*  72 */ 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10,\
+/*  80 */ 0x10, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00,\
+/*  88 */ 0x00, 0x12, 0x1e, 0x20, 0x00, 0x00, 0x00, 0x00,\
+/*  96 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26,\
+/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\
+/* 112 */ 0x00, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,\
+/* 120 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
+/* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,\
+/* 136 */ 0x04, 0x04, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00,\
+/* 144 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
+/* 152 */ 0x10, 0x00, 0x06, 0x10, 0x00, 0x04, 0x1a, 0x00,\
 /* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/* 168 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/* 176 */ 0x00,}
+/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10,\
+/* 176 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,}
 
-/* The sqlite3P2Values() routine is able to run faster if it knows
+/* The resolve3P2Values() routine is able to run faster if it knows
 ** the value of the largest JUMP opcode.  The smaller the maximum
 ** JUMP opcode the better, so the mkopcodeh.tcl script that
 ** generated this include file strives to group all JUMP opcodes
 ** together near the beginning of the list.
 */
-#define SQLITE_MX_JUMP_OPCODE  62  /* Maximum JUMP opcode */
+#define SQLITE_MX_JUMP_OPCODE  63  /* Maximum JUMP opcode */
 
 /************** End of opcodes.h *********************************************/
 /************** Continuing where we left off in vdbe.h ***********************/
@@ -15916,7 +15475,7 @@ SQLITE_PRIVATE   void sqlite3ExplainBreakpoint(const char*,const char*);
 #else
 # define sqlite3ExplainBreakpoint(A,B) /*no-op*/
 #endif
-SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
+SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*, int, char*, u16);
 SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8);
 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);
@@ -16383,6 +15942,12 @@ SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache);
 # define SET_FULLSYNC(x,y)
 #endif
 
+/* Maximum pathname length.  Note: FILENAME_MAX defined by stdio.h
+*/
+#ifndef SQLITE_MAX_PATHLEN
+# define SQLITE_MAX_PATHLEN FILENAME_MAX
+#endif
+
 /*
 ** The default size of a disk sector
 */
@@ -16888,6 +16453,11 @@ SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
 #endif /* SQLITE_OMIT_DEPRECATED */
 #define SQLITE_TRACE_NONLEGACY_MASK  0x0f     /* Normal flags */
 
+/*
+** Maximum number of sqlite3.aDb[] entries.  This is the number of attached
+** databases plus 2 for "main" and "temp".
+*/
+#define SQLITE_MAX_DB (SQLITE_MAX_ATTACHED+2)
 
 /*
 ** Each database connection is an instance of the following structure.
@@ -16908,7 +16478,7 @@ struct sqlite3 {
   int errCode;                  /* Most recent error code (SQLITE_*) */
   int errMask;                  /* & result codes with this before returning */
   int iSysErrno;                /* Errno value from last system error */
-  u16 dbOptFlags;               /* Flags to enable/disable optimizations */
+  u32 dbOptFlags;               /* Flags to enable/disable optimizations */
   u8 enc;                       /* Text encoding */
   u8 autoCommit;                /* The auto-commit flag. */
   u8 temp_store;                /* 1: file 2: memory 0: default */
@@ -16922,10 +16492,10 @@ struct sqlite3 {
   u8 mTrace;                    /* zero or more SQLITE_TRACE flags */
   u8 noSharedCache;             /* True if no shared-cache backends */
   u8 nSqlExec;                  /* Number of pending OP_SqlExec opcodes */
+  u8 eOpenState;                /* Current condition of the connection */
   int nextPagesize;             /* Pagesize after VACUUM if >0 */
-  u32 magic;                    /* Magic number for detect library misuse */
-  int nChange;                  /* Value returned by sqlite3_changes() */
-  int nTotalChange;             /* Value returned by sqlite3_total_changes() */
+  i64 nChange;                  /* Value returned by sqlite3_changes() */
+  i64 nTotalChange;             /* Value returned by sqlite3_total_changes() */
   int aLimit[SQLITE_N_LIMIT];   /* Limits */
   int nMaxSorterMmap;           /* Maximum size of regions mapped by sorter */
   struct sqlite3InitInfo {      /* Information used during initialization */
@@ -16935,7 +16505,7 @@ struct sqlite3 {
     unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */
     unsigned imposterTable : 1; /* Building an imposter table */
     unsigned reopenMemdb : 1;   /* ATTACH is really a reopen using MemDB */
-    char **azInit;              /* "type", "name", and "tbl_name" columns */
+    const char **azInit;        /* "type", "name", and "tbl_name" columns */
   } init;
   int nVdbeActive;              /* Number of VDBEs currently running */
   int nVdbeRead;                /* Number of active VDBEs that read or write */
@@ -16945,10 +16515,10 @@ struct sqlite3 {
   int nExtension;               /* Number of loaded extensions */
   void **aExtension;            /* Array of shared library handles */
   union {
-    void (*xLegacy)(void*,const char*);     /* Legacy trace function */
-    int (*xV2)(u32,void*,void*,void*);      /* V2 Trace function */
+    void (*xLegacy)(void*,const char*);   /* mTrace==SQLITE_TRACE_LEGACY */
+    int (*xV2)(u32,void*,void*,void*);    /* All other mTrace values */
   } trace;
-  void *pTraceArg;                          /* Argument to the trace function */
+  void *pTraceArg;                        /* Argument to the trace function */
 #ifndef SQLITE_OMIT_DEPRECATED
   void (*xProfile)(void*,const char*,u64);  /* Profiling function */
   void *pProfileArg;                        /* Argument to profile function */
@@ -16959,6 +16529,9 @@ struct sqlite3 {
   void (*xRollbackCallback)(void*); /* Invoked at every commit. */
   void *pUpdateArg;
   void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
+  void *pAutovacPagesArg;           /* Client argument to autovac_pages */
+  void (*xAutovacDestr)(void*);     /* Destructor for pAutovacPAgesArg */
+  unsigned int (*xAutovacPages)(void*,const char*,u32,u32,u32);
   Parse *pParse;                /* Current parse */
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
   void *pPreUpdateArg;          /* First argument to xPreUpdateCallback */
@@ -17088,6 +16661,7 @@ struct sqlite3 {
 #define SQLITE_CountRows      HI(0x00001) /* Count rows changed by INSERT, */
                                           /*   DELETE, or UPDATE and return */
                                           /*   the count using a callback. */
+#define SQLITE_CorruptRdOnly  HI(0x00002) /* Prohibit writes due to error */
 
 /* Flags used only if debugging */
 #ifdef SQLITE_DEBUG
@@ -17115,24 +16689,28 @@ struct sqlite3 {
 ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to
 ** selectively disable various optimizations.
 */
-#define SQLITE_QueryFlattener 0x0001   /* Query flattening */
-#define SQLITE_WindowFunc     0x0002   /* Use xInverse for window functions */
-#define SQLITE_GroupByOrder   0x0004   /* GROUPBY cover of ORDERBY */
-#define SQLITE_FactorOutConst 0x0008   /* Constant factoring */
-#define SQLITE_DistinctOpt    0x0010   /* DISTINCT using indexes */
-#define SQLITE_CoverIdxScan   0x0020   /* Covering index scans */
-#define SQLITE_OrderByIdxJoin 0x0040   /* ORDER BY of joins via index */
-#define SQLITE_Transitive     0x0080   /* Transitive constraints */
-#define SQLITE_OmitNoopJoin   0x0100   /* Omit unused tables in joins */
-#define SQLITE_CountOfView    0x0200   /* The count-of-view optimization */
-#define SQLITE_CursorHints    0x0400   /* Add OP_CursorHint opcodes */
-#define SQLITE_Stat4          0x0800   /* Use STAT4 data */
-   /* TH3 expects the Stat4   ^^^^^^ value to be 0x0800.  Don't change it */
-#define SQLITE_PushDown       0x1000   /* The push-down optimization */
-#define SQLITE_SimplifyJoin   0x2000   /* Convert LEFT JOIN to JOIN */
-#define SQLITE_SkipScan       0x4000   /* Skip-scans */
-#define SQLITE_PropagateConst 0x8000   /* The constant propagation opt */
-#define SQLITE_AllOpts        0xffff   /* All optimizations */
+#define SQLITE_QueryFlattener 0x00000001 /* Query flattening */
+#define SQLITE_WindowFunc     0x00000002 /* Use xInverse for window functions */
+#define SQLITE_GroupByOrder   0x00000004 /* GROUPBY cover of ORDERBY */
+#define SQLITE_FactorOutConst 0x00000008 /* Constant factoring */
+#define SQLITE_DistinctOpt    0x00000010 /* DISTINCT using indexes */
+#define SQLITE_CoverIdxScan   0x00000020 /* Covering index scans */
+#define SQLITE_OrderByIdxJoin 0x00000040 /* ORDER BY of joins via index */
+#define SQLITE_Transitive     0x00000080 /* Transitive constraints */
+#define SQLITE_OmitNoopJoin   0x00000100 /* Omit unused tables in joins */
+#define SQLITE_CountOfView    0x00000200 /* The count-of-view optimization */
+#define SQLITE_CursorHints    0x00000400 /* Add OP_CursorHint opcodes */
+#define SQLITE_Stat4          0x00000800 /* Use STAT4 data */
+   /* TH3 expects this value  ^^^^^^^^^^ to be 0x0000800. Don't change it */
+#define SQLITE_PushDown       0x00001000 /* The push-down optimization */
+#define SQLITE_SimplifyJoin   0x00002000 /* Convert LEFT JOIN to JOIN */
+#define SQLITE_SkipScan       0x00004000 /* Skip-scans */
+#define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */
+#define SQLITE_MinMaxOpt      0x00010000 /* The min/max optimization */
+#define SQLITE_SeekScan       0x00020000 /* The OP_SeekScan optimization */
+#define SQLITE_OmitOrderBy    0x00040000 /* Omit pointless ORDER BY */
+   /* TH3 expects this value  ^^^^^^^^^^ to be 0x40000. Coordinate any change */
+#define SQLITE_AllOpts        0xffffffff /* All optimizations */
 
 /*
 ** Macros for testing whether or not optimizations are enabled or disabled.
@@ -17146,17 +16724,16 @@ struct sqlite3 {
 */
 #define ConstFactorOk(P) ((P)->okConstFactor)
 
-/*
-** Possible values for the sqlite.magic field.
-** The numbers are obtained at random and have no special meaning, other
-** than being distinct from one another.
+/* Possible values for the sqlite3.eOpenState field.
+** The numbers are randomly selected such that a minimum of three bits must
+** change to convert any number to another or to zero
 */
-#define SQLITE_MAGIC_OPEN     0xa029a697  /* Database is open */
-#define SQLITE_MAGIC_CLOSED   0x9f3c2d33  /* Database is closed */
-#define SQLITE_MAGIC_SICK     0x4b771290  /* Error and awaiting close */
-#define SQLITE_MAGIC_BUSY     0xf03b7906  /* Database currently in use */
-#define SQLITE_MAGIC_ERROR    0xb5357930  /* An SQLITE_MISUSE error occurred */
-#define SQLITE_MAGIC_ZOMBIE   0x64cffc7f  /* Close with last statement close */
+#define SQLITE_STATE_OPEN     0x76  /* Database is open */
+#define SQLITE_STATE_CLOSED   0xce  /* Database is closed */
+#define SQLITE_STATE_SICK     0xba  /* Error and awaiting close */
+#define SQLITE_STATE_BUSY     0x6d  /* Database currently in use */
+#define SQLITE_STATE_ERROR    0xd5  /* An SQLITE_MISUSE error occurred */
+#define SQLITE_STATE_ZOMBIE   0xa7  /* Close with last statement close */
 
 /*
 ** Each SQL function is defined by an instance of the following
@@ -17181,7 +16758,7 @@ struct FuncDef {
   union {
     FuncDef *pHash;      /* Next with a different name but the same hash */
     FuncDestructor *pDestructor;   /* Reference counted destructor function */
-  } u;
+  } u; /* pHash if SQLITE_FUNC_BUILTIN, pDestructor otherwise */
 };
 
 /*
@@ -17211,12 +16788,13 @@ struct FuncDestructor {
 ** are assert() statements in the code to verify this.
 **
 ** Value constraints (enforced via assert()):
-**     SQLITE_FUNC_MINMAX    ==  NC_MinMaxAgg      == SF_MinMaxAgg
-**     SQLITE_FUNC_LENGTH    ==  OPFLAG_LENGTHARG
-**     SQLITE_FUNC_TYPEOF    ==  OPFLAG_TYPEOFARG
-**     SQLITE_FUNC_CONSTANT  ==  SQLITE_DETERMINISTIC from the API
-**     SQLITE_FUNC_DIRECT    ==  SQLITE_DIRECTONLY from the API
-**     SQLITE_FUNC_UNSAFE    ==  SQLITE_INNOCUOUS
+**     SQLITE_FUNC_MINMAX      ==  NC_MinMaxAgg      == SF_MinMaxAgg
+**     SQLITE_FUNC_ANYORDER    ==  NC_OrderAgg       == SF_OrderByReqd
+**     SQLITE_FUNC_LENGTH      ==  OPFLAG_LENGTHARG
+**     SQLITE_FUNC_TYPEOF      ==  OPFLAG_TYPEOFARG
+**     SQLITE_FUNC_CONSTANT    ==  SQLITE_DETERMINISTIC from the API
+**     SQLITE_FUNC_DIRECT      ==  SQLITE_DIRECTONLY from the API
+**     SQLITE_FUNC_UNSAFE      ==  SQLITE_INNOCUOUS
 **     SQLITE_FUNC_ENCMASK   depends on SQLITE_UTF* macros in the API
 */
 #define SQLITE_FUNC_ENCMASK  0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */
@@ -17241,6 +16819,8 @@ struct FuncDestructor {
 #define SQLITE_FUNC_SUBTYPE  0x00100000 /* Result likely to have sub-type */
 #define SQLITE_FUNC_UNSAFE   0x00200000 /* Function has side effects */
 #define SQLITE_FUNC_INLINE   0x00400000 /* Functions implemented in-line */
+#define SQLITE_FUNC_BUILTIN  0x00800000 /* This is a built-in function */
+#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
 
 /* Identifier numbers for each in-line function */
 #define INLINEFUNC_coalesce             0
@@ -17288,6 +16868,9 @@ struct FuncDestructor {
 **     a single query.  The iArg is ignored.  The user-data is always set
 **     to a NULL pointer.  The bNC parameter is not used.
 **
+**   MFUNCTION(zName, nArg, xPtr, xFunc)
+**     For math-library functions.  xPtr is an arbitrary pointer.
+**
 **   PURE_DATE(zName, nArg, iArg, bNC, xFunc)
 **     Used for "pure" date/time functions, this macro is like DFUNCTION
 **     except that it does set the SQLITE_FUNC_CONSTANT flags.  iArg is
@@ -17315,41 +16898,51 @@ struct FuncDestructor {
 **     parameter.
 */
 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
-  {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+   SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
-  {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
-  {nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
+#define MFUNCTION(zName, nArg, xPtr, xFunc) \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \
+   xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \
-  {nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+   SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
    SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
 #define TEST_FUNC(zName, nArg, iArg, mFlags) \
-  {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+         SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
          SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
    SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
-  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
    0, 0, xFunc, 0, 0, 0, #zName, {0} }
 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
-  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+         SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
    (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
-  {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
+  {nArg, SQLITE_FUNC_BUILTIN|\
+   SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
-  {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+   SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    pArg, 0, xFunc, 0, 0, 0, #zName, }
 #define LIKEFUNC(zName, nArg, arg, flags) \
-  {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
    (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
 #define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
-  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
    SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
 #define INTERNAL_FUNCTION(zName, nArg, xFunc) \
-  {nArg, SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
+  {nArg, SQLITE_FUNC_BUILTIN|\
+   SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
    0, 0, xFunc, 0, 0, 0, #zName, {0} }
 
 
@@ -17405,19 +16998,48 @@ struct Module {
 **                            or equal to the table column index.  It is
 **                            equal if and only if there are no VIRTUAL
 **                            columns to the left.
+**
+** Notes on zCnName:
+** The zCnName field stores the name of the column, the datatype of the
+** column, and the collating sequence for the column, in that order, all in
+** a single allocation.  Each string is 0x00 terminated.  The datatype
+** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the
+** collating sequence name is only included if the COLFLAG_HASCOLL bit is
+** set.
 */
 struct Column {
-  char *zName;     /* Name of this column, \000, then the type */
-  Expr *pDflt;     /* Default value or GENERATED ALWAYS AS value */
-  char *zColl;     /* Collating sequence.  If NULL, use the default */
-  u8 notNull;      /* An OE_ code for handling a NOT NULL constraint */
-  char affinity;   /* One of the SQLITE_AFF_... values */
-  u8 szEst;        /* Estimated size of value in this column. sizeof(INT)==1 */
-  u8 hName;        /* Column name hash for faster lookup */
-  u16 colFlags;    /* Boolean properties.  See COLFLAG_ defines below */
+  char *zCnName;        /* Name of this column */
+  unsigned notNull :4;  /* An OE_ code for handling a NOT NULL constraint */
+  unsigned eCType :4;   /* One of the standard types */
+  char affinity;        /* One of the SQLITE_AFF_... values */
+  u8 szEst;             /* Est size of value in this column. sizeof(INT)==1 */
+  u8 hName;             /* Column name hash for faster lookup */
+  u16 iDflt;            /* 1-based index of DEFAULT.  0 means "none" */
+  u16 colFlags;         /* Boolean properties.  See COLFLAG_ defines below */
 };
 
-/* Allowed values for Column.colFlags:
+/* Allowed values for Column.eCType.
+**
+** Values must match entries in the global constant arrays
+** sqlite3StdTypeLen[] and sqlite3StdType[].  Each value is one more
+** than the offset into these arrays for the corresponding name.
+** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
+*/
+#define COLTYPE_CUSTOM      0   /* Type appended to zName */
+#define COLTYPE_ANY         1
+#define COLTYPE_BLOB        2
+#define COLTYPE_INT         3
+#define COLTYPE_INTEGER     4
+#define COLTYPE_REAL        5
+#define COLTYPE_TEXT        6
+#define SQLITE_N_STDTYPE    6  /* Number of standard types */
+
+/* Allowed values for Column.colFlags.
+**
+** Constraints:
+**         TF_HasVirtual == COLFLAG_VIRTUAL
+**         TF_HasStored  == COLFLAG_STORED
+**         TF_HasHidden  == COLFLAG_HIDDEN
 */
 #define COLFLAG_PRIMKEY   0x0001   /* Column is part of the primary key */
 #define COLFLAG_HIDDEN    0x0002   /* A hidden column in a virtual table */
@@ -17428,6 +17050,7 @@ struct Column {
 #define COLFLAG_STORED    0x0040   /* GENERATED ALWAYS AS ... STORED */
 #define COLFLAG_NOTAVAIL  0x0080   /* STORED column not yet calculated */
 #define COLFLAG_BUSY      0x0100   /* Blocks recursion on GENERATED columns */
+#define COLFLAG_HASCOLL   0x0200   /* Has collating sequence name in zCnName */
 #define COLFLAG_GENERATED 0x0060   /* Combo: _STORED, _VIRTUAL */
 #define COLFLAG_NOINSERT  0x0062   /* Combo: _HIDDEN, _STORED, _VIRTUAL */
 
@@ -17493,9 +17116,7 @@ struct CollSeq {
 ** operator is NULL.  It is added to certain comparison operators to
 ** prove that the operands are always NOT NULL.
 */
-#define SQLITE_KEEPNULL     0x08  /* Used by vector == or <> */
 #define SQLITE_JUMPIFNULL   0x10  /* jumps if either operand is NULL */
-#define SQLITE_STOREP2      0x20  /* Store result in reg[P2] rather than jump */
 #define SQLITE_NULLEQ       0x80  /* NULL=NULL */
 #define SQLITE_NOTNULL      0x90  /* Assert that operands are never NULL */
 
@@ -17559,15 +17180,13 @@ struct VTable {
 #define SQLITE_VTABRISK_High         2
 
 /*
-** The schema for each SQL table and view is represented in memory
-** by an instance of the following structure.
+** The schema for each SQL table, virtual table, and view is represented
+** in memory by an instance of the following structure.
 */
 struct Table {
   char *zName;         /* Name of the table or view */
   Column *aCol;        /* Information about each column */
   Index *pIndex;       /* List of SQL indexes on this table. */
-  Select *pSelect;     /* NULL for tables.  Points to definition if a view. */
-  FKey *pFKey;         /* Linked list of all foreign keys in this table */
   char *zColAff;       /* String defining the affinity of each column */
   ExprList *pCheck;    /* All CHECK constraints */
                        /*   ... also used as column name list in a VIEW */
@@ -17583,17 +17202,25 @@ struct Table {
   LogEst costMult;     /* Cost multiplier for using this table */
 #endif
   u8 keyConf;          /* What to do in case of uniqueness conflict on iPKey */
-#ifndef SQLITE_OMIT_ALTERTABLE
-  int addColOffset;    /* Offset in CREATE TABLE stmt to add a new column */
-#endif
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  int nModuleArg;      /* Number of arguments to the module */
-  char **azModuleArg;  /* 0: module 1: schema 2: vtab name 3...: args */
-  VTable *pVTable;     /* List of VTable objects. */
-#endif
-  Trigger *pTrigger;   /* List of triggers stored in pSchema */
+  u8 eTabType;         /* 0: normal, 1: virtual, 2: view */
+  union {
+    struct {             /* Used by ordinary tables: */
+      int addColOffset;    /* Offset in CREATE TABLE stmt to add a new column */
+      FKey *pFKey;         /* Linked list of all foreign keys in this table */
+      ExprList *pDfltList; /* DEFAULT clauses on various columns.
+                           ** Or the AS clause for generated columns. */
+    } tab;
+    struct {             /* Used by views: */
+      Select *pSelect;     /* View definition */
+    } view;
+    struct {             /* Used by virtual tables only: */
+      int nArg;            /* Number of arguments to the module */
+      char **azArg;        /* 0: module 1: schema 2: vtab name 3...: args */
+      VTable *p;           /* List of VTable objects. */
+    } vtab;
+  } u;
+  Trigger *pTrigger;   /* List of triggers on this object */
   Schema *pSchema;     /* Schema that contains this table */
-  Table *pNextZombie;  /* Next on the Parse.pZombieTab list */
 };
 
 /*
@@ -17607,25 +17234,39 @@ struct Table {
 **
 ** Constraints:
 **
-**         TF_HasVirtual == COLFLAG_Virtual
-**         TF_HasStored  == COLFLAG_Stored
-*/
-#define TF_Readonly        0x0001    /* Read-only system table */
-#define TF_Ephemeral       0x0002    /* An ephemeral table */
-#define TF_HasPrimaryKey   0x0004    /* Table has a primary key */
-#define TF_Autoincrement   0x0008    /* Integer primary key is autoincrement */
-#define TF_HasStat1        0x0010    /* nRowLogEst set from sqlite_stat1 */
-#define TF_HasVirtual      0x0020    /* Has one or more VIRTUAL columns */
-#define TF_HasStored       0x0040    /* Has one or more STORED columns */
-#define TF_HasGenerated    0x0060    /* Combo: HasVirtual + HasStored */
-#define TF_WithoutRowid    0x0080    /* No rowid.  PRIMARY KEY is the key */
-#define TF_StatsUsed       0x0100    /* Query planner decisions affected by
+**         TF_HasVirtual == COLFLAG_VIRTUAL
+**         TF_HasStored  == COLFLAG_STORED
+**         TF_HasHidden  == COLFLAG_HIDDEN
+*/
+#define TF_Readonly       0x00000001 /* Read-only system table */
+#define TF_HasHidden      0x00000002 /* Has one or more hidden columns */
+#define TF_HasPrimaryKey  0x00000004 /* Table has a primary key */
+#define TF_Autoincrement  0x00000008 /* Integer primary key is autoincrement */
+#define TF_HasStat1       0x00000010 /* nRowLogEst set from sqlite_stat1 */
+#define TF_HasVirtual     0x00000020 /* Has one or more VIRTUAL columns */
+#define TF_HasStored      0x00000040 /* Has one or more STORED columns */
+#define TF_HasGenerated   0x00000060 /* Combo: HasVirtual + HasStored */
+#define TF_WithoutRowid   0x00000080 /* No rowid.  PRIMARY KEY is the key */
+#define TF_StatsUsed      0x00000100 /* Query planner decisions affected by
                                      ** Index.aiRowLogEst[] values */
-#define TF_NoVisibleRowid  0x0200    /* No user-visible "rowid" column */
-#define TF_OOOHidden       0x0400    /* Out-of-Order hidden columns */
-#define TF_HasNotNull      0x0800    /* Contains NOT NULL constraints */
-#define TF_Shadow          0x1000    /* True for a shadow table */
-#define TF_HasStat4        0x2000    /* STAT4 info available for this table */
+#define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */
+#define TF_OOOHidden      0x00000400 /* Out-of-Order hidden columns */
+#define TF_HasNotNull     0x00000800 /* Contains NOT NULL constraints */
+#define TF_Shadow         0x00001000 /* True for a shadow table */
+#define TF_HasStat4       0x00002000 /* STAT4 info available for this table */
+#define TF_Ephemeral      0x00004000 /* An ephemeral table */
+#define TF_Eponymous      0x00008000 /* An eponymous virtual table */
+#define TF_Strict         0x00010000 /* STRICT mode */
+
+/*
+** Allowed values for Table.eTabType
+*/
+#define TABTYP_NORM      0     /* Ordinary table */
+#define TABTYP_VTAB      1     /* Virtual table */
+#define TABTYP_VIEW      2     /* A view */
+
+#define IsView(X)           ((X)->eTabType==TABTYP_VIEW)
+#define IsOrdinaryTable(X)  ((X)->eTabType==TABTYP_NORM)
 
 /*
 ** Test to see whether or not a table is a virtual table.  This is
@@ -17633,9 +17274,9 @@ struct Table {
 ** table support is omitted from the build.
 */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-#  define IsVirtual(X)      ((X)->nModuleArg)
+#  define IsVirtual(X)      ((X)->eTabType==TABTYP_VTAB)
 #  define ExprIsVtab(X)  \
-              ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)
+    ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->eTabType==TABTYP_VTAB)
 #else
 #  define IsVirtual(X)      0
 #  define ExprIsVtab(X)     0
@@ -17722,16 +17363,22 @@ struct FKey {
 ** is returned.  REPLACE means that preexisting database rows that caused
 ** a UNIQUE constraint violation are removed so that the new insert or
 ** update can proceed.  Processing continues and no error is reported.
+** UPDATE applies to insert operations only and means that the insert
+** is omitted and the DO UPDATE clause of an upsert is run instead.
 **
-** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
+** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys.
 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
 ** same as ROLLBACK for DEFERRED keys.  SETNULL means that the foreign
-** key is set to NULL.  CASCADE means that a DELETE or UPDATE of the
+** key is set to NULL.  SETDFLT means that the foreign key is set
+** to its default value.  CASCADE means that a DELETE or UPDATE of the
 ** referenced table row is propagated into the row that holds the
 ** foreign key.
 **
+** The OE_Default value is a place holder that means to use whatever
+** conflict resolution algorthm is required from context.
+**
 ** The following symbolic values are used to record which type
-** of action to take.
+** of conflict resolution action to take.
 */
 #define OE_None     0   /* There is no constraint to check */
 #define OE_Rollback 1   /* Fail the operation and rollback the transaction */
@@ -17985,10 +17632,10 @@ struct AggInfo {
     FuncDef *pFunc;          /* The aggregate function implementation */
     int iMem;                /* Memory location that acts as accumulator */
     int iDistinct;           /* Ephemeral table used to enforce DISTINCT */
+    int iDistAddr;           /* Address of OP_OpenEphemeral */
   } *aFunc;
   int nFunc;              /* Number of entries in aFunc[] */
   u32 selId;              /* Select to which this AggInfo belongs */
-  AggInfo *pNext;         /* Next in list of them all */
 };
 
 /*
@@ -18018,10 +17665,10 @@ typedef int ynVar;
 ** tree.
 **
 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
-** or TK_STRING), then Expr.token contains the text of the SQL literal. If
-** the expression is a variable (TK_VARIABLE), then Expr.token contains the
+** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If
+** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the
 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
-** then Expr.token contains the name of the function.
+** then Expr.u.zToken contains the name of the function.
 **
 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
 ** binary operator. Either or both may be NULL.
@@ -18061,7 +17708,7 @@ typedef int ynVar;
 ** help reduce memory requirements, sometimes an Expr object will be
 ** truncated.  And to reduce the number of memory allocations, sometimes
 ** two or more Expr objects will be stored in a single memory allocation,
-** together with Expr.zToken strings.
+** together with Expr.u.zToken strings.
 **
 ** If the EP_Reduced and EP_TokenOnly flags are set when
 ** an Expr object is truncated.  When EP_Reduced is set, then all
@@ -18117,7 +17764,7 @@ struct Expr {
                          ** TK_VARIABLE: variable number (always >= 1).
                          ** TK_SELECT_COLUMN: column of the result vector */
   i16 iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
-  i16 iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
+  int iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
   AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
   union {
     Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL
@@ -18130,8 +17777,7 @@ struct Expr {
   } y;
 };
 
-/*
-** The following are the meanings of bits in the Expr.flags field.
+/* The following are the meanings of bits in the Expr.flags field.
 ** Value restrictions:
 **
 **          EP_Agg == NC_HasAgg == SF_HasAgg
@@ -18159,7 +17805,7 @@ struct Expr {
 #define EP_ConstFunc  0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
 #define EP_CanBeNull  0x100000 /* Can be null despite NOT NULL constraint */
 #define EP_Subquery   0x200000 /* Tree contains a TK_SELECT operator */
-#define EP_Alias      0x400000 /* Is an alias for a result set column */
+                 /*   0x400000 // Available */
 #define EP_Leaf       0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
 #define EP_WinFunc   0x1000000 /* TK_FUNCTION with Expr.y.pWin set */
 #define EP_Subrtn    0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */
@@ -18170,14 +17816,12 @@ struct Expr {
 #define EP_FromDDL  0x40000000 /* Originates from sqlite_schema */
                /*   0x80000000 // Available */
 
-/*
-** The EP_Propagate mask is a set of properties that automatically propagate
+/* The EP_Propagate mask is a set of properties that automatically propagate
 ** upwards into parent nodes.
 */
 #define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc)
 
-/*
-** These macros can be used to test, set, or clear bits in the
+/* Macros can be used to test, set, or clear bits in the
 ** Expr.flags field.
 */
 #define ExprHasProperty(E,P)     (((E)->flags&(P))!=0)
@@ -18187,6 +17831,16 @@ struct Expr {
 #define ExprAlwaysTrue(E)   (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue)
 #define ExprAlwaysFalse(E)  (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse)
 
+/* Macros used to ensure that the correct members of unions are accessed
+** in Expr.
+*/
+#define ExprUseUToken(E)    (((E)->flags&EP_IntValue)==0)
+#define ExprUseUValue(E)    (((E)->flags&EP_IntValue)!=0)
+#define ExprUseXList(E)     (((E)->flags&EP_xIsSelect)==0)
+#define ExprUseXSelect(E)   (((E)->flags&EP_xIsSelect)!=0)
+#define ExprUseYTab(E)      (((E)->flags&(EP_WinFunc|EP_Subrtn))==0)
+#define ExprUseYWin(E)      (((E)->flags&EP_WinFunc)!=0)
+#define ExprUseYSub(E)      (((E)->flags&EP_Subrtn)!=0)
 
 /* Flags for use with Expr.vvaFlags
 */
@@ -18258,6 +17912,7 @@ struct Expr {
 */
 struct ExprList {
   int nExpr;             /* Number of expressions on the list */
+  int nAlloc;            /* Number of a[] slots allocated */
   struct ExprList_item { /* For each expression in the list */
     Expr *pExpr;            /* The parse tree for this expression */
     char *zEName;           /* Token associated with this expression */
@@ -18268,11 +17923,12 @@ struct ExprList {
     unsigned bSorterRef :1; /* Defer evaluation until after sorting */
     unsigned bNulls: 1;     /* True if explicit "NULLS FIRST/LAST" */
     union {
-      struct {
+      struct {             /* Used by any ExprList other than Parse.pConsExpr */
         u16 iOrderByCol;      /* For ORDER BY, column number in result set */
         u16 iAlias;           /* Index into Parse.aAlias[] for zName */
       } x;
-      int iConstExprReg;      /* Register in which Expr value is cached */
+      int iConstExprReg;   /* Register in which Expr value is cached. Used only
+                           ** by Parse.pConstExpr */
     } u;
   } a[1];                  /* One slot for each expression in the list */
 };
@@ -18307,6 +17963,53 @@ struct IdList {
   int nId;         /* Number of identifiers on the list */
 };
 
+/*
+** The SrcItem object represents a single term in the FROM clause of a query.
+** The SrcList object is mostly an array of SrcItems.
+**
+** Union member validity:
+**
+**    u1.zIndexedBy          fg.isIndexedBy && !fg.isTabFunc
+**    u1.pFuncArg            fg.isTabFunc   && !fg.isIndexedBy
+**    u2.pIBIndex            fg.isIndexedBy && !fg.isCte
+**    u2.pCteUse             fg.isCte       && !fg.isIndexedBy
+*/
+struct SrcItem {
+  Schema *pSchema;  /* Schema to which this item is fixed */
+  char *zDatabase;  /* Name of database holding this table */
+  char *zName;      /* Name of the table */
+  char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
+  Table *pTab;      /* An SQL table corresponding to zName */
+  Select *pSelect;  /* A SELECT statement used in place of a table name */
+  int addrFillSub;  /* Address of subroutine to manifest a subquery */
+  int regReturn;    /* Register holding return address of addrFillSub */
+  int regResult;    /* Registers holding results of a co-routine */
+  struct {
+    u8 jointype;      /* Type of join between this table and the previous */
+    unsigned notIndexed :1;    /* True if there is a NOT INDEXED clause */
+    unsigned isIndexedBy :1;   /* True if there is an INDEXED BY clause */
+    unsigned isTabFunc :1;     /* True if table-valued-function syntax */
+    unsigned isCorrelated :1;  /* True if sub-query is correlated */
+    unsigned viaCoroutine :1;  /* Implemented as a co-routine */
+    unsigned isRecursive :1;   /* True for recursive reference in WITH */
+    unsigned fromDDL :1;       /* Comes from sqlite_schema */
+    unsigned isCte :1;         /* This is a CTE */
+    unsigned notCte :1;        /* This item may not match a CTE */
+  } fg;
+  int iCursor;      /* The VDBE cursor number used to access this table */
+  Expr *pOn;        /* The ON clause of a join */
+  IdList *pUsing;   /* The USING clause of a join */
+  Bitmask colUsed;  /* Bit N (1<<N) set if column N of pTab is used */
+  union {
+    char *zIndexedBy;    /* Identifier from "INDEXED BY <zIndex>" clause */
+    ExprList *pFuncArg;  /* Arguments to table-valued-function */
+  } u1;
+  union {
+    Index *pIBIndex;  /* Index structure corresponding to u1.zIndexedBy */
+    CteUse *pCteUse;  /* CTE Usage info info fg.isCte is true */
+  } u2;
+};
+
 /*
 ** The following structure describes the FROM clause of a SELECT statement.
 ** Each table or subquery in the FROM clause is a separate element of
@@ -18329,36 +18032,7 @@ struct IdList {
 struct SrcList {
   int nSrc;        /* Number of tables or subqueries in the FROM clause */
   u32 nAlloc;      /* Number of entries allocated in a[] below */
-  struct SrcList_item {
-    Schema *pSchema;  /* Schema to which this item is fixed */
-    char *zDatabase;  /* Name of database holding this table */
-    char *zName;      /* Name of the table */
-    char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
-    Table *pTab;      /* An SQL table corresponding to zName */
-    Select *pSelect;  /* A SELECT statement used in place of a table name */
-    int addrFillSub;  /* Address of subroutine to manifest a subquery */
-    int regReturn;    /* Register holding return address of addrFillSub */
-    int regResult;    /* Registers holding results of a co-routine */
-    struct {
-      u8 jointype;      /* Type of join between this table and the previous */
-      unsigned notIndexed :1;    /* True if there is a NOT INDEXED clause */
-      unsigned isIndexedBy :1;   /* True if there is an INDEXED BY clause */
-      unsigned isTabFunc :1;     /* True if table-valued-function syntax */
-      unsigned isCorrelated :1;  /* True if sub-query is correlated */
-      unsigned viaCoroutine :1;  /* Implemented as a co-routine */
-      unsigned isRecursive :1;   /* True for recursive reference in WITH */
-      unsigned fromDDL :1;       /* Comes from sqlite_schema */
-    } fg;
-    int iCursor;      /* The VDBE cursor number used to access this table */
-    Expr *pOn;        /* The ON clause of a join */
-    IdList *pUsing;   /* The USING clause of a join */
-    Bitmask colUsed;  /* Bit N (1<<N) set if column N of pTab is used */
-    union {
-      char *zIndexedBy;    /* Identifier from "INDEXED BY <zIndex>" clause */
-      ExprList *pFuncArg;  /* Arguments to table-valued-function */
-    } u1;
-    Index *pIBIndex;  /* Index structure corresponding to u1.zIndexedBy */
-  } a[1];             /* One entry for each identifier on the list */
+  SrcItem a[1];    /* One entry for each identifier on the list */
 };
 
 /*
@@ -18392,7 +18066,7 @@ 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() */
-                        /*     0x0400    not currently used */
+#define WHERE_AGG_DISTINCT     0x0400 /* Query is "SELECT agg(DISTINCT ...)" */
 #define WHERE_ORDERBY_LIMIT    0x0800 /* ORDERBY+LIMIT on the inner loop */
                         /*     0x1000    not currently used */
                         /*     0x2000    not currently used */
@@ -18434,10 +18108,11 @@ struct NameContext {
     ExprList *pEList;    /* Optional list of result-set columns */
     AggInfo *pAggInfo;   /* Information about aggregates at this level */
     Upsert *pUpsert;     /* ON CONFLICT clause information from an upsert */
+    int iBaseReg;        /* For TK_REGISTER when parsing RETURNING */
   } uNC;
   NameContext *pNext;  /* Next outer name context.  NULL for outermost */
   int nRef;            /* Number of names resolved by this context */
-  int nErr;            /* Number of errors encountered while resolving names */
+  int nNcErr;          /* Number of errors encountered while resolving names */
   int ncFlags;         /* Zero or more NC_* flags defined below */
   Select *pWinSelect;  /* SELECT statement for any window functions */
 };
@@ -18446,29 +18121,33 @@ struct NameContext {
 ** Allowed values for the NameContext, ncFlags field.
 **
 ** Value constraints (all checked via assert()):
-**    NC_HasAgg    == SF_HasAgg    == EP_Agg
-**    NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX
+**    NC_HasAgg    == SF_HasAgg       == EP_Agg
+**    NC_MinMaxAgg == SF_MinMaxAgg    == SQLITE_FUNC_MINMAX
+**    NC_OrderAgg  == SF_OrderByReqd  == SQLITE_FUNC_ANYORDER
 **    NC_HasWin    == EP_Win
 **
 */
-#define NC_AllowAgg  0x00001  /* Aggregate functions are allowed here */
-#define NC_PartIdx   0x00002  /* True if resolving a partial index WHERE */
-#define NC_IsCheck   0x00004  /* True if resolving a CHECK constraint */
-#define NC_GenCol    0x00008  /* True for a GENERATED ALWAYS AS clause */
-#define NC_HasAgg    0x00010  /* One or more aggregate functions seen */
-#define NC_IdxExpr   0x00020  /* True if resolving columns of CREATE INDEX */
-#define NC_SelfRef   0x0002e  /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */
-#define NC_VarSelect 0x00040  /* A correlated subquery has been seen */
-#define NC_UEList    0x00080  /* True if uNC.pEList is used */
-#define NC_UAggInfo  0x00100  /* True if uNC.pAggInfo is used */
-#define NC_UUpsert   0x00200  /* True if uNC.pUpsert is used */
-#define NC_MinMaxAgg 0x01000  /* min/max aggregates seen.  See note above */
-#define NC_Complex   0x02000  /* True if a function or subquery seen */
-#define NC_AllowWin  0x04000  /* Window functions are allowed here */
-#define NC_HasWin    0x08000  /* One or more window functions seen */
-#define NC_IsDDL     0x10000  /* Resolving names in a CREATE statement */
-#define NC_InAggFunc 0x20000  /* True if analyzing arguments to an agg func */
-#define NC_FromDDL   0x40000  /* SQL text comes from sqlite_schema */
+#define NC_AllowAgg  0x000001 /* Aggregate functions are allowed here */
+#define NC_PartIdx   0x000002 /* True if resolving a partial index WHERE */
+#define NC_IsCheck   0x000004 /* True if resolving a CHECK constraint */
+#define NC_GenCol    0x000008 /* True for a GENERATED ALWAYS AS clause */
+#define NC_HasAgg    0x000010 /* One or more aggregate functions seen */
+#define NC_IdxExpr   0x000020 /* True if resolving columns of CREATE INDEX */
+#define NC_SelfRef   0x00002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */
+#define NC_VarSelect 0x000040 /* A correlated subquery has been seen */
+#define NC_UEList    0x000080 /* True if uNC.pEList is used */
+#define NC_UAggInfo  0x000100 /* True if uNC.pAggInfo is used */
+#define NC_UUpsert   0x000200 /* True if uNC.pUpsert is used */
+#define NC_UBaseReg  0x000400 /* True if uNC.iBaseReg is used */
+#define NC_MinMaxAgg 0x001000 /* min/max aggregates seen.  See note above */
+#define NC_Complex   0x002000 /* True if a function or subquery seen */
+#define NC_AllowWin  0x004000 /* Window functions are allowed here */
+#define NC_HasWin    0x008000 /* One or more window functions seen */
+#define NC_IsDDL     0x010000 /* Resolving names in a CREATE statement */
+#define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */
+#define NC_FromDDL   0x040000 /* SQL text comes from sqlite_schema */
+#define NC_NoSelect  0x080000 /* Do not descend into sub-selects */
+#define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
 
 /*
 ** An instance of the following object describes a single ON CONFLICT
@@ -18485,15 +18164,21 @@ struct NameContext {
 ** WHERE clause is omitted.
 */
 struct Upsert {
-  ExprList *pUpsertTarget;  /* Optional description of conflicting index */
+  ExprList *pUpsertTarget;  /* Optional description of conflict target */
   Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */
   ExprList *pUpsertSet;     /* The SET clause from an ON CONFLICT UPDATE */
   Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */
-  /* The fields above comprise the parse tree for the upsert clause.
-  ** The fields below are used to transfer information from the INSERT
-  ** processing down into the UPDATE processing while generating code.
-  ** Upsert owns the memory allocated above, but not the memory below. */
-  Index *pUpsertIdx;        /* Constraint that pUpsertTarget identifies */
+  Upsert *pNextUpsert;      /* Next ON CONFLICT clause in the list */
+  u8 isDoUpdate;            /* True for DO UPDATE.  False for DO NOTHING */
+  /* Above this point is the parse tree for the ON CONFLICT clauses.
+  ** The next group of fields stores intermediate data. */
+  void *pToFree;            /* Free memory when deleting the Upsert object */
+  /* All fields above are owned by the Upsert object and must be freed
+  ** when the Upsert is destroyed.  The fields below are used to transfer
+  ** information from the INSERT processing down into the UPDATE processing
+  ** while generating code.  The fields below are owned by the INSERT
+  ** statement and will be freed by INSERT processing. */
+  Index *pUpsertIdx;        /* UNIQUE constraint specified by pUpsertTarget */
   SrcList *pUpsertSrc;      /* Table to be updated */
   int regData;              /* First register holding array of VALUES */
   int iDataCur;             /* Index of the data cursor */
@@ -18545,9 +18230,10 @@ struct Select {
 ** "Select Flag".
 **
 ** Value constraints (all checked via assert())
-**     SF_HasAgg     == NC_HasAgg
-**     SF_MinMaxAgg  == NC_MinMaxAgg     == SQLITE_FUNC_MINMAX
-**     SF_FixedLimit == WHERE_USE_LIMIT
+**     SF_HasAgg      == NC_HasAgg
+**     SF_MinMaxAgg   == NC_MinMaxAgg     == SQLITE_FUNC_MINMAX
+**     SF_OrderByReqd == NC_OrderAgg      == SQLITE_FUNC_ANYORDER
+**     SF_FixedLimit  == WHERE_USE_LIMIT
 */
 #define SF_Distinct      0x0000001 /* Output should be DISTINCT */
 #define SF_All           0x0000002 /* Includes the ALL keyword */
@@ -18572,7 +18258,11 @@ struct Select {
 #define SF_WinRewrite    0x0100000 /* Window function rewrite accomplished */
 #define SF_View          0x0200000 /* SELECT statement is a view */
 #define SF_NoopOrderBy   0x0400000 /* ORDER BY is ignored for this query */
-#define SF_UpdateFrom    0x0800000 /* Statement is an UPDATE...FROM */
+#define SF_UFSrcCheck    0x0800000 /* Check pSrc as required by UPDATE...FROM */
+#define SF_PushDown      0x1000000 /* SELECT has be modified by push-down opt */
+#define SF_MultiPart     0x2000000 /* Has multiple incompatible PARTITIONs */
+#define SF_CopyCte       0x4000000 /* SELECT statement is a copy of a CTE */
+#define SF_OrderByReqd   0x8000000 /* The ORDER BY clause may not be omitted */
 
 /*
 ** The results of a SELECT can be distributed in several ways, as defined
@@ -18743,6 +18433,17 @@ struct TriggerPrg {
 # define DbMaskNonZero(M)   (M)!=0
 #endif
 
+/*
+** An instance of the ParseCleanup object specifies an operation that
+** should be performed after parsing to deallocation resources obtained
+** during the parse and which are no longer needed.
+*/
+struct ParseCleanup {
+  ParseCleanup *pNext;               /* Next cleanup task */
+  void *pPtr;                        /* Pointer to object to deallocate */
+  void (*xCleanup)(sqlite3*,void*);  /* Deallocation routine */
+};
+
 /*
 ** An SQL parser context.  A copy of this structure is passed through
 ** the parser and down into all the parser action routine in order to
@@ -18774,6 +18475,9 @@ struct Parse {
   u8 okConstFactor;    /* OK to factor out constants */
   u8 disableLookaside; /* Number of times lookaside has been disabled */
   u8 disableVtab;      /* Disable all virtual tables for this parse */
+#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
+  u8 earlyCleanup;     /* OOM inside sqlite3ParserAddCleanup() */
+#endif
   int nRangeReg;       /* Size of the temporary register block */
   int iRangeReg;       /* First register in temporary register block */
   int nErr;            /* Number of errors seen */
@@ -18800,13 +18504,15 @@ 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 */
+  union {
+    int addrCrTab;         /* Address of OP_CreateBtree on CREATE TABLE */
+    Returning *pReturning; /* The RETURNING clause */
+  } u1;
   u32 nQueryLoop;      /* Est number of iterations of a query (10*log2(N)) */
   u32 oldmask;         /* Mask of old.* columns referenced */
   u32 newmask;         /* Mask of new.* columns referenced */
   u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */
+  u8 bReturning;       /* Coding a RETURNING trigger */
   u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */
   u8 disableTriggers;  /* True to disable triggers */
 
@@ -18852,15 +18558,16 @@ struct Parse {
   Token sArg;               /* Complete text of a module argument */
   Table **apVtabLock;       /* Pointer to virtual tables needing locking */
 #endif
-  Table *pZombieTab;        /* List of Table objects to delete after code gen */
   TriggerPrg *pTriggerPrg;  /* Linked list of coded triggers */
   With *pWith;              /* Current WITH clause, or NULL */
-  With *pWithToFree;        /* Free this WITH object at the end of the parse */
+  ParseCleanup *pCleanup;   /* List of cleanup operations to run after parse */
 #ifndef SQLITE_OMIT_ALTERTABLE
   RenameToken *pRename;     /* Tokens subject to renaming by ALTER TABLE */
 #endif
 };
 
+/* Allowed values for Parse.eParseMode
+*/
 #define PARSE_MODE_NORMAL        0
 #define PARSE_MODE_DECLARE_VTAB  1
 #define PARSE_MODE_RENAME        2
@@ -18935,6 +18642,7 @@ struct AuthContext {
 #define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete/Insert: save cursor pos */
 #define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */
 #define OPFLAG_NOCHNG_MAGIC  0x6d    /* OP_MakeRecord: serialtype 10 is ok */
+#define OPFLAG_PREFORMAT     0x80    /* OP_Insert uses preformatted cell */
 
 /*
  * Each trigger present in the database schema is stored as an instance of
@@ -18956,6 +18664,7 @@ struct Trigger {
   char *table;            /* The table or view to which the trigger applies */
   u8 op;                  /* One of TK_DELETE, TK_UPDATE, TK_INSERT         */
   u8 tr_tm;               /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
+  u8 bReturning;          /* This trigger implements a RETURNING clause */
   Expr *pWhen;            /* The WHEN clause of the expression (may be NULL) */
   IdList *pColumns;       /* If this is an UPDATE OF <column-list> trigger,
                              the <column-list> is stored here */
@@ -19014,14 +18723,15 @@ struct Trigger {
  *
  */
 struct TriggerStep {
-  u8 op;               /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
+  u8 op;               /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT,
+                       ** or TK_RETURNING */
   u8 orconf;           /* OE_Rollback etc. */
   Trigger *pTrig;      /* The trigger that this step is a part of */
   Select *pSelect;     /* SELECT statement or RHS of INSERT INTO SELECT ... */
   char *zTarget;       /* Target table for DELETE, UPDATE, INSERT */
   SrcList *pFrom;      /* FROM clause for UPDATE statement (if any) */
   Expr *pWhere;        /* The WHERE clause for DELETE or UPDATE steps */
-  ExprList *pExprList; /* SET clause for UPDATE */
+  ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */
   IdList *pIdList;     /* Column names for INSERT */
   Upsert *pUpsert;     /* Upsert clauses on an INSERT */
   char *zSpan;         /* Original SQL text of this command */
@@ -19030,18 +18740,16 @@ struct TriggerStep {
 };
 
 /*
-** The following structure contains information used by the sqliteFix...
-** routines as they walk the parse tree to make database references
-** explicit.
+** Information about a RETURNING clause
 */
-typedef struct DbFixer DbFixer;
-struct DbFixer {
-  Parse *pParse;      /* The parsing context.  Error messages written here */
-  Schema *pSchema;    /* Fix items to this schema */
-  u8 bTemp;           /* True for TEMP schema entries */
-  const char *zDb;    /* Make sure all objects are contained in this database */
-  const char *zType;  /* Type of the container - used for error messages */
-  const Token *pName; /* Name of the container - used for error messages */
+struct Returning {
+  Parse *pParse;        /* The parse that includes the RETURNING clause */
+  ExprList *pReturnEL;  /* List of expressions to return */
+  Trigger retTrig;      /* The transient trigger that implements RETURNING */
+  TriggerStep retTStep; /* The trigger step */
+  int iRetCur;          /* Transient table holding RETURNING results */
+  int nRetCol;          /* Number of in pReturnEL after expansion */
+  int iRetReg;          /* Register array for holding a row of RETURNING */
 };
 
 /*
@@ -19081,7 +18789,26 @@ typedef struct {
 /*
 ** Allowed values for mInitFlags
 */
-#define INITFLAG_AlterTable   0x0001  /* This is a reparse after ALTER TABLE */
+#define INITFLAG_AlterMask     0x0003  /* Types of ALTER */
+#define INITFLAG_AlterRename   0x0001  /* Reparse after a RENAME */
+#define INITFLAG_AlterDrop     0x0002  /* Reparse after a DROP COLUMN */
+#define INITFLAG_AlterAdd      0x0003  /* Reparse after an ADD COLUMN */
+
+/* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
+** on debug-builds of the CLI using ".testctrl tune ID VALUE".  Tuning
+** parameters are for temporary use during development, to help find
+** optimial values for parameters in the query planner.  The should not
+** be used on trunk check-ins.  They are a temporary mechanism available
+** for transient development builds only.
+**
+** Tuning parameters are numbered starting with 1.
+*/
+#define SQLITE_NTUNE  6             /* Should be zero for all trunk check-ins */
+#ifdef SQLITE_DEBUG
+# define Tuning(X)  (sqlite3Config.aTune[(X)-1])
+#else
+# define Tuning(X)  0
+#endif
 
 /*
 ** Structure containing global configuration data for the SQLite library.
@@ -19137,7 +18864,7 @@ struct Sqlite3Config {
   void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */
   void *pVdbeBranchArg;                                     /* 1st argument */
 #endif
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
   sqlite3_int64 mxMemdbSize;        /* Default max memdb size */
 #endif
 #ifndef SQLITE_UNTESTABLE
@@ -19147,6 +18874,10 @@ struct Sqlite3Config {
   int iOnceResetThreshold;          /* When to reset OP_Once counters */
   u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
   unsigned int iPrngSeed;           /* Alternative fixed seed for the PRNG */
+  /* vvvv--- must be last ---vvv */
+#ifdef SQLITE_DEBUG
+  sqlite3_int64 aTune[SQLITE_NTUNE]; /* Tuning parameters */
+#endif
 };
 
 /*
@@ -19182,8 +18913,8 @@ struct Walker {
     int n;                                    /* A counter */
     int iCur;                                 /* A cursor number */
     SrcList *pSrcList;                        /* FROM clause */
-    struct SrcCount *pSrcCount;               /* Counting column references */
     struct CCurHint *pCCurHint;               /* Used by codeCursorHint() */
+    struct RefSrcList *pRefSrcList;           /* sqlite3ReferencesSrcList() */
     int *aiCol;                               /* array of column indexes */
     struct IdxCover *pIdxCover;               /* Check for index coverage */
     struct IdxExprTrans *pIdxTrans;           /* Convert idxed expr to column */
@@ -19193,10 +18924,26 @@ struct Walker {
     struct WhereConst *pConst;                /* WHERE clause constants */
     struct RenameCtx *pRename;                /* RENAME COLUMN context */
     struct Table *pTab;                       /* Table of generated column */
-    struct SrcList_item *pSrcItem;            /* A single FROM clause item */
+    SrcItem *pSrcItem;                        /* A single FROM clause item */
+    DbFixer *pFix;
   } u;
 };
 
+/*
+** The following structure contains information used by the sqliteFix...
+** routines as they walk the parse tree to make database references
+** explicit.
+*/
+struct DbFixer {
+  Parse *pParse;      /* The parsing context.  Error messages written here */
+  Walker w;           /* Walker object */
+  Schema *pSchema;    /* Fix items to this schema */
+  u8 bTemp;           /* True for TEMP schema entries */
+  const char *zDb;    /* Make sure all objects are contained in this database */
+  const char *zType;  /* Type of the container - used for error messages */
+  const Token *pName; /* Name of the container - used for error messages */
+};
+
 /* Forward declarations */
 SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*);
 SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*);
@@ -19208,11 +18955,18 @@ SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker*, Select*);
 SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker*, Select*);
 SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker*,Select*);
 SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker*,Select*);
+SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker*,Select*);
 
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*);
 #endif
 
+#ifndef SQLITE_OMIT_CTE
+SQLITE_PRIVATE void sqlite3SelectPopWith(Walker*, Select*);
+#else
+# define sqlite3SelectPopWith 0
+#endif
+
 /*
 ** Return code from the parse-tree walking primitives and their
 ** callbacks.
@@ -19222,20 +18976,56 @@ SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*);
 #define WRC_Abort       2   /* Abandon the tree walk */
 
 /*
-** An instance of this structure represents a set of one or more CTEs
-** (common table expressions) created by a single WITH clause.
+** A single common table expression
+*/
+struct Cte {
+  char *zName;            /* Name of this CTE */
+  ExprList *pCols;        /* List of explicit column names, or NULL */
+  Select *pSelect;        /* The definition of this CTE */
+  const char *zCteErr;    /* Error message for circular references */
+  CteUse *pUse;           /* Usage information for this CTE */
+  u8 eM10d;               /* The MATERIALIZED flag */
+};
+
+/*
+** Allowed values for the materialized flag (eM10d):
+*/
+#define M10d_Yes       0  /* AS MATERIALIZED */
+#define M10d_Any       1  /* Not specified.  Query planner's choice */
+#define M10d_No        2  /* AS NOT MATERIALIZED */
+
+/*
+** An instance of the With object represents a WITH clause containing
+** one or more CTEs (common table expressions).
 */
 struct With {
-  int nCte;                       /* Number of CTEs in the WITH clause */
-  With *pOuter;                   /* Containing WITH clause, or NULL */
-  struct Cte {                    /* For each CTE in the WITH clause.... */
-    char *zName;                    /* Name of this CTE */
-    ExprList *pCols;                /* List of explicit column names, or NULL */
-    Select *pSelect;                /* The definition of this CTE */
-    const char *zCteErr;            /* Error message for circular references */
-  } a[1];
+  int nCte;               /* Number of CTEs in the WITH clause */
+  int bView;              /* Belongs to the outermost Select of a view */
+  With *pOuter;           /* Containing WITH clause, or NULL */
+  Cte a[1];               /* For each CTE in the WITH clause.... */
 };
 
+/*
+** The Cte object is not guaranteed to persist for the entire duration
+** of code generation.  (The query flattener or other parser tree
+** edits might delete it.)  The following object records information
+** about each Common Table Expression that must be preserved for the
+** duration of the parse.
+**
+** The CteUse objects are freed using sqlite3ParserAddCleanup() rather
+** than sqlite3SelectDelete(), which is what enables them to persist
+** until the end of code generation.
+*/
+struct CteUse {
+  int nUse;              /* Number of users of this CTE */
+  int addrM9e;           /* Start of subroutine to compute materialization */
+  int regRtn;            /* Return address register for addrM9e subroutine */
+  int iCur;              /* Ephemeral table holding the materialization */
+  LogEst nRowEst;        /* Estimated number of rows in the table */
+  u8 eM10d;              /* The MATERIALIZED flag */
+};
+
+
 #ifdef SQLITE_DEBUG
 /*
 ** An instance of the TreeView object is used for printing the content of
@@ -19309,11 +19099,10 @@ SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p);
 SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
 SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*);
 SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin);
-SQLITE_PRIVATE int sqlite3WindowCompare(Parse*, Window*, Window*, int);
+SQLITE_PRIVATE int sqlite3WindowCompare(const Parse*, const Window*, const Window*, int);
 SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse*, Select*);
 SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int);
 SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*);
-SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, struct SrcList_item*);
 SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*);
 SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p);
 SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p);
@@ -19442,8 +19231,8 @@ SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64);
 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, u64);
 SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*);
 SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3*, void*);
-SQLITE_PRIVATE int sqlite3MallocSize(void*);
-SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*);
+SQLITE_PRIVATE int sqlite3MallocSize(const void*);
+SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, const void*);
 SQLITE_PRIVATE void *sqlite3PageMalloc(int);
 SQLITE_PRIVATE void sqlite3PageFree(void*);
 SQLITE_PRIVATE void sqlite3MemSetDefault(void);
@@ -19559,6 +19348,7 @@ SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
 SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3Dequote(char*);
 SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*);
+SQLITE_PRIVATE void sqlite3DequoteToken(Token*);
 SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*);
 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
 SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **);
@@ -19578,15 +19368,17 @@ SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*);
 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*);
 SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*);
 SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*);
-SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*, int);
-SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,Expr*,FuncDef*);
+SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, const Token*, int);
+SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*);
 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32);
 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
+SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*);
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*);
+SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse*, int, ExprList*);
 SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList*,int,int);
-SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
+SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,const Token*,int);
 SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*);
 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*);
@@ -19602,7 +19394,12 @@ SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*);
 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*);
 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
+SQLITE_PRIVATE void sqlite3ColumnSetExpr(Parse*,Table*,Column*,Expr*);
+SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table*,Column*);
+SQLITE_PRIVATE void sqlite3ColumnSetColl(sqlite3*,Column*,const char*zColl);
+SQLITE_PRIVATE const char *sqlite3ColumnColl(Column*);
 SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*);
+SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect);
 SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);
 SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*,char);
 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*,char);
@@ -19622,14 +19419,15 @@ SQLITE_PRIVATE   void sqlite3ColumnPropertiesFromName(Table*, Column*);
 #else
 # define sqlite3ColumnPropertiesFromName(T,C) /* no-op */
 #endif
-SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*,Token*);
+SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token,Token);
 SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);
 SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
 SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*, const char*, const char*);
 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*);
 SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
 SQLITE_PRIVATE void sqlite3AddGenerated(Parse*,Expr*,Token*);
-SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);
+SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u32,Select*);
+SQLITE_PRIVATE void sqlite3AddReturning(Parse*,ExprList*);
 SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*,
                     sqlite3_vfs**,char**,char **);
 #define sqlite3CodecQueryParameters(A,B,C) 0
@@ -19695,7 +19493,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, T
                                       Token*, Select*, Expr*, IdList*);
 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
 SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*);
-SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *);
+SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, SrcItem *);
 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);
 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
@@ -19723,6 +19521,7 @@ SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*);
+SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe*,WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*);
@@ -19737,7 +19536,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int
 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
 SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int);
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
-SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Column*, int);
+SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Table*, Column*, int);
 #endif
 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int);
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
@@ -19756,23 +19555,24 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*);
 #define LOCATE_VIEW    0x01
 #define LOCATE_NOERR   0x02
 SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*);
-SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,struct SrcList_item *);
+SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char*);
+SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *);
 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
 SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*);
 SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*);
-SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*);
-SQLITE_PRIVATE int sqlite3ExprCompare(Parse*,Expr*, Expr*, int);
-SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*, Expr*, int);
-SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*, int);
-SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse*,Expr*, Expr*, int);
+SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, const Token*);
+SQLITE_PRIVATE int sqlite3ExprCompare(const Parse*,const Expr*,const Expr*, int);
+SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*,Expr*,int);
+SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList*,const ExprList*, int);
+SQLITE_PRIVATE int sqlite3ExprImpliesExpr(const Parse*,const Expr*,const Expr*, int);
 SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int);
 SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*);
 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
 SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx);
-SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr*, SrcList*);
+SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse*, Expr*, SrcList*);
 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
 #ifndef SQLITE_UNTESTABLE
 SQLITE_PRIVATE void sqlite3PrngSaveState(void);
@@ -19797,7 +19597,7 @@ SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int);
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
 SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*);
 #endif
-SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*);
+SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*);
 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
 SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
 SQLITE_PRIVATE int sqlite3IsRowid(const char*);
@@ -19822,11 +19622,11 @@ SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8);
 SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*);
 SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*);
-SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int);
-SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int);
-SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int);
-SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*);
-SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int);
+SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,const Expr*,int);
+SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,const ExprList*,int);
+SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,const SrcList*,int);
+SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,const IdList*);
+SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,const Select*,int);
 SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*);
 SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int);
 SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8);
@@ -19836,6 +19636,7 @@ SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*);
 SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*);
 SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*);
 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int);
+SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p);
 
 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
 SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int);
@@ -19884,6 +19685,7 @@ SQLITE_PRIVATE   SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*);
 #endif
 
 SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*);
+SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol);
 SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr*,int);
 SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
@@ -19906,7 +19708,6 @@ SQLITE_PRIVATE void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Tok
 SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*);
 SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*);
 SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*);
-SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*);
 SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
 SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64);
 SQLITE_PRIVATE void sqlite3Int64ToText(i64,char*);
@@ -19963,12 +19764,13 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3*, Index*);
 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int);
 SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);
-SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table*,int);
+SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table*,int);
 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);
 SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8);
 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*);
 SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);
 SQLITE_PRIVATE void sqlite3Error(sqlite3*,int);
+SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3*);
 SQLITE_PRIVATE void sqlite3SystemError(sqlite3*,int);
 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
 SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
@@ -19978,7 +19780,7 @@ SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
 SQLITE_PRIVATE const char *sqlite3ErrName(int);
 #endif
 
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
 SQLITE_PRIVATE int sqlite3MemdbInit(void);
 #endif
 
@@ -19991,14 +19793,14 @@ SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8);
 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
 SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse*,const Expr*,const Expr*);
-SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int);
-SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*);
+SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(const Parse *pParse, Expr*, const Token*, int);
+SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(const Parse*,Expr*,const char*);
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*);
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr*);
 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *);
 SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*);
 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*);
-SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int);
+SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, i64);
 SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64);
 SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64);
 SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64);
@@ -20023,16 +19825,22 @@ SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *);
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
 #endif
-SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
+SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, const Expr *, u8, u8, sqlite3_value **);
 SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
 #ifndef SQLITE_AMALGAMATION
 SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
 SQLITE_PRIVATE const char sqlite3StrBINARY[];
+SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[];
+SQLITE_PRIVATE const char sqlite3StdTypeAffinity[];
+SQLITE_PRIVATE const char sqlite3StdTypeMap[];
+SQLITE_PRIVATE const char *sqlite3StdType[];
 SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
+SQLITE_PRIVATE const unsigned char *sqlite3aLTb;
+SQLITE_PRIVATE const unsigned char *sqlite3aEQb;
+SQLITE_PRIVATE const unsigned char *sqlite3aGTb;
 SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
 SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
 SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
-SQLITE_API extern u32 sqlite3_unsupported_selecttrace;
 #ifndef SQLITE_OMIT_WSD
 SQLITE_PRIVATE int sqlite3PendingByte;
 #endif
@@ -20051,6 +19859,7 @@ SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int);
 SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int);
 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*);
 SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
+SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, SrcItem*);
 SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
 SQLITE_PRIVATE int sqlite3MatchEName(
   const struct ExprList_item*,
@@ -20068,8 +19877,9 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const
 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
-SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse*, void*, Token*);
-SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, void *pTo, void *pFrom);
+SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse*, SrcList*, const Token*);
+SQLITE_PRIVATE const void *sqlite3RenameTokenMap(Parse*, const void*, const Token*);
+SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom);
 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*);
 SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*);
 SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
@@ -20091,6 +19901,7 @@ SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int);
+SQLITE_PRIVATE const char *sqlite3SelectOpName(int);
 SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse*, ExprList*);
 
 #ifdef SQLITE_DEBUG
@@ -20112,6 +19923,8 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);
 
 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int);
 SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*);
+SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum*, u8);
+SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*);
 SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int);
 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
 
@@ -20164,7 +19977,7 @@ SQLITE_PRIVATE   int sqlite3Utf8To8(unsigned char*);
 #endif
 
 #ifdef SQLITE_OMIT_VIRTUALTABLE
-#  define sqlite3VtabClear(Y)
+#  define sqlite3VtabClear(D,T)
 #  define sqlite3VtabSync(X,Y) SQLITE_OK
 #  define sqlite3VtabRollback(X)
 #  define sqlite3VtabCommit(X)
@@ -20201,9 +20014,11 @@ SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 SQLITE_PRIVATE   int sqlite3ShadowTableName(sqlite3 *db, const char *zName);
 SQLITE_PRIVATE   int sqlite3IsShadowTableOf(sqlite3*,Table*,const char*);
+SQLITE_PRIVATE   void sqlite3MarkAllShadowTablesOf(sqlite3*, Table*);
 #else
 # define sqlite3ShadowTableName(A,B) 0
 # define sqlite3IsShadowTableOf(A,B,C) 0
+# define sqlite3MarkAllShadowTablesOf(A,B)
 #endif
 SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse*,Module*);
 SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3*,Module*);
@@ -20221,6 +20036,7 @@ SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
 SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
 SQLITE_PRIVATE void sqlite3ParserReset(Parse*);
+SQLITE_PRIVATE void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*);
 #ifdef SQLITE_ENABLE_NORMALIZE
 SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*);
 #endif
@@ -20235,23 +20051,32 @@ SQLITE_PRIVATE   int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
 SQLITE_PRIVATE   int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
 #endif
 #ifndef SQLITE_OMIT_CTE
-SQLITE_PRIVATE   With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*);
+SQLITE_PRIVATE   Cte *sqlite3CteNew(Parse*,Token*,ExprList*,Select*,u8);
+SQLITE_PRIVATE   void sqlite3CteDelete(sqlite3*,Cte*);
+SQLITE_PRIVATE   With *sqlite3WithAdd(Parse*,With*,Cte*);
 SQLITE_PRIVATE   void sqlite3WithDelete(sqlite3*,With*);
-SQLITE_PRIVATE   void sqlite3WithPush(Parse*, With*, u8);
+SQLITE_PRIVATE   With *sqlite3WithPush(Parse*, With*, u8);
 #else
-#define sqlite3WithPush(x,y,z)
-#define sqlite3WithDelete(x,y)
+# define sqlite3CteNew(P,T,E,S)   ((void*)0)
+# define sqlite3CteDelete(D,C)
+# define sqlite3CteWithAdd(P,W,C) ((void*)0)
+# define sqlite3WithDelete(x,y)
+# define sqlite3WithPush(x,y,z) ((void*)0)
 #endif
 #ifndef SQLITE_OMIT_UPSERT
-SQLITE_PRIVATE   Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*);
+SQLITE_PRIVATE   Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*);
 SQLITE_PRIVATE   void sqlite3UpsertDelete(sqlite3*,Upsert*);
 SQLITE_PRIVATE   Upsert *sqlite3UpsertDup(sqlite3*,Upsert*);
 SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*);
 SQLITE_PRIVATE   void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int);
+SQLITE_PRIVATE   Upsert *sqlite3UpsertOfIndex(Upsert*,Index*);
+SQLITE_PRIVATE   int sqlite3UpsertNextIsIPK(Upsert*);
 #else
-#define sqlite3UpsertNew(v,w,x,y,z) ((Upsert*)0)
+#define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0)
 #define sqlite3UpsertDelete(x,y)
-#define sqlite3UpsertDup(x,y)       ((Upsert*)0)
+#define sqlite3UpsertDup(x,y)         ((Upsert*)0)
+#define sqlite3UpsertOfIndex(x,y)     ((Upsert*)0)
+#define sqlite3UpsertNextIsIPK(x)     0
 #endif
 
 
@@ -20333,7 +20158,7 @@ SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);
 
 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
 #if SQLITE_MAX_EXPR_DEPTH>0
-SQLITE_PRIVATE   int sqlite3SelectExprHeight(Select *);
+SQLITE_PRIVATE   int sqlite3SelectExprHeight(const Select *);
 SQLITE_PRIVATE   int sqlite3ExprCheckHeight(Parse*, int);
 #else
   #define sqlite3SelectExprHeight(x) 0
@@ -20404,8 +20229,8 @@ SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
 */
 #ifdef SQLITE_MEMDEBUG
 SQLITE_PRIVATE   void sqlite3MemdebugSetType(void*,u8);
-SQLITE_PRIVATE   int sqlite3MemdebugHasType(void*,u8);
-SQLITE_PRIVATE   int sqlite3MemdebugNoType(void*,u8);
+SQLITE_PRIVATE   int sqlite3MemdebugHasType(const void*,u8);
+SQLITE_PRIVATE   int sqlite3MemdebugNoType(const void*,u8);
 #else
 # define sqlite3MemdebugSetType(X,Y)  /* no-op */
 # define sqlite3MemdebugHasType(X,Y)  1
@@ -20430,10 +20255,10 @@ SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3*);
 SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3*);
 #endif
 
-SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr);
-SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr);
+SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr);
+SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr);
 SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr*, int);
-SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int);
+SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int,int);
 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse*, Expr*);
 
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
@@ -20443,6 +20268,990 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt);
 #endif /* SQLITEINT_H */
 
 /************** End of sqliteInt.h *******************************************/
+/************** Begin file os_common.h ***************************************/
+/*
+** 2004 May 22
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains macros and a little bit of code that is common to
+** all of the platform-specific files (os_*.c) and is #included into those
+** files.
+**
+** This file should be #included by the os_*.c files only.  It is not a
+** general purpose header file.
+*/
+#ifndef _OS_COMMON_H_
+#define _OS_COMMON_H_
+
+/*
+** At least two bugs have slipped in because we changed the MEMORY_DEBUG
+** macro to SQLITE_DEBUG and some older makefiles have not yet made the
+** switch.  The following code should catch this problem at compile-time.
+*/
+#ifdef MEMORY_DEBUG
+# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."
+#endif
+
+/*
+** Macros for performance tracing.  Normally turned off.  Only works
+** on i486 hardware.
+*/
+#ifdef SQLITE_PERFORMANCE_TRACE
+
+/*
+** hwtime.h contains inline assembler code for implementing
+** high-performance timing routines.
+*/
+/************** Include hwtime.h in the middle of os_common.h ****************/
+/************** Begin file hwtime.h ******************************************/
+/*
+** 2008 May 27
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains inline asm code for retrieving "high-performance"
+** counters for x86 and x86_64 class CPUs.
+*/
+#ifndef SQLITE_HWTIME_H
+#define SQLITE_HWTIME_H
+
+/*
+** The following routine only works on pentium-class (or newer) processors.
+** It uses the RDTSC opcode to read the cycle count value out of the
+** processor and returns that value.  This can be used for high-res
+** profiling.
+*/
+#if !defined(__STRICT_ANSI__) && \
+    (defined(__GNUC__) || defined(_MSC_VER)) && \
+    (defined(i386) || defined(__i386__) || defined(_M_IX86))
+
+  #if defined(__GNUC__)
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+     unsigned int lo, hi;
+     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+     return (sqlite_uint64)hi << 32 | lo;
+  }
+
+  #elif defined(_MSC_VER)
+
+  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
+     __asm {
+        rdtsc
+        ret       ; return value at EDX:EAX
+     }
+  }
+
+  #endif
+
+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+      unsigned long val;
+      __asm__ __volatile__ ("rdtsc" : "=A" (val));
+      return val;
+  }
+
+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
+
+  __inline__ sqlite_uint64 sqlite3Hwtime(void){
+      unsigned long long retval;
+      unsigned long junk;
+      __asm__ __volatile__ ("\n\
+          1:      mftbu   %1\n\
+                  mftb    %L0\n\
+                  mftbu   %0\n\
+                  cmpw    %0,%1\n\
+                  bne     1b"
+                  : "=r" (retval), "=r" (junk));
+      return retval;
+  }
+
+#else
+
+  /*
+  ** asm() is needed for hardware timing support.  Without asm(),
+  ** disable the sqlite3Hwtime() routine.
+  **
+  ** sqlite3Hwtime() is only used for some obscure debugging
+  ** and analysis configurations, not in any deliverable, so this
+  ** should not be a great loss.
+  */
+SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
+
+#endif
+
+#endif /* !defined(SQLITE_HWTIME_H) */
+
+/************** End of hwtime.h **********************************************/
+/************** Continuing where we left off in os_common.h ******************/
+
+static sqlite_uint64 g_start;
+static sqlite_uint64 g_elapsed;
+#define TIMER_START       g_start=sqlite3Hwtime()
+#define TIMER_END         g_elapsed=sqlite3Hwtime()-g_start
+#define TIMER_ELAPSED     g_elapsed
+#else
+#define TIMER_START
+#define TIMER_END
+#define TIMER_ELAPSED     ((sqlite_uint64)0)
+#endif
+
+/*
+** If we compile with the SQLITE_TEST macro set, then the following block
+** of code will give us the ability to simulate a disk I/O error.  This
+** is used for testing the I/O recovery logic.
+*/
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_io_error_hit;
+SQLITE_API extern int sqlite3_io_error_hardhit;
+SQLITE_API extern int sqlite3_io_error_pending;
+SQLITE_API extern int sqlite3_io_error_persist;
+SQLITE_API extern int sqlite3_io_error_benign;
+SQLITE_API extern int sqlite3_diskfull_pending;
+SQLITE_API extern int sqlite3_diskfull;
+#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
+#define SimulateIOError(CODE)  \
+  if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
+       || sqlite3_io_error_pending-- == 1 )  \
+              { local_ioerr(); CODE; }
+static void local_ioerr(){
+  IOTRACE(("IOERR\n"));
+  sqlite3_io_error_hit++;
+  if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
+}
+#define SimulateDiskfullError(CODE) \
+   if( sqlite3_diskfull_pending ){ \
+     if( sqlite3_diskfull_pending == 1 ){ \
+       local_ioerr(); \
+       sqlite3_diskfull = 1; \
+       sqlite3_io_error_hit = 1; \
+       CODE; \
+     }else{ \
+       sqlite3_diskfull_pending--; \
+     } \
+   }
+#else
+#define SimulateIOErrorBenign(X)
+#define SimulateIOError(A)
+#define SimulateDiskfullError(A)
+#endif /* defined(SQLITE_TEST) */
+
+/*
+** When testing, keep a count of the number of open files.
+*/
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_open_file_count;
+#define OpenCounter(X)  sqlite3_open_file_count+=(X)
+#else
+#define OpenCounter(X)
+#endif /* defined(SQLITE_TEST) */
+
+#endif /* !defined(_OS_COMMON_H_) */
+
+/************** End of os_common.h *******************************************/
+/************** Begin file ctime.c *******************************************/
+/*
+** 2010 February 23
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+**
+** This file implements routines used to report what compile-time options
+** SQLite was built with.
+*/
+#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */
+
+/*
+** Include the configuration header output by 'configure' if we're using the
+** autoconf-based build
+*/
+#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H)
+/* #include "config.h" */
+#define SQLITECONFIG_H 1
+#endif
+
+/* These macros are provided to "stringify" the value of the define
+** for those options in which the value is meaningful. */
+#define CTIMEOPT_VAL_(opt) #opt
+#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
+
+/* Like CTIMEOPT_VAL, but especially for SQLITE_DEFAULT_LOOKASIDE. This
+** option requires a separate macro because legal values contain a single
+** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */
+#define CTIMEOPT_VAL2_(opt1,opt2) #opt1 "," #opt2
+#define CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt)
+/* #include "sqliteInt.h" */
+
+/*
+** An array of names of all compile-time options.  This array should
+** be sorted A-Z.
+**
+** This array looks large, but in a typical installation actually uses
+** only a handful of compile-time options, so most times this array is usually
+** rather short and uses little memory space.
+*/
+static const char * const sqlite3azCompileOpt[] = {
+
+/*
+** BEGIN CODE GENERATED BY tool/mkctime.tcl
+*/
+#ifdef SQLITE_32BIT_ROWID
+  "32BIT_ROWID",
+#endif
+#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
+  "4_BYTE_ALIGNED_MALLOC",
+#endif
+#ifdef SQLITE_64BIT_STATS
+  "64BIT_STATS",
+#endif
+#ifdef SQLITE_ALLOW_COVERING_INDEX_SCAN
+# if SQLITE_ALLOW_COVERING_INDEX_SCAN != 1
+  "ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN),
+# endif
+#endif
+#ifdef SQLITE_ALLOW_URI_AUTHORITY
+  "ALLOW_URI_AUTHORITY",
+#endif
+#ifdef SQLITE_ATOMIC_INTRINSICS
+  "ATOMIC_INTRINSICS=" CTIMEOPT_VAL(SQLITE_ATOMIC_INTRINSICS),
+#endif
+#ifdef SQLITE_BITMASK_TYPE
+  "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE),
+#endif
+#ifdef SQLITE_BUG_COMPATIBLE_20160819
+  "BUG_COMPATIBLE_20160819",
+#endif
+#ifdef SQLITE_CASE_SENSITIVE_LIKE
+  "CASE_SENSITIVE_LIKE",
+#endif
+#ifdef SQLITE_CHECK_PAGES
+  "CHECK_PAGES",
+#endif
+#if defined(__clang__) && defined(__clang_major__)
+  "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "."
+                    CTIMEOPT_VAL(__clang_minor__) "."
+                    CTIMEOPT_VAL(__clang_patchlevel__),
+#elif defined(_MSC_VER)
+  "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),
+#elif defined(__GNUC__) && defined(__VERSION__)
+  "COMPILER=gcc-" __VERSION__,
+#endif
+#ifdef SQLITE_COVERAGE_TEST
+  "COVERAGE_TEST",
+#endif
+#ifdef SQLITE_DEBUG
+  "DEBUG",
+#endif
+#ifdef SQLITE_DEFAULT_AUTOMATIC_INDEX
+  "DEFAULT_AUTOMATIC_INDEX",
+#endif
+#ifdef SQLITE_DEFAULT_AUTOVACUUM
+  "DEFAULT_AUTOVACUUM",
+#endif
+#ifdef SQLITE_DEFAULT_CACHE_SIZE
+  "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE),
+#endif
+#ifdef SQLITE_DEFAULT_CKPTFULLFSYNC
+  "DEFAULT_CKPTFULLFSYNC",
+#endif
+#ifdef SQLITE_DEFAULT_FILE_FORMAT
+  "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT),
+#endif
+#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS
+  "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS),
+#endif
+#ifdef SQLITE_DEFAULT_FOREIGN_KEYS
+  "DEFAULT_FOREIGN_KEYS",
+#endif
+#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
+  "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT),
+#endif
+#ifdef SQLITE_DEFAULT_LOCKING_MODE
+  "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
+#endif
+#ifdef SQLITE_DEFAULT_LOOKASIDE
+  "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
+#endif
+#ifdef SQLITE_DEFAULT_MEMSTATUS
+# if SQLITE_DEFAULT_MEMSTATUS != 1
+  "DEFAULT_MEMSTATUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_MEMSTATUS),
+# endif
+#endif
+#ifdef SQLITE_DEFAULT_MMAP_SIZE
+  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
+#endif
+#ifdef SQLITE_DEFAULT_PAGE_SIZE
+  "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE),
+#endif
+#ifdef SQLITE_DEFAULT_PCACHE_INITSZ
+  "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ),
+#endif
+#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
+  "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS),
+#endif
+#ifdef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
+  "DEFAULT_RECURSIVE_TRIGGERS",
+#endif
+#ifdef SQLITE_DEFAULT_ROWEST
+  "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST),
+#endif
+#ifdef SQLITE_DEFAULT_SECTOR_SIZE
+  "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE),
+#endif
+#ifdef SQLITE_DEFAULT_SYNCHRONOUS
+  "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS),
+#endif
+#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
+  "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT),
+#endif
+#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS
+  "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS),
+#endif
+#ifdef SQLITE_DEFAULT_WORKER_THREADS
+  "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS),
+#endif
+#ifdef SQLITE_DIRECT_OVERFLOW_READ
+  "DIRECT_OVERFLOW_READ",
+#endif
+#ifdef SQLITE_DISABLE_DIRSYNC
+  "DISABLE_DIRSYNC",
+#endif
+#ifdef SQLITE_DISABLE_FTS3_UNICODE
+  "DISABLE_FTS3_UNICODE",
+#endif
+#ifdef SQLITE_DISABLE_FTS4_DEFERRED
+  "DISABLE_FTS4_DEFERRED",
+#endif
+#ifdef SQLITE_DISABLE_INTRINSIC
+  "DISABLE_INTRINSIC",
+#endif
+#ifdef SQLITE_DISABLE_LFS
+  "DISABLE_LFS",
+#endif
+#ifdef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
+  "DISABLE_PAGECACHE_OVERFLOW_STATS",
+#endif
+#ifdef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
+  "DISABLE_SKIPAHEAD_DISTINCT",
+#endif
+#ifdef SQLITE_ENABLE_8_3_NAMES
+  "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES),
+#endif
+#ifdef SQLITE_ENABLE_API_ARMOR
+  "ENABLE_API_ARMOR",
+#endif
+#ifdef SQLITE_ENABLE_ATOMIC_WRITE
+  "ENABLE_ATOMIC_WRITE",
+#endif
+#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
+  "ENABLE_BATCH_ATOMIC_WRITE",
+#endif
+#ifdef SQLITE_ENABLE_BYTECODE_VTAB
+  "ENABLE_BYTECODE_VTAB",
+#endif
+#ifdef SQLITE_ENABLE_CEROD
+  "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
+#endif
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+  "ENABLE_COLUMN_METADATA",
+#endif
+#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
+  "ENABLE_COLUMN_USED_MASK",
+#endif
+#ifdef SQLITE_ENABLE_COSTMULT
+  "ENABLE_COSTMULT",
+#endif
+#ifdef SQLITE_ENABLE_CURSOR_HINTS
+  "ENABLE_CURSOR_HINTS",
+#endif
+#ifdef SQLITE_ENABLE_DBPAGE_VTAB
+  "ENABLE_DBPAGE_VTAB",
+#endif
+#ifdef SQLITE_ENABLE_DBSTAT_VTAB
+  "ENABLE_DBSTAT_VTAB",
+#endif
+#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
+  "ENABLE_EXPENSIVE_ASSERT",
+#endif
+#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
+  "ENABLE_EXPLAIN_COMMENTS",
+#endif
+#ifdef SQLITE_ENABLE_FTS3
+  "ENABLE_FTS3",
+#endif
+#ifdef SQLITE_ENABLE_FTS3_PARENTHESIS
+  "ENABLE_FTS3_PARENTHESIS",
+#endif
+#ifdef SQLITE_ENABLE_FTS3_TOKENIZER
+  "ENABLE_FTS3_TOKENIZER",
+#endif
+#ifdef SQLITE_ENABLE_FTS4
+  "ENABLE_FTS4",
+#endif
+#ifdef SQLITE_ENABLE_FTS5
+  "ENABLE_FTS5",
+#endif
+#ifdef SQLITE_ENABLE_GEOPOLY
+  "ENABLE_GEOPOLY",
+#endif
+#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS
+  "ENABLE_HIDDEN_COLUMNS",
+#endif
+#ifdef SQLITE_ENABLE_ICU
+  "ENABLE_ICU",
+#endif
+#ifdef SQLITE_ENABLE_IOTRACE
+  "ENABLE_IOTRACE",
+#endif
+#ifdef SQLITE_ENABLE_JSON1
+  "ENABLE_JSON1",
+#endif
+#ifdef SQLITE_ENABLE_LOAD_EXTENSION
+  "ENABLE_LOAD_EXTENSION",
+#endif
+#ifdef SQLITE_ENABLE_LOCKING_STYLE
+  "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
+#endif
+#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
+  "ENABLE_MATH_FUNCTIONS",
+#endif
+#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
+  "ENABLE_MEMORY_MANAGEMENT",
+#endif
+#ifdef SQLITE_ENABLE_MEMSYS3
+  "ENABLE_MEMSYS3",
+#endif
+#ifdef SQLITE_ENABLE_MEMSYS5
+  "ENABLE_MEMSYS5",
+#endif
+#ifdef SQLITE_ENABLE_MULTIPLEX
+  "ENABLE_MULTIPLEX",
+#endif
+#ifdef SQLITE_ENABLE_NORMALIZE
+  "ENABLE_NORMALIZE",
+#endif
+#ifdef SQLITE_ENABLE_NULL_TRIM
+  "ENABLE_NULL_TRIM",
+#endif
+#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
+  "ENABLE_OFFSET_SQL_FUNC",
+#endif
+#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK
+  "ENABLE_OVERSIZE_CELL_CHECK",
+#endif
+#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
+  "ENABLE_PREUPDATE_HOOK",
+#endif
+#ifdef SQLITE_ENABLE_QPSG
+  "ENABLE_QPSG",
+#endif
+#ifdef SQLITE_ENABLE_RBU
+  "ENABLE_RBU",
+#endif
+#ifdef SQLITE_ENABLE_RTREE
+  "ENABLE_RTREE",
+#endif
+#ifdef SQLITE_ENABLE_SELECTTRACE
+  "ENABLE_SELECTTRACE",
+#endif
+#ifdef SQLITE_ENABLE_SESSION
+  "ENABLE_SESSION",
+#endif
+#ifdef SQLITE_ENABLE_SNAPSHOT
+  "ENABLE_SNAPSHOT",
+#endif
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES
+  "ENABLE_SORTER_REFERENCES",
+#endif
+#ifdef SQLITE_ENABLE_SQLLOG
+  "ENABLE_SQLLOG",
+#endif
+#ifdef SQLITE_ENABLE_STAT4
+  "ENABLE_STAT4",
+#endif
+#ifdef SQLITE_ENABLE_STMTVTAB
+  "ENABLE_STMTVTAB",
+#endif
+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
+  "ENABLE_STMT_SCANSTATUS",
+#endif
+#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
+  "ENABLE_UNKNOWN_SQL_FUNCTION",
+#endif
+#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
+  "ENABLE_UNLOCK_NOTIFY",
+#endif
+#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
+  "ENABLE_UPDATE_DELETE_LIMIT",
+#endif
+#ifdef SQLITE_ENABLE_URI_00_ERROR
+  "ENABLE_URI_00_ERROR",
+#endif
+#ifdef SQLITE_ENABLE_VFSTRACE
+  "ENABLE_VFSTRACE",
+#endif
+#ifdef SQLITE_ENABLE_WHERETRACE
+  "ENABLE_WHERETRACE",
+#endif
+#ifdef SQLITE_ENABLE_ZIPVFS
+  "ENABLE_ZIPVFS",
+#endif
+#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS
+  "EXPLAIN_ESTIMATED_ROWS",
+#endif
+#ifdef SQLITE_EXTRA_IFNULLROW
+  "EXTRA_IFNULLROW",
+#endif
+#ifdef SQLITE_EXTRA_INIT
+  "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT),
+#endif
+#ifdef SQLITE_EXTRA_SHUTDOWN
+  "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN),
+#endif
+#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH
+  "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH),
+#endif
+#ifdef SQLITE_FTS5_ENABLE_TEST_MI
+  "FTS5_ENABLE_TEST_MI",
+#endif
+#ifdef SQLITE_FTS5_NO_WITHOUT_ROWID
+  "FTS5_NO_WITHOUT_ROWID",
+#endif
+#if HAVE_ISNAN || SQLITE_HAVE_ISNAN
+  "HAVE_ISNAN",
+#endif
+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
+# if SQLITE_HOMEGROWN_RECURSIVE_MUTEX != 1
+  "HOMEGROWN_RECURSIVE_MUTEX=" CTIMEOPT_VAL(SQLITE_HOMEGROWN_RECURSIVE_MUTEX),
+# endif
+#endif
+#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
+  "IGNORE_AFP_LOCK_ERRORS",
+#endif
+#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
+  "IGNORE_FLOCK_LOCK_ERRORS",
+#endif
+#ifdef SQLITE_INLINE_MEMCPY
+  "INLINE_MEMCPY",
+#endif
+#ifdef SQLITE_INT64_TYPE
+  "INT64_TYPE",
+#endif
+#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX
+  "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX),
+#endif
+#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
+  "LIKE_DOESNT_MATCH_BLOBS",
+#endif
+#ifdef SQLITE_LOCK_TRACE
+  "LOCK_TRACE",
+#endif
+#ifdef SQLITE_LOG_CACHE_SPILL
+  "LOG_CACHE_SPILL",
+#endif
+#ifdef SQLITE_MALLOC_SOFT_LIMIT
+  "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT),
+#endif
+#ifdef SQLITE_MAX_ATTACHED
+  "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED),
+#endif
+#ifdef SQLITE_MAX_COLUMN
+  "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN),
+#endif
+#ifdef SQLITE_MAX_COMPOUND_SELECT
+  "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT),
+#endif
+#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE
+  "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE),
+#endif
+#ifdef SQLITE_MAX_EXPR_DEPTH
+  "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH),
+#endif
+#ifdef SQLITE_MAX_FUNCTION_ARG
+  "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG),
+#endif
+#ifdef SQLITE_MAX_LENGTH
+  "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH),
+#endif
+#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH
+  "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH),
+#endif
+#ifdef SQLITE_MAX_MEMORY
+  "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY),
+#endif
+#ifdef SQLITE_MAX_MMAP_SIZE
+  "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),
+#endif
+#ifdef SQLITE_MAX_MMAP_SIZE_
+  "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_),
+#endif
+#ifdef SQLITE_MAX_PAGE_COUNT
+  "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT),
+#endif
+#ifdef SQLITE_MAX_PAGE_SIZE
+  "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE),
+#endif
+#ifdef SQLITE_MAX_SCHEMA_RETRY
+  "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
+#endif
+#ifdef SQLITE_MAX_SQL_LENGTH
+  "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH),
+#endif
+#ifdef SQLITE_MAX_TRIGGER_DEPTH
+  "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH),
+#endif
+#ifdef SQLITE_MAX_VARIABLE_NUMBER
+  "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER),
+#endif
+#ifdef SQLITE_MAX_VDBE_OP
+  "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP),
+#endif
+#ifdef SQLITE_MAX_WORKER_THREADS
+  "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS),
+#endif
+#ifdef SQLITE_MEMDEBUG
+  "MEMDEBUG",
+#endif
+#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
+  "MIXED_ENDIAN_64BIT_FLOAT",
+#endif
+#ifdef SQLITE_MMAP_READWRITE
+  "MMAP_READWRITE",
+#endif
+#ifdef SQLITE_MUTEX_NOOP
+  "MUTEX_NOOP",
+#endif
+#ifdef SQLITE_MUTEX_OMIT
+  "MUTEX_OMIT",
+#endif
+#ifdef SQLITE_MUTEX_PTHREADS
+  "MUTEX_PTHREADS",
+#endif
+#ifdef SQLITE_MUTEX_W32
+  "MUTEX_W32",
+#endif
+#ifdef SQLITE_NEED_ERR_NAME
+  "NEED_ERR_NAME",
+#endif
+#ifdef SQLITE_NO_SYNC
+  "NO_SYNC",
+#endif
+#ifdef SQLITE_OMIT_ALTERTABLE
+  "OMIT_ALTERTABLE",
+#endif
+#ifdef SQLITE_OMIT_ANALYZE
+  "OMIT_ANALYZE",
+#endif
+#ifdef SQLITE_OMIT_ATTACH
+  "OMIT_ATTACH",
+#endif
+#ifdef SQLITE_OMIT_AUTHORIZATION
+  "OMIT_AUTHORIZATION",
+#endif
+#ifdef SQLITE_OMIT_AUTOINCREMENT
+  "OMIT_AUTOINCREMENT",
+#endif
+#ifdef SQLITE_OMIT_AUTOINIT
+  "OMIT_AUTOINIT",
+#endif
+#ifdef SQLITE_OMIT_AUTOMATIC_INDEX
+  "OMIT_AUTOMATIC_INDEX",
+#endif
+#ifdef SQLITE_OMIT_AUTORESET
+  "OMIT_AUTORESET",
+#endif
+#ifdef SQLITE_OMIT_AUTOVACUUM
+  "OMIT_AUTOVACUUM",
+#endif
+#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION
+  "OMIT_BETWEEN_OPTIMIZATION",
+#endif
+#ifdef SQLITE_OMIT_BLOB_LITERAL
+  "OMIT_BLOB_LITERAL",
+#endif
+#ifdef SQLITE_OMIT_CAST
+  "OMIT_CAST",
+#endif
+#ifdef SQLITE_OMIT_CHECK
+  "OMIT_CHECK",
+#endif
+#ifdef SQLITE_OMIT_COMPLETE
+  "OMIT_COMPLETE",
+#endif
+#ifdef SQLITE_OMIT_COMPOUND_SELECT
+  "OMIT_COMPOUND_SELECT",
+#endif
+#ifdef SQLITE_OMIT_CONFLICT_CLAUSE
+  "OMIT_CONFLICT_CLAUSE",
+#endif
+#ifdef SQLITE_OMIT_CTE
+  "OMIT_CTE",
+#endif
+#if defined(SQLITE_OMIT_DATETIME_FUNCS) || defined(SQLITE_OMIT_FLOATING_POINT)
+  "OMIT_DATETIME_FUNCS",
+#endif
+#ifdef SQLITE_OMIT_DECLTYPE
+  "OMIT_DECLTYPE",
+#endif
+#ifdef SQLITE_OMIT_DEPRECATED
+  "OMIT_DEPRECATED",
+#endif
+#ifdef SQLITE_OMIT_DESERIALIZE
+  "OMIT_DESERIALIZE",
+#endif
+#ifdef SQLITE_OMIT_DISKIO
+  "OMIT_DISKIO",
+#endif
+#ifdef SQLITE_OMIT_EXPLAIN
+  "OMIT_EXPLAIN",
+#endif
+#ifdef SQLITE_OMIT_FLAG_PRAGMAS
+  "OMIT_FLAG_PRAGMAS",
+#endif
+#ifdef SQLITE_OMIT_FLOATING_POINT
+  "OMIT_FLOATING_POINT",
+#endif
+#ifdef SQLITE_OMIT_FOREIGN_KEY
+  "OMIT_FOREIGN_KEY",
+#endif
+#ifdef SQLITE_OMIT_GET_TABLE
+  "OMIT_GET_TABLE",
+#endif
+#ifdef SQLITE_OMIT_HEX_INTEGER
+  "OMIT_HEX_INTEGER",
+#endif
+#ifdef SQLITE_OMIT_INCRBLOB
+  "OMIT_INCRBLOB",
+#endif
+#ifdef SQLITE_OMIT_INTEGRITY_CHECK
+  "OMIT_INTEGRITY_CHECK",
+#endif
+#ifdef SQLITE_OMIT_INTROSPECTION_PRAGMAS
+  "OMIT_INTROSPECTION_PRAGMAS",
+#endif
+#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION
+  "OMIT_LIKE_OPTIMIZATION",
+#endif
+#ifdef SQLITE_OMIT_LOAD_EXTENSION
+  "OMIT_LOAD_EXTENSION",
+#endif
+#ifdef SQLITE_OMIT_LOCALTIME
+  "OMIT_LOCALTIME",
+#endif
+#ifdef SQLITE_OMIT_LOOKASIDE
+  "OMIT_LOOKASIDE",
+#endif
+#ifdef SQLITE_OMIT_MEMORYDB
+  "OMIT_MEMORYDB",
+#endif
+#ifdef SQLITE_OMIT_OR_OPTIMIZATION
+  "OMIT_OR_OPTIMIZATION",
+#endif
+#ifdef SQLITE_OMIT_PAGER_PRAGMAS
+  "OMIT_PAGER_PRAGMAS",
+#endif
+#ifdef SQLITE_OMIT_PARSER_TRACE
+  "OMIT_PARSER_TRACE",
+#endif
+#ifdef SQLITE_OMIT_POPEN
+  "OMIT_POPEN",
+#endif
+#ifdef SQLITE_OMIT_PRAGMA
+  "OMIT_PRAGMA",
+#endif
+#ifdef SQLITE_OMIT_PROGRESS_CALLBACK
+  "OMIT_PROGRESS_CALLBACK",
+#endif
+#ifdef SQLITE_OMIT_QUICKBALANCE
+  "OMIT_QUICKBALANCE",
+#endif
+#ifdef SQLITE_OMIT_REINDEX
+  "OMIT_REINDEX",
+#endif
+#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS
+  "OMIT_SCHEMA_PRAGMAS",
+#endif
+#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
+  "OMIT_SCHEMA_VERSION_PRAGMAS",
+#endif
+#ifdef SQLITE_OMIT_SHARED_CACHE
+  "OMIT_SHARED_CACHE",
+#endif
+#ifdef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
+  "OMIT_SHUTDOWN_DIRECTORIES",
+#endif
+#ifdef SQLITE_OMIT_SUBQUERY
+  "OMIT_SUBQUERY",
+#endif
+#ifdef SQLITE_OMIT_TCL_VARIABLE
+  "OMIT_TCL_VARIABLE",
+#endif
+#ifdef SQLITE_OMIT_TEMPDB
+  "OMIT_TEMPDB",
+#endif
+#ifdef SQLITE_OMIT_TEST_CONTROL
+  "OMIT_TEST_CONTROL",
+#endif
+#ifdef SQLITE_OMIT_TRACE
+# if SQLITE_OMIT_TRACE != 1
+  "OMIT_TRACE=" CTIMEOPT_VAL(SQLITE_OMIT_TRACE),
+# endif
+#endif
+#ifdef SQLITE_OMIT_TRIGGER
+  "OMIT_TRIGGER",
+#endif
+#ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
+  "OMIT_TRUNCATE_OPTIMIZATION",
+#endif
+#ifdef SQLITE_OMIT_UTF16
+  "OMIT_UTF16",
+#endif
+#ifdef SQLITE_OMIT_VACUUM
+  "OMIT_VACUUM",
+#endif
+#ifdef SQLITE_OMIT_VIEW
+  "OMIT_VIEW",
+#endif
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+  "OMIT_VIRTUALTABLE",
+#endif
+#ifdef SQLITE_OMIT_WAL
+  "OMIT_WAL",
+#endif
+#ifdef SQLITE_OMIT_WSD
+  "OMIT_WSD",
+#endif
+#ifdef SQLITE_OMIT_XFER_OPT
+  "OMIT_XFER_OPT",
+#endif
+#ifdef SQLITE_PCACHE_SEPARATE_HEADER
+  "PCACHE_SEPARATE_HEADER",
+#endif
+#ifdef SQLITE_PERFORMANCE_TRACE
+  "PERFORMANCE_TRACE",
+#endif
+#ifdef SQLITE_POWERSAFE_OVERWRITE
+# if SQLITE_POWERSAFE_OVERWRITE != 1
+  "POWERSAFE_OVERWRITE=" CTIMEOPT_VAL(SQLITE_POWERSAFE_OVERWRITE),
+# endif
+#endif
+#ifdef SQLITE_PREFER_PROXY_LOCKING
+  "PREFER_PROXY_LOCKING",
+#endif
+#ifdef SQLITE_PROXY_DEBUG
+  "PROXY_DEBUG",
+#endif
+#ifdef SQLITE_REVERSE_UNORDERED_SELECTS
+  "REVERSE_UNORDERED_SELECTS",
+#endif
+#ifdef SQLITE_RTREE_INT_ONLY
+  "RTREE_INT_ONLY",
+#endif
+#ifdef SQLITE_SECURE_DELETE
+  "SECURE_DELETE",
+#endif
+#ifdef SQLITE_SMALL_STACK
+  "SMALL_STACK",
+#endif
+#ifdef SQLITE_SORTER_PMASZ
+  "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ),
+#endif
+#ifdef SQLITE_SOUNDEX
+  "SOUNDEX",
+#endif
+#ifdef SQLITE_STAT4_SAMPLES
+  "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES),
+#endif
+#ifdef SQLITE_STMTJRNL_SPILL
+  "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
+#endif
+#ifdef SQLITE_SUBSTR_COMPATIBILITY
+  "SUBSTR_COMPATIBILITY",
+#endif
+#if (!defined(SQLITE_WIN32_MALLOC) \
+     && !defined(SQLITE_ZERO_MALLOC) \
+     && !defined(SQLITE_MEMDEBUG) \
+    ) || defined(SQLITE_SYSTEM_MALLOC)
+  "SYSTEM_MALLOC",
+#endif
+#ifdef SQLITE_TCL
+  "TCL",
+#endif
+#ifdef SQLITE_TEMP_STORE
+  "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
+#endif
+#ifdef SQLITE_TEST
+  "TEST",
+#endif
+#if defined(SQLITE_THREADSAFE)
+  "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
+#elif defined(THREADSAFE)
+  "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE),
+#else
+  "THREADSAFE=1",
+#endif
+#ifdef SQLITE_UNLINK_AFTER_CLOSE
+  "UNLINK_AFTER_CLOSE",
+#endif
+#ifdef SQLITE_UNTESTABLE
+  "UNTESTABLE",
+#endif
+#ifdef SQLITE_USER_AUTHENTICATION
+  "USER_AUTHENTICATION",
+#endif
+#ifdef SQLITE_USE_ALLOCA
+  "USE_ALLOCA",
+#endif
+#ifdef SQLITE_USE_FCNTL_TRACE
+  "USE_FCNTL_TRACE",
+#endif
+#ifdef SQLITE_USE_URI
+  "USE_URI",
+#endif
+#ifdef SQLITE_VDBE_COVERAGE
+  "VDBE_COVERAGE",
+#endif
+#ifdef SQLITE_WIN32_MALLOC
+  "WIN32_MALLOC",
+#endif
+#ifdef SQLITE_ZERO_MALLOC
+  "ZERO_MALLOC",
+#endif
+/*
+** END CODE GENERATED BY tool/mkctime.tcl
+*/
+};
+
+SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){
+  *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]);
+  return (const char**)sqlite3azCompileOpt;
+}
+
+#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
+
+/************** End of ctime.c ***********************************************/
 /************** Begin file global.c ******************************************/
 /*
 ** 2008 June 13
@@ -20483,7 +21292,7 @@ SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = {
     198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
     216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
     234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
-    252,253,254,255
+    252,253,254,255,
 #endif
 #ifdef SQLITE_EBCDIC
       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */
@@ -20503,7 +21312,35 @@ SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = {
     224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */
     240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */
 #endif
+/* All of the upper-to-lower conversion data is above.  The following
+** 18 integers are completely unrelated.  They are appended to the
+** sqlite3UpperToLower[] array to avoid UBSAN warnings.  Here's what is
+** going on:
+**
+** The SQL comparison operators (<>, =, >, <=, <, and >=) are implemented
+** by invoking sqlite3MemCompare(A,B) which compares values A and B and
+** returns negative, zero, or positive if A is less then, equal to, or
+** greater than B, respectively.  Then the true false results is found by
+** consulting sqlite3aLTb[opcode], sqlite3aEQb[opcode], or
+** sqlite3aGTb[opcode] depending on whether the result of compare(A,B)
+** is negative, zero, or positive, where opcode is the specific opcode.
+** The only works because the comparison opcodes are consecutive and in
+** this order: NE EQ GT LE LT GE.  Various assert()s throughout the code
+** ensure that is the case.
+**
+** These elements must be appended to another array.  Otherwise the
+** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus
+** be undefined behavior.  That's goofy, but the C-standards people thought
+** it was a good idea, so here we are.
+*/
+/* NE  EQ  GT  LE  LT  GE  */
+   1,  0,  0,  1,  1,  0,  /* aLTb[]: Use when compare(A,B) less than zero */
+   0,  1,  0,  1,  0,  1,  /* aEQb[]: Use when compare(A,B) equals zero */
+   1,  0,  1,  0,  0,  1   /* aGTb[]: Use when compare(A,B) greater than zero*/
 };
+SQLITE_PRIVATE const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne];
+SQLITE_PRIVATE const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne];
+SQLITE_PRIVATE const unsigned char *sqlite3aGTb = &sqlite3UpperToLower[256+12-OP_Ne];
 
 /*
 ** The following 256 byte lookup table is used to support SQLites built-in
@@ -20697,7 +21534,7 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
    0,                         /* xVdbeBranch */
    0,                         /* pVbeBranchArg */
 #endif
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
    SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */
 #endif
 #ifndef SQLITE_UNTESTABLE
@@ -20716,6 +21553,18 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 */
 SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
 
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
+/*
+** Counter used for coverage testing.  Does not come into play for
+** release builds.
+**
+** Access to this global variable is not mutex protected.  This might
+** result in TSAN warnings.  But as the variable does not exist in
+** release builds, that should not be a concern.
+*/
+SQLITE_PRIVATE unsigned int sqlite3CoverageCounter;
+#endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */
+
 #ifdef VDBE_PROFILE
 /*
 ** The following performance counter can be used in place of
@@ -20747,9 +21596,10 @@ SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000;
 #endif
 
 /*
-** Flags for select tracing and the ".selecttrace" macro of the CLI
+** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
 */
-SQLITE_API u32 sqlite3_unsupported_selecttrace = 0;
+SQLITE_PRIVATE u32 sqlite3SelectTrace = 0;
+SQLITE_PRIVATE u32 sqlite3WhereTrace = 0;
 
 /* #include "opcodes.h" */
 /*
@@ -20765,6 +21615,48 @@ SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
 */
 SQLITE_PRIVATE const char sqlite3StrBINARY[] = "BINARY";
 
+/*
+** Standard typenames.  These names must match the COLTYPE_* definitions.
+** Adjust the SQLITE_N_STDTYPE value if adding or removing entries.
+**
+**    sqlite3StdType[]            The actual names of the datatypes.
+**
+**    sqlite3StdTypeLen[]         The length (in bytes) of each entry
+**                                in sqlite3StdType[].
+**
+**    sqlite3StdTypeAffinity[]    The affinity associated with each entry
+**                                in sqlite3StdType[].
+**
+**    sqlite3StdTypeMap[]         The type value (as returned from
+**                                sqlite3_column_type() or sqlite3_value_type())
+**                                for each entry in sqlite3StdType[].
+*/
+SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 };
+SQLITE_PRIVATE const char sqlite3StdTypeAffinity[] = {
+  SQLITE_AFF_NUMERIC,
+  SQLITE_AFF_BLOB,
+  SQLITE_AFF_INTEGER,
+  SQLITE_AFF_INTEGER,
+  SQLITE_AFF_REAL,
+  SQLITE_AFF_TEXT
+};
+SQLITE_PRIVATE const char sqlite3StdTypeMap[] = {
+  0,
+  SQLITE_BLOB,
+  SQLITE_INTEGER,
+  SQLITE_INTEGER,
+  SQLITE_FLOAT,
+  SQLITE_TEXT
+};
+SQLITE_PRIVATE const char *sqlite3StdType[] = {
+  "ANY",
+  "BLOB",
+  "INT",
+  "INTEGER",
+  "REAL",
+  "TEXT"
+};
+
 /************** End of global.c **********************************************/
 /************** Begin file status.c ******************************************/
 /*
@@ -20873,6 +21765,7 @@ struct VdbeCursor {
   Bool isEphemeral:1;     /* True for an ephemeral table */
   Bool useRandomRowid:1;  /* Generate new record numbers semi-randomly */
   Bool isOrdered:1;       /* True if the table is not BTREE_UNORDERED */
+  Bool hasBeenDuped:1;    /* This cursor was source or target of OP_OpenDup */
   u16 seekHit;            /* See the OP_SeekHit and OP_IfNoHope opcodes */
   Btree *pBtx;            /* Separate file holding temporary table */
   i64 seqCount;           /* Sequence counter */
@@ -20966,8 +21859,8 @@ struct VdbeFrame {
   int nMem;               /* Number of entries in aMem */
   int nChildMem;          /* Number of memory cells for child frame */
   int nChildCsr;          /* Number of cursors for child frame */
-  int nChange;            /* Statement changes (Vdbe.nChange)     */
-  int nDbChange;          /* Value of db->nChange */
+  i64 nChange;            /* Statement changes (Vdbe.nChange)     */
+  i64 nDbChange;          /* Value of db->nChange */
 };
 
 /* Magic number for sanity checking on VdbeFrame objects */
@@ -21168,13 +22061,13 @@ struct Vdbe {
   Vdbe *pPrev,*pNext;     /* Linked list of VDBEs with the same Vdbe.db */
   Parse *pParse;          /* Parsing context used to create this Vdbe */
   ynVar nVar;             /* Number of entries in aVar[] */
-  u32 magic;              /* Magic number for sanity checking */
+  u32 iVdbeMagic;         /* Magic number defining state of the SQL statement */
   int nMem;               /* Number of memory locations currently allocated */
   int nCursor;            /* Number of slots in apCsr[] */
   u32 cacheCtr;           /* VdbeCursor row cache generation counter */
   int pc;                 /* The program counter */
   int rc;                 /* Value to return */
-  int nChange;            /* Number of db changes made since last reset */
+  i64 nChange;            /* Number of db changes made since last reset */
   int iStatement;         /* Statement number (or 0 if has no opened stmt) */
   i64 iCurrentTime;       /* Value of julianday('now') for this statement */
   i64 nFkConstraint;      /* Number of imm. FK constraints this VM */
@@ -21258,6 +22151,7 @@ struct PreUpdate {
   UnpackedRecord *pUnpacked;      /* Unpacked version of aRecord[] */
   UnpackedRecord *pNewUnpacked;   /* Unpacked version of new.* record */
   int iNewReg;                    /* Register for new.* values */
+  int iBlobWrite;                 /* Value returned by preupdate_blobwrite() */
   i64 iKey1;                      /* First key value passed to hook */
   i64 iKey2;                      /* Second key value passed to hook */
   Mem *aNew;                      /* Array of new.* values */
@@ -21301,7 +22195,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
-SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
+SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, i64, u8, void(*)(void*));
 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
 #ifdef SQLITE_OMIT_FLOATING_POINT
 # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
@@ -21311,13 +22205,18 @@ SQLITE_PRIVATE   void sqlite3VdbeMemSetDouble(Mem*, double);
 SQLITE_PRIVATE void sqlite3VdbeMemSetPointer(Mem*, void*, const char*, void(*)(void*));
 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16);
 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
+#ifndef SQLITE_OMIT_INCRBLOB
 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
+#else
+SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem*,int);
+#endif
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*);
 #endif
 SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8);
+SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double);
 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
@@ -21346,7 +22245,8 @@ SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*);      /* Destructor on Mem */
 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */
 SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *);
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
-SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int);
+SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
+    Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int,int);
 #endif
 SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p);
 
@@ -22673,6 +23573,7 @@ static int isDate(
   int eType;
   memset(p, 0, sizeof(*p));
   if( argc==0 ){
+    if( !sqlite3NotPureFunc(context) ) return 1;
     return setDateTimeToCurrent(context, p);
   }
   if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
@@ -22800,131 +23701,100 @@ static void strftimeFunc(
   sqlite3_value **argv
 ){
   DateTime x;
-  u64 n;
   size_t i,j;
-  char *z;
   sqlite3 *db;
   const char *zFmt;
-  char zBuf[100];
+  sqlite3_str sRes;
+
+
   if( argc==0 ) return;
   zFmt = (const char*)sqlite3_value_text(argv[0]);
   if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
   db = sqlite3_context_db_handle(context);
-  for(i=0, n=1; zFmt[i]; i++, n++){
-    if( zFmt[i]=='%' ){
-      switch( zFmt[i+1] ){
-        case 'd':
-        case 'H':
-        case 'm':
-        case 'M':
-        case 'S':
-        case 'W':
-          n++;
-          /* fall thru */
-        case 'w':
-        case '%':
-          break;
-        case 'f':
-          n += 8;
-          break;
-        case 'j':
-          n += 3;
-          break;
-        case 'Y':
-          n += 8;
-          break;
-        case 's':
-        case 'J':
-          n += 50;
-          break;
-        default:
-          return;  /* ERROR.  return a NULL */
-      }
-      i++;
-    }
-  }
-  testcase( n==sizeof(zBuf)-1 );
-  testcase( n==sizeof(zBuf) );
-  testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
-  testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
-  if( n<sizeof(zBuf) ){
-    z = zBuf;
-  }else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
-    sqlite3_result_error_toobig(context);
-    return;
-  }else{
-    z = sqlite3DbMallocRawNN(db, (int)n);
-    if( z==0 ){
-      sqlite3_result_error_nomem(context);
-      return;
-    }
-  }
+  sqlite3StrAccumInit(&sRes, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
+
   computeJD(&x);
   computeYMD_HMS(&x);
   for(i=j=0; zFmt[i]; i++){
-    if( zFmt[i]!='%' ){
-      z[j++] = zFmt[i];
-    }else{
-      i++;
-      switch( zFmt[i] ){
-        case 'd':  sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
-        case 'f': {
-          double s = x.s;
-          if( s>59.999 ) s = 59.999;
-          sqlite3_snprintf(7, &z[j],"%06.3f", s);
-          j += sqlite3Strlen30(&z[j]);
-          break;
-        }
-        case 'H':  sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
-        case 'W': /* Fall thru */
-        case 'j': {
-          int nDay;             /* Number of days since 1st day of year */
-          DateTime y = x;
-          y.validJD = 0;
-          y.M = 1;
-          y.D = 1;
-          computeJD(&y);
-          nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
-          if( zFmt[i]=='W' ){
-            int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
-            wd = (int)(((x.iJD+43200000)/86400000)%7);
-            sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
-            j += 2;
-          }else{
-            sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
-            j += 3;
-          }
-          break;
-        }
-        case 'J': {
-          sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
-          j+=sqlite3Strlen30(&z[j]);
-          break;
-        }
-        case 'm':  sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
-        case 'M':  sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
-        case 's': {
-          i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000);
-          sqlite3Int64ToText(iS, &z[j]);
-          j += sqlite3Strlen30(&z[j]);
-          break;
-        }
-        case 'S':  sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
-        case 'w': {
-          z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
-          break;
-        }
-        case 'Y': {
-          sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
-          break;
+    if( zFmt[i]!='%' ) continue;
+    if( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j));
+    i++;
+    j = i + 1;
+    switch( zFmt[i] ){
+      case 'd': {
+        sqlite3_str_appendf(&sRes, "%02d", x.D);
+        break;
+      }
+      case 'f': {
+        double s = x.s;
+        if( s>59.999 ) s = 59.999;
+        sqlite3_str_appendf(&sRes, "%06.3f", s);
+        break;
+      }
+      case 'H': {
+        sqlite3_str_appendf(&sRes, "%02d", x.h);
+        break;
+      }
+      case 'W': /* Fall thru */
+      case 'j': {
+        int nDay;             /* Number of days since 1st day of year */
+        DateTime y = x;
+        y.validJD = 0;
+        y.M = 1;
+        y.D = 1;
+        computeJD(&y);
+        nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
+        if( zFmt[i]=='W' ){
+          int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
+          wd = (int)(((x.iJD+43200000)/86400000)%7);
+          sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7);
+        }else{
+          sqlite3_str_appendf(&sRes,"%03d",nDay+1);
         }
-        default:   z[j++] = '%'; break;
+        break;
+      }
+      case 'J': {
+        sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0);
+        break;
+      }
+      case 'm': {
+        sqlite3_str_appendf(&sRes,"%02d",x.M);
+        break;
+      }
+      case 'M': {
+        sqlite3_str_appendf(&sRes,"%02d",x.m);
+        break;
+      }
+      case 's': {
+        i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000);
+        sqlite3_str_appendf(&sRes,"%lld",iS);
+        break;
+      }
+      case 'S': {
+        sqlite3_str_appendf(&sRes,"%02d",(int)x.s);
+        break;
+      }
+      case 'w': {
+        sqlite3_str_appendchar(&sRes, 1,
+                       (char)(((x.iJD+129600000)/86400000) % 7) + '0');
+        break;
+      }
+      case 'Y': {
+        sqlite3_str_appendf(&sRes,"%04d",x.Y);
+        break;
+      }
+      case '%': {
+        sqlite3_str_appendchar(&sRes, 1, '%');
+        break;
+      }
+      default: {
+        sqlite3_str_reset(&sRes);
+        return;
       }
     }
   }
-  z[j] = 0;
-  sqlite3_result_text(context, z, -1,
-                      z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC);
+  if( j<i ) sqlite3_str_append(&sRes, zFmt+j, (int)(i-j));
+  sqlite3ResultStrAccum(context, &sRes);
 }
 
 /*
@@ -23173,6 +24043,8 @@ SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
 #ifdef SQLITE_TEST
   if( op!=SQLITE_FCNTL_COMMIT_PHASETWO
    && op!=SQLITE_FCNTL_LOCK_TIMEOUT
+   && op!=SQLITE_FCNTL_CKPT_DONE
+   && op!=SQLITE_FCNTL_CKPT_START
   ){
     /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
     ** is using a regular VFS, it is called after the corresponding
@@ -23183,7 +24055,12 @@ SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
     ** The core must call OsFileControl() though, not OsFileControlHint(),
     ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
     ** means the commit really has failed and an error should be returned
-    ** to the user.  */
+    ** to the user.
+    **
+    ** The CKPT_DONE and CKPT_START file-controls are write-only signals
+    ** to the cksumvfs.  Their return code is meaningless and is ignored
+    ** by the SQLite core, so there is no point in simulating OOMs for them.
+    */
     DO_OS_MALLOC_TEST(id);
   }
 #endif
@@ -23198,6 +24075,7 @@ SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){
   return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
 }
 SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
+  if( NEVER(id->pMethods==0) ) return 0;
   return id->pMethods->xDeviceCharacteristics(id);
 }
 #ifndef SQLITE_OMIT_WAL
@@ -23266,7 +24144,7 @@ SQLITE_PRIVATE int sqlite3OsOpen(
 SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
   DO_OS_MALLOC_TEST(0);
   assert( dirSync==0 || dirSync==1 );
-  return pVfs->xDelete(pVfs, zPath, dirSync);
+  return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK;
 }
 SQLITE_PRIVATE int sqlite3OsAccess(
   sqlite3_vfs *pVfs,
@@ -23289,6 +24167,8 @@ SQLITE_PRIVATE int sqlite3OsFullPathname(
 }
 #ifndef SQLITE_OMIT_LOAD_EXTENSION
 SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  assert( zPath!=0 );
+  assert( strlen(zPath)<=SQLITE_MAX_PATHLEN );  /* tag-20210611-1 */
   return pVfs->xDlOpen(pVfs, zPath);
 }
 SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
@@ -23350,12 +24230,15 @@ SQLITE_PRIVATE int sqlite3OsOpenMalloc(
     rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
     if( rc!=SQLITE_OK ){
       sqlite3_free(pFile);
+      *ppFile = 0;
     }else{
       *ppFile = pFile;
     }
   }else{
+    *ppFile = 0;
     rc = SQLITE_NOMEM_BKPT;
   }
+  assert( *ppFile!=0 || rc!=SQLITE_OK );
   return rc;
 }
 SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){
@@ -24073,7 +24956,7 @@ static void adjustStats(int iSize, int increment){
 ** This routine checks the guards at either end of the allocation and
 ** if they are incorrect it asserts.
 */
-static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
+static struct MemBlockHdr *sqlite3MemsysGetHeader(const void *pAllocation){
   struct MemBlockHdr *p;
   int *pInt;
   u8 *pU8;
@@ -24320,7 +25203,7 @@ SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){
 **
 **     assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
 */
-SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){
+SQLITE_PRIVATE int sqlite3MemdebugHasType(const void *p, u8 eType){
   int rc = 1;
   if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){
     struct MemBlockHdr *pHdr;
@@ -24342,7 +25225,7 @@ SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){
 **
 **     assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
 */
-SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){
+SQLITE_PRIVATE int sqlite3MemdebugNoType(const void *p, u8 eType){
   int rc = 1;
   if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){
     struct MemBlockHdr *pHdr;
@@ -26720,205 +27603,7 @@ SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
 /*
 ** Include code that is common to all os_*.c files
 */
-/************** Include os_common.h in the middle of mutex_w32.c *************/
-/************** Begin file os_common.h ***************************************/
-/*
-** 2004 May 22
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains macros and a little bit of code that is common to
-** all of the platform-specific files (os_*.c) and is #included into those
-** files.
-**
-** This file should be #included by the os_*.c files only.  It is not a
-** general purpose header file.
-*/
-#ifndef _OS_COMMON_H_
-#define _OS_COMMON_H_
-
-/*
-** At least two bugs have slipped in because we changed the MEMORY_DEBUG
-** macro to SQLITE_DEBUG and some older makefiles have not yet made the
-** switch.  The following code should catch this problem at compile-time.
-*/
-#ifdef MEMORY_DEBUG
-# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."
-#endif
-
-/*
-** Macros for performance tracing.  Normally turned off.  Only works
-** on i486 hardware.
-*/
-#ifdef SQLITE_PERFORMANCE_TRACE
-
-/*
-** hwtime.h contains inline assembler code for implementing
-** high-performance timing routines.
-*/
-/************** Include hwtime.h in the middle of os_common.h ****************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 27
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-/*
-** The following routine only works on pentium-class (or newer) processors.
-** It uses the RDTSC opcode to read the cycle count value out of the
-** processor and returns that value.  This can be used for high-res
-** profiling.
-*/
-#if !defined(__STRICT_ANSI__) && \
-    (defined(__GNUC__) || defined(_MSC_VER)) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  #if defined(__GNUC__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-  #elif defined(_MSC_VER)
-
-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
-     __asm {
-        rdtsc
-        ret       ; return value at EDX:EAX
-     }
-  }
-
-  #endif
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long val;
-      __asm__ __volatile__ ("rdtsc" : "=A" (val));
-      return val;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in os_common.h ******************/
-
-static sqlite_uint64 g_start;
-static sqlite_uint64 g_elapsed;
-#define TIMER_START       g_start=sqlite3Hwtime()
-#define TIMER_END         g_elapsed=sqlite3Hwtime()-g_start
-#define TIMER_ELAPSED     g_elapsed
-#else
-#define TIMER_START
-#define TIMER_END
-#define TIMER_ELAPSED     ((sqlite_uint64)0)
-#endif
-
-/*
-** If we compile with the SQLITE_TEST macro set, then the following block
-** of code will give us the ability to simulate a disk I/O error.  This
-** is used for testing the I/O recovery logic.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_io_error_hit;
-SQLITE_API extern int sqlite3_io_error_hardhit;
-SQLITE_API extern int sqlite3_io_error_pending;
-SQLITE_API extern int sqlite3_io_error_persist;
-SQLITE_API extern int sqlite3_io_error_benign;
-SQLITE_API extern int sqlite3_diskfull_pending;
-SQLITE_API extern int sqlite3_diskfull;
-#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
-#define SimulateIOError(CODE)  \
-  if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
-       || sqlite3_io_error_pending-- == 1 )  \
-              { local_ioerr(); CODE; }
-static void local_ioerr(){
-  IOTRACE(("IOERR\n"));
-  sqlite3_io_error_hit++;
-  if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
-}
-#define SimulateDiskfullError(CODE) \
-   if( sqlite3_diskfull_pending ){ \
-     if( sqlite3_diskfull_pending == 1 ){ \
-       local_ioerr(); \
-       sqlite3_diskfull = 1; \
-       sqlite3_io_error_hit = 1; \
-       CODE; \
-     }else{ \
-       sqlite3_diskfull_pending--; \
-     } \
-   }
-#else
-#define SimulateIOErrorBenign(X)
-#define SimulateIOError(A)
-#define SimulateDiskfullError(A)
-#endif /* defined(SQLITE_TEST) */
-
-/*
-** When testing, keep a count of the number of open files.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_open_file_count;
-#define OpenCounter(X)  sqlite3_open_file_count+=(X)
-#else
-#define OpenCounter(X)
-#endif /* defined(SQLITE_TEST) */
-
-#endif /* !defined(_OS_COMMON_H_) */
-
-/************** End of os_common.h *******************************************/
-/************** Continuing where we left off in mutex_w32.c ******************/
+/* #include "os_common.h" */
 
 /*
 ** Include the header file for the Windows VFS.
@@ -27556,7 +28241,6 @@ SQLITE_PRIVATE int sqlite3MallocInit(void){
   if( sqlite3GlobalConfig.m.xMalloc==0 ){
     sqlite3MemSetDefault();
   }
-  memset(&mem0, 0, sizeof(mem0));
   mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
   if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
       || sqlite3GlobalConfig.nPage<=0 ){
@@ -27712,7 +28396,7 @@ SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){
 ** TRUE if p is a lookaside memory allocation from db
 */
 #ifndef SQLITE_OMIT_LOOKASIDE
-static int isLookaside(sqlite3 *db, void *p){
+static int isLookaside(sqlite3 *db, const void *p){
   return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);
 }
 #else
@@ -27723,18 +28407,18 @@ static int isLookaside(sqlite3 *db, void *p){
 ** Return the size of a memory allocation previously obtained from
 ** sqlite3Malloc() or sqlite3_malloc().
 */
-SQLITE_PRIVATE int sqlite3MallocSize(void *p){
+SQLITE_PRIVATE int sqlite3MallocSize(const void *p){
   assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
-  return sqlite3GlobalConfig.m.xSize(p);
+  return sqlite3GlobalConfig.m.xSize((void*)p);
 }
-static int lookasideMallocSize(sqlite3 *db, void *p){
+static int lookasideMallocSize(sqlite3 *db, const void *p){
 #ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
   return p<db->lookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL;
 #else
   return db->lookaside.szTrue;
 #endif
 }
-SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
+SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, const void *p){
   assert( p!=0 );
 #ifdef SQLITE_DEBUG
   if( db==0 || !isLookaside(db,p) ){
@@ -27761,7 +28445,7 @@ SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
       }
     }
   }
-  return sqlite3GlobalConfig.m.xSize(p);
+  return sqlite3GlobalConfig.m.xSize((void*)p);
 }
 SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){
   assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
@@ -28255,7 +28939,7 @@ SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){
 #define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '',
                           NULL pointers replaced by SQL NULL.  %Q */
 #define etTOKEN      11 /* a pointer to a Token structure */
-#define etSRCLIST    12 /* a pointer to a SrcList */
+#define etSRCITEM    12 /* a pointer to a SrcItem */
 #define etPOINTER    13 /* The %p conversion */
 #define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */
 #define etORDINAL    15 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
@@ -28321,10 +29005,16 @@ static const et_info fmtinfo[] = {
 
   /* All the rest are undocumented and are for internal use only */
   {  'T',  0, 0, etTOKEN,      0,  0 },
-  {  'S',  0, 0, etSRCLIST,    0,  0 },
+  {  'S',  0, 0, etSRCITEM,    0,  0 },
   {  'r', 10, 1, etORDINAL,    0,  0 },
 };
 
+/* Notes:
+**
+**    %S    Takes a pointer to SrcItem.  Shows name or database.name
+**    %!S   Like %S but prefer the zName over the zAlias
+*/
+
 /* Floating point constants used for rounding */
 static const double arRound[] = {
   5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05,
@@ -28365,7 +29055,7 @@ static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
 /*
 ** Set the StrAccum object to an error mode.
 */
-static void setStrAccumError(StrAccum *p, u8 eError){
+SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum *p, u8 eError){
   assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG );
   p->accError = eError;
   if( p->mxAlloc ) sqlite3_str_reset(p);
@@ -28401,12 +29091,12 @@ static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){
   char *z;
   if( pAccum->accError ) return 0;
   if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){
-    setStrAccumError(pAccum, SQLITE_TOOBIG);
+    sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG);
     return 0;
   }
   z = sqlite3DbMallocRaw(pAccum->db, n);
   if( z==0 ){
-    setStrAccumError(pAccum, SQLITE_NOMEM);
+    sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM);
   }
   return z;
 }
@@ -29079,21 +29769,24 @@ SQLITE_API void sqlite3_str_vappendf(
         length = width = 0;
         break;
       }
-      case etSRCLIST: {
-        SrcList *pSrc;
-        int k;
-        struct SrcList_item *pItem;
+      case etSRCITEM: {
+        SrcItem *pItem;
         if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
-        pSrc = va_arg(ap, SrcList*);
-        k = va_arg(ap, int);
-        pItem = &pSrc->a[k];
+        pItem = va_arg(ap, SrcItem*);
         assert( bArgList==0 );
-        assert( k>=0 && k<pSrc->nSrc );
-        if( pItem->zDatabase ){
-          sqlite3_str_appendall(pAccum, pItem->zDatabase);
-          sqlite3_str_append(pAccum, ".", 1);
+        if( pItem->zAlias && !flag_altform2 ){
+          sqlite3_str_appendall(pAccum, pItem->zAlias);
+        }else if( pItem->zName ){
+          if( pItem->zDatabase ){
+            sqlite3_str_appendall(pAccum, pItem->zDatabase);
+            sqlite3_str_append(pAccum, ".", 1);
+          }
+          sqlite3_str_appendall(pAccum, pItem->zName);
+        }else if( pItem->zAlias ){
+          sqlite3_str_appendall(pAccum, pItem->zAlias);
+        }else if( ALWAYS(pItem->pSelect) ){
+          sqlite3_str_appendf(pAccum, "SUBQUERY %u", pItem->pSelect->selId);
         }
-        sqlite3_str_appendall(pAccum, pItem->zName);
         length = width = 0;
         break;
       }
@@ -29142,12 +29835,12 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
     return 0;
   }
   if( p->mxAlloc==0 ){
-    setStrAccumError(p, SQLITE_TOOBIG);
+    sqlite3StrAccumSetError(p, SQLITE_TOOBIG);
     return p->nAlloc - p->nChar - 1;
   }else{
     char *zOld = isMalloced(p) ? p->zText : 0;
     i64 szNew = p->nChar;
-    szNew += N + 1;
+    szNew += (sqlite3_int64)N + 1;
     if( szNew+p->nChar<=p->mxAlloc ){
       /* Force exponential buffer size growth as long as it does not overflow,
       ** to avoid having to call this routine too often */
@@ -29155,7 +29848,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
     }
     if( szNew > p->mxAlloc ){
       sqlite3_str_reset(p);
-      setStrAccumError(p, SQLITE_TOOBIG);
+      sqlite3StrAccumSetError(p, SQLITE_TOOBIG);
       return 0;
     }else{
       p->nAlloc = (int)szNew;
@@ -29173,7 +29866,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
       p->printfFlags |= SQLITE_PRINTF_MALLOCED;
     }else{
       sqlite3_str_reset(p);
-      setStrAccumError(p, SQLITE_NOMEM);
+      sqlite3StrAccumSetError(p, SQLITE_NOMEM);
       return 0;
     }
   }
@@ -29246,7 +29939,7 @@ static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){
     memcpy(zText, p->zText, p->nChar+1);
     p->printfFlags |= SQLITE_PRINTF_MALLOCED;
   }else{
-    setStrAccumError(p, SQLITE_NOMEM);
+    sqlite3StrAccumSetError(p, SQLITE_NOMEM);
   }
   p->zText = zText;
   return zText;
@@ -29261,6 +29954,22 @@ SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
   return p->zText;
 }
 
+/*
+** Use the content of the StrAccum passed as the second argument
+** as the result of an SQL function.
+*/
+SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){
+  if( p->accError ){
+    sqlite3_result_error_code(pCtx, p->accError);
+    sqlite3_str_reset(p);
+  }else if( isMalloced(p) ){
+    sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC);
+  }else{
+    sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
+    sqlite3_str_reset(p);
+  }
+}
+
 /*
 ** This singleton is an sqlite3_str object that is returned if
 ** sqlite3_malloc() fails to provide space for a real one.  This
@@ -29650,7 +30359,10 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
         }
         sqlite3_str_appendf(&x, ")");
       }
-      sqlite3_str_appendf(&x, " AS");
+      if( pCte->pUse ){
+        sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse,
+                 pCte->pUse->nUse);
+      }
       sqlite3StrAccumFinish(&x);
       sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1);
       sqlite3TreeViewSelect(pView, pCte->pSelect, 0);
@@ -29666,29 +30378,27 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
 SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
   int i;
   for(i=0; i<pSrc->nSrc; i++){
-    const struct SrcList_item *pItem = &pSrc->a[i];
+    const SrcItem *pItem = &pSrc->a[i];
     StrAccum x;
     char zLine[100];
     sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
-    sqlite3_str_appendf(&x, "{%d:*}", pItem->iCursor);
-    if( pItem->zDatabase ){
-      sqlite3_str_appendf(&x, " %s.%s", pItem->zDatabase, pItem->zName);
-    }else if( pItem->zName ){
-      sqlite3_str_appendf(&x, " %s", pItem->zName);
-    }
+    x.printfFlags |= SQLITE_PRINTF_INTERNAL;
+    sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem);
     if( pItem->pTab ){
       sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
            pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
     }
-    if( pItem->zAlias ){
-      sqlite3_str_appendf(&x, " (AS %s)", pItem->zAlias);
-    }
     if( pItem->fg.jointype & JT_LEFT ){
       sqlite3_str_appendf(&x, " LEFT-JOIN");
+    }else if( pItem->fg.jointype & JT_CROSS ){
+      sqlite3_str_appendf(&x, " CROSS-JOIN");
     }
     if( pItem->fg.fromDDL ){
       sqlite3_str_appendf(&x, " DDL");
     }
+    if( pItem->fg.isCte ){
+      sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse);
+    }
     sqlite3StrAccumFinish(&x);
     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
     if( pItem->pSelect ){
@@ -29980,6 +30690,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s",
                                     pExpr->iColumn, zFlgs, zOp2);
       }else{
+        assert( ExprUseYTab(pExpr) );
         sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s",
                         pExpr->iTable, pExpr->iColumn,
                         pExpr->y.pTab, zFlgs);
@@ -29999,11 +30710,13 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     }
 #ifndef SQLITE_OMIT_FLOATING_POINT
     case TK_FLOAT: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
       break;
     }
 #endif
     case TK_STRING: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken);
       break;
     }
@@ -30012,17 +30725,19 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
       break;
     }
     case TK_TRUEFALSE: {
-      sqlite3TreeViewLine(pView,
-         sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE");
+      sqlite3TreeViewLine(pView,"%s%s",
+         sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs);
       break;
     }
 #ifndef SQLITE_OMIT_BLOB_LITERAL
     case TK_BLOB: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken);
       break;
     }
 #endif
     case TK_VARIABLE: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)",
                           pExpr->u.zToken, pExpr->iColumn);
       break;
@@ -30032,12 +30747,14 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
       break;
     }
     case TK_ID: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken);
       break;
     }
 #ifndef SQLITE_OMIT_CAST
     case TK_CAST: {
       /* Expressions of the form:   CAST(pLeft AS token) */
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken);
       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
       break;
@@ -30087,6 +30804,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     }
 
     case TK_SPAN: {
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
       break;
@@ -30098,6 +30816,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
       ** up in the treeview output as "SOFT-COLLATE".  Explicit COLLATE
       ** operators that appear in the original SQL always have the
       ** EP_Collate bit set and appear in treeview output as just "COLLATE" */
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s",
         !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "",
         pExpr->u.zToken, zFlgs);
@@ -30113,6 +30832,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         pFarg = 0;
         pWin = 0;
       }else{
+        assert( ExprUseXList(pExpr) );
         pFarg = pExpr->x.pList;
 #ifndef SQLITE_OMIT_WINDOWFUNC
         pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0;
@@ -30120,6 +30840,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         pWin = 0;
 #endif
       }
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       if( pExpr->op==TK_AGG_FUNCTION ){
         sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p",
                              pExpr->op2, pExpr->u.zToken, zFlgs,
@@ -30151,11 +30872,13 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     }
 #ifndef SQLITE_OMIT_SUBQUERY
     case TK_EXISTS: {
+      assert( ExprUseXSelect(pExpr) );
       sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags);
       sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
       break;
     }
     case TK_SELECT: {
+      assert( ExprUseXSelect(pExpr) );
       sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags);
       sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
       break;
@@ -30163,7 +30886,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     case TK_IN: {
       sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags);
       sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
-      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+      if( ExprUseXSelect(pExpr) ){
         sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
       }else{
         sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
@@ -30184,9 +30907,12 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     ** Z is stored in pExpr->pList->a[1].pExpr.
     */
     case TK_BETWEEN: {
-      Expr *pX = pExpr->pLeft;
-      Expr *pY = pExpr->x.pList->a[0].pExpr;
-      Expr *pZ = pExpr->x.pList->a[1].pExpr;
+      const Expr *pX, *pY, *pZ;
+      pX = pExpr->pLeft;
+      assert( ExprUseXList(pExpr) );
+      assert( pExpr->x.pList->nExpr==2 );
+      pY = pExpr->x.pList->a[0].pExpr;
+      pZ = pExpr->x.pList->a[1].pExpr;
       sqlite3TreeViewLine(pView, "BETWEEN");
       sqlite3TreeViewExpr(pView, pX, 1);
       sqlite3TreeViewExpr(pView, pY, 1);
@@ -30208,6 +30934,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     case TK_CASE: {
       sqlite3TreeViewLine(pView, "CASE");
       sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
+      assert( ExprUseXList(pExpr) );
       sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
       break;
     }
@@ -30220,6 +30947,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         case OE_Fail:       zType = "fail";      break;
         case OE_Ignore:     zType = "ignore";    break;
       }
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken);
       break;
     }
@@ -30232,12 +30960,16 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     }
     case TK_VECTOR: {
       char *z = sqlite3_mprintf("VECTOR%s",zFlgs);
+      assert( ExprUseXList(pExpr) );
       sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z);
       sqlite3_free(z);
       break;
     }
     case TK_SELECT_COLUMN: {
-      sqlite3TreeViewLine(pView, "SELECT-COLUMN %d", pExpr->iColumn);
+      sqlite3TreeViewLine(pView, "SELECT-COLUMN %d of [0..%d]%s",
+              pExpr->iColumn, pExpr->iTable-1,
+              pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : "");
+      assert( ExprUseXSelect(pExpr->pLeft) );
       sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0);
       break;
     }
@@ -30246,6 +30978,23 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
       sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
       break;
     }
+    case TK_ERROR: {
+      Expr tmp;
+      sqlite3TreeViewLine(pView, "ERROR");
+      tmp = *pExpr;
+      tmp.op = pExpr->op2;
+      sqlite3TreeViewExpr(pView, &tmp, 0);
+      break;
+    }
+    case TK_ROW: {
+      if( pExpr->iColumn<=0 ){
+        sqlite3TreeViewLine(pView, "First FROM table rowid");
+      }else{
+        sqlite3TreeViewLine(pView, "First FROM table column %d",
+            pExpr->iColumn-1);
+      }
+      break;
+    }
     default: {
       sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
       break;
@@ -30395,11 +31144,16 @@ SQLITE_API void sqlite3_randomness(int N, void *pBuf){
   ** number generator) not as an encryption device.
   */
   if( !wsdPrng.isInit ){
+    sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
     int i;
     char k[256];
     wsdPrng.j = 0;
     wsdPrng.i = 0;
-    sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
+    if( NEVER(pVfs==0) ){
+      memset(k, 0, sizeof(k));
+    }else{
+      sqlite3OsRandomness(pVfs, 256, k);
+    }
     for(i=0; i<256; i++){
       wsdPrng.s[i] = (u8)i;
     }
@@ -31292,16 +32046,6 @@ SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
 #include <math.h>
 #endif
 
-/*
-** Routine needed to support the testcase() macro.
-*/
-#ifdef SQLITE_COVERAGE_TEST
-SQLITE_PRIVATE void sqlite3Coverage(int x){
-  static unsigned dummy = 0;
-  dummy += (unsigned)x;
-}
-#endif
-
 /*
 ** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
 ** or to bypass normal error detection during testing in order to let
@@ -31331,11 +32075,21 @@ SQLITE_PRIVATE int sqlite3FaultSim(int iTest){
 #ifndef SQLITE_OMIT_FLOATING_POINT
 /*
 ** Return true if the floating point value is Not a Number (NaN).
+**
+** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
+** Otherwise, we have our own implementation that works on most systems.
 */
 SQLITE_PRIVATE int sqlite3IsNaN(double x){
+  int rc;   /* The value return */
+#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
   u64 y;
   memcpy(&y,&x,sizeof(y));
-  return IsNaN(y);
+  rc = IsNaN(y);
+#else
+  rc = isnan(x);
+#endif /* HAVE_ISNAN */
+  testcase( rc );
+  return rc;
 }
 #endif /* SQLITE_OMIT_FLOATING_POINT */
 
@@ -31360,8 +32114,14 @@ SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
 */
 SQLITE_PRIVATE char *sqlite3ColumnType(Column *pCol, char *zDflt){
-  if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt;
-  return pCol->zName + strlen(pCol->zName) + 1;
+  if( pCol->colFlags & COLFLAG_HASTYPE ){
+    return pCol->zCnName + strlen(pCol->zCnName) + 1;
+  }else if( pCol->eCType ){
+    assert( pCol->eCType<=SQLITE_N_STDTYPE );
+    return (char*)sqlite3StdType[pCol->eCType-1];
+  }else{
+    return zDflt;
+  }
 }
 
 /*
@@ -31385,6 +32145,16 @@ SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){
   if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code);
 }
 
+/*
+** The equivalent of sqlite3Error(db, SQLITE_OK).  Clear the error state
+** and error message.
+*/
+SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3 *db){
+  assert( db!=0 );
+  db->errCode = SQLITE_OK;
+  if( db->pErr ) sqlite3ValueSetNull(db->pErr);
+}
+
 /*
 ** Load the sqlite3.iSysErrno field if that is an appropriate thing
 ** to do based on the SQLite error code in rc.
@@ -31522,11 +32292,34 @@ SQLITE_PRIVATE void sqlite3Dequote(char *z){
   z[j] = 0;
 }
 SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){
+  assert( !ExprHasProperty(p, EP_IntValue) );
   assert( sqlite3Isquote(p->u.zToken[0]) );
   p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
   sqlite3Dequote(p->u.zToken);
 }
 
+/*
+** If the input token p is quoted, try to adjust the token to remove
+** the quotes.  This is not always possible:
+**
+**     "abc"     ->   abc
+**     "ab""cd"  ->   (not possible because of the interior "")
+**
+** Remove the quotes if possible.  This is a optimization.  The overall
+** system should still return the correct answer even if this routine
+** is always a no-op.
+*/
+SQLITE_PRIVATE void sqlite3DequoteToken(Token *p){
+  unsigned int i;
+  if( p->n<2 ) return;
+  if( !sqlite3Isquote(p->z[0]) ) return;
+  for(i=1; i<p->n-1; i++){
+    if( sqlite3Isquote(p->z[i]) ) return;
+  }
+  p->n -= 2;
+  p->z++;
+}
+
 /*
 ** Generate a Token object from a string
 */
@@ -32632,13 +33425,13 @@ static void logBadConnection(const char *zType){
 ** used as an argument to sqlite3_errmsg() or sqlite3_close().
 */
 SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
-  u32 magic;
+  u8 eOpenState;
   if( db==0 ){
     logBadConnection("NULL");
     return 0;
   }
-  magic = db->magic;
-  if( magic!=SQLITE_MAGIC_OPEN ){
+  eOpenState = db->eOpenState;
+  if( eOpenState!=SQLITE_STATE_OPEN ){
     if( sqlite3SafetyCheckSickOrOk(db) ){
       testcase( sqlite3GlobalConfig.xLog!=0 );
       logBadConnection("unopened");
@@ -32649,11 +33442,11 @@ SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
   }
 }
 SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
-  u32 magic;
-  magic = db->magic;
-  if( magic!=SQLITE_MAGIC_SICK &&
-      magic!=SQLITE_MAGIC_OPEN &&
-      magic!=SQLITE_MAGIC_BUSY ){
+  u8 eOpenState;
+  eOpenState = db->eOpenState;
+  if( eOpenState!=SQLITE_STATE_SICK &&
+      eOpenState!=SQLITE_STATE_OPEN &&
+      eOpenState!=SQLITE_STATE_BUSY ){
     testcase( sqlite3GlobalConfig.xLog!=0 );
     logBadConnection("invalid");
     return 0;
@@ -33272,35 +34065,35 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  18 */ "If"               OpHelp(""),
     /*  19 */ "Not"              OpHelp("r[P2]= !r[P1]"),
     /*  20 */ "IfNot"            OpHelp(""),
-    /*  21 */ "IfNullRow"        OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"),
-    /*  22 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
-    /*  23 */ "SeekLE"           OpHelp("key=r[P3@P4]"),
-    /*  24 */ "SeekGE"           OpHelp("key=r[P3@P4]"),
-    /*  25 */ "SeekGT"           OpHelp("key=r[P3@P4]"),
-    /*  26 */ "IfNotOpen"        OpHelp("if( !csr[P1] ) goto P2"),
-    /*  27 */ "IfNoHope"         OpHelp("key=r[P3@P4]"),
-    /*  28 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
-    /*  29 */ "NotFound"         OpHelp("key=r[P3@P4]"),
-    /*  30 */ "Found"            OpHelp("key=r[P3@P4]"),
-    /*  31 */ "SeekRowid"        OpHelp("intkey=r[P3]"),
-    /*  32 */ "NotExists"        OpHelp("intkey=r[P3]"),
-    /*  33 */ "Last"             OpHelp(""),
-    /*  34 */ "IfSmaller"        OpHelp(""),
-    /*  35 */ "SorterSort"       OpHelp(""),
-    /*  36 */ "Sort"             OpHelp(""),
-    /*  37 */ "Rewind"           OpHelp(""),
-    /*  38 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
-    /*  39 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
-    /*  40 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
-    /*  41 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
-    /*  42 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
+    /*  21 */ "IsNullOrType"     OpHelp("if typeof(r[P1]) IN (P3,5) goto P2"),
+    /*  22 */ "IfNullRow"        OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"),
+    /*  23 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
+    /*  24 */ "SeekLE"           OpHelp("key=r[P3@P4]"),
+    /*  25 */ "SeekGE"           OpHelp("key=r[P3@P4]"),
+    /*  26 */ "SeekGT"           OpHelp("key=r[P3@P4]"),
+    /*  27 */ "IfNotOpen"        OpHelp("if( !csr[P1] ) goto P2"),
+    /*  28 */ "IfNoHope"         OpHelp("key=r[P3@P4]"),
+    /*  29 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
+    /*  30 */ "NotFound"         OpHelp("key=r[P3@P4]"),
+    /*  31 */ "Found"            OpHelp("key=r[P3@P4]"),
+    /*  32 */ "SeekRowid"        OpHelp("intkey=r[P3]"),
+    /*  33 */ "NotExists"        OpHelp("intkey=r[P3]"),
+    /*  34 */ "Last"             OpHelp(""),
+    /*  35 */ "IfSmaller"        OpHelp(""),
+    /*  36 */ "SorterSort"       OpHelp(""),
+    /*  37 */ "Sort"             OpHelp(""),
+    /*  38 */ "Rewind"           OpHelp(""),
+    /*  39 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
+    /*  40 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
+    /*  41 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
+    /*  42 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
     /*  43 */ "Or"               OpHelp("r[P3]=(r[P1] || r[P2])"),
     /*  44 */ "And"              OpHelp("r[P3]=(r[P1] && r[P2])"),
-    /*  45 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
-    /*  46 */ "Program"          OpHelp(""),
-    /*  47 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
-    /*  48 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
-    /*  49 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
+    /*  45 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
+    /*  46 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
+    /*  47 */ "Program"          OpHelp(""),
+    /*  48 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
+    /*  49 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
     /*  50 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
     /*  51 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
     /*  52 */ "Ne"               OpHelp("IF r[P3]!=r[P1]"),
@@ -33309,125 +34102,130 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  55 */ "Le"               OpHelp("IF r[P3]<=r[P1]"),
     /*  56 */ "Lt"               OpHelp("IF r[P3]<r[P1]"),
     /*  57 */ "Ge"               OpHelp("IF r[P3]>=r[P1]"),
-    /*  58 */ "ElseNotEq"        OpHelp(""),
-    /*  59 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
-    /*  60 */ "IncrVacuum"       OpHelp(""),
-    /*  61 */ "VNext"            OpHelp(""),
-    /*  62 */ "Init"             OpHelp("Start at P2"),
-    /*  63 */ "PureFunc"         OpHelp("r[P3]=func(r[P2@NP])"),
-    /*  64 */ "Function"         OpHelp("r[P3]=func(r[P2@NP])"),
-    /*  65 */ "Return"           OpHelp(""),
-    /*  66 */ "EndCoroutine"     OpHelp(""),
-    /*  67 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
-    /*  68 */ "Halt"             OpHelp(""),
-    /*  69 */ "Integer"          OpHelp("r[P2]=P1"),
-    /*  70 */ "Int64"            OpHelp("r[P2]=P4"),
-    /*  71 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
-    /*  72 */ "Null"             OpHelp("r[P2..P3]=NULL"),
-    /*  73 */ "SoftNull"         OpHelp("r[P1]=NULL"),
-    /*  74 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
-    /*  75 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
-    /*  76 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
-    /*  77 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
-    /*  78 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
-    /*  79 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
-    /*  80 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
-    /*  81 */ "CollSeq"          OpHelp(""),
-    /*  82 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
-    /*  83 */ "RealAffinity"     OpHelp(""),
-    /*  84 */ "Cast"             OpHelp("affinity(r[P1])"),
-    /*  85 */ "Permutation"      OpHelp(""),
-    /*  86 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
-    /*  87 */ "IsTrue"           OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"),
-    /*  88 */ "Offset"           OpHelp("r[P3] = sqlite_offset(P1)"),
-    /*  89 */ "Column"           OpHelp("r[P3]=PX"),
-    /*  90 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
-    /*  91 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
-    /*  92 */ "Count"            OpHelp("r[P2]=count()"),
-    /*  93 */ "ReadCookie"       OpHelp(""),
-    /*  94 */ "SetCookie"        OpHelp(""),
-    /*  95 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
-    /*  96 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
-    /*  97 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
-    /*  98 */ "OpenDup"          OpHelp(""),
-    /*  99 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
-    /* 100 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
-    /* 101 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
-    /* 102 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
-    /* 103 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
-    /* 104 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
-    /* 105 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
-    /* 106 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
-    /* 107 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
-    /* 108 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
-    /* 109 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
-    /* 110 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
-    /* 111 */ "SorterOpen"       OpHelp(""),
-    /* 112 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
-    /* 113 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
-    /* 114 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
-    /* 115 */ "String8"          OpHelp("r[P2]='P4'"),
-    /* 116 */ "Close"            OpHelp(""),
-    /* 117 */ "ColumnsUsed"      OpHelp(""),
-    /* 118 */ "SeekScan"         OpHelp("Scan-ahead up to P1 rows"),
-    /* 119 */ "SeekHit"          OpHelp("set P2<=seekHit<=P3"),
-    /* 120 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
-    /* 121 */ "NewRowid"         OpHelp("r[P2]=rowid"),
-    /* 122 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
-    /* 123 */ "Delete"           OpHelp(""),
-    /* 124 */ "ResetCount"       OpHelp(""),
-    /* 125 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
-    /* 126 */ "SorterData"       OpHelp("r[P2]=data"),
-    /* 127 */ "RowData"          OpHelp("r[P2]=data"),
-    /* 128 */ "Rowid"            OpHelp("r[P2]=rowid"),
-    /* 129 */ "NullRow"          OpHelp(""),
-    /* 130 */ "SeekEnd"          OpHelp(""),
-    /* 131 */ "IdxInsert"        OpHelp("key=r[P2]"),
-    /* 132 */ "SorterInsert"     OpHelp("key=r[P2]"),
-    /* 133 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
-    /* 134 */ "DeferredSeek"     OpHelp("Move P3 to P1.rowid if needed"),
-    /* 135 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
-    /* 136 */ "FinishSeek"       OpHelp(""),
-    /* 137 */ "Destroy"          OpHelp(""),
-    /* 138 */ "Clear"            OpHelp(""),
-    /* 139 */ "ResetSorter"      OpHelp(""),
-    /* 140 */ "CreateBtree"      OpHelp("r[P2]=root iDb=P1 flags=P3"),
-    /* 141 */ "SqlExec"          OpHelp(""),
-    /* 142 */ "ParseSchema"      OpHelp(""),
-    /* 143 */ "LoadAnalysis"     OpHelp(""),
-    /* 144 */ "DropTable"        OpHelp(""),
-    /* 145 */ "DropIndex"        OpHelp(""),
-    /* 146 */ "DropTrigger"      OpHelp(""),
-    /* 147 */ "IntegrityCk"      OpHelp(""),
-    /* 148 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
-    /* 149 */ "Param"            OpHelp(""),
-    /* 150 */ "Real"             OpHelp("r[P2]=P4"),
-    /* 151 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
-    /* 152 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
-    /* 153 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
-    /* 154 */ "AggInverse"       OpHelp("accum=r[P3] inverse(r[P2@P5])"),
-    /* 155 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 156 */ "AggStep1"         OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 157 */ "AggValue"         OpHelp("r[P3]=value N=P2"),
-    /* 158 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
-    /* 159 */ "Expire"           OpHelp(""),
-    /* 160 */ "CursorLock"       OpHelp(""),
-    /* 161 */ "CursorUnlock"     OpHelp(""),
-    /* 162 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
-    /* 163 */ "VBegin"           OpHelp(""),
-    /* 164 */ "VCreate"          OpHelp(""),
-    /* 165 */ "VDestroy"         OpHelp(""),
-    /* 166 */ "VOpen"            OpHelp(""),
-    /* 167 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
-    /* 168 */ "VRename"          OpHelp(""),
-    /* 169 */ "Pagecount"        OpHelp(""),
-    /* 170 */ "MaxPgcnt"         OpHelp(""),
-    /* 171 */ "Trace"            OpHelp(""),
-    /* 172 */ "CursorHint"       OpHelp(""),
-    /* 173 */ "ReleaseReg"       OpHelp("release r[P1@P2] mask P3"),
-    /* 174 */ "Noop"             OpHelp(""),
-    /* 175 */ "Explain"          OpHelp(""),
-    /* 176 */ "Abortable"        OpHelp(""),
+    /*  58 */ "ElseEq"           OpHelp(""),
+    /*  59 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]--, goto P2"),
+    /*  60 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
+    /*  61 */ "IncrVacuum"       OpHelp(""),
+    /*  62 */ "VNext"            OpHelp(""),
+    /*  63 */ "Init"             OpHelp("Start at P2"),
+    /*  64 */ "PureFunc"         OpHelp("r[P3]=func(r[P2@NP])"),
+    /*  65 */ "Function"         OpHelp("r[P3]=func(r[P2@NP])"),
+    /*  66 */ "Return"           OpHelp(""),
+    /*  67 */ "EndCoroutine"     OpHelp(""),
+    /*  68 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
+    /*  69 */ "Halt"             OpHelp(""),
+    /*  70 */ "Integer"          OpHelp("r[P2]=P1"),
+    /*  71 */ "Int64"            OpHelp("r[P2]=P4"),
+    /*  72 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
+    /*  73 */ "Null"             OpHelp("r[P2..P3]=NULL"),
+    /*  74 */ "SoftNull"         OpHelp("r[P1]=NULL"),
+    /*  75 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
+    /*  76 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
+    /*  77 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
+    /*  78 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
+    /*  79 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
+    /*  80 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
+    /*  81 */ "ChngCntRow"       OpHelp("output=r[P1]"),
+    /*  82 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
+    /*  83 */ "CollSeq"          OpHelp(""),
+    /*  84 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
+    /*  85 */ "RealAffinity"     OpHelp(""),
+    /*  86 */ "Cast"             OpHelp("affinity(r[P1])"),
+    /*  87 */ "Permutation"      OpHelp(""),
+    /*  88 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
+    /*  89 */ "IsTrue"           OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"),
+    /*  90 */ "ZeroOrNull"       OpHelp("r[P2] = 0 OR NULL"),
+    /*  91 */ "Offset"           OpHelp("r[P3] = sqlite_offset(P1)"),
+    /*  92 */ "Column"           OpHelp("r[P3]=PX"),
+    /*  93 */ "TypeCheck"        OpHelp("typecheck(r[P1@P2])"),
+    /*  94 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
+    /*  95 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
+    /*  96 */ "Count"            OpHelp("r[P2]=count()"),
+    /*  97 */ "ReadCookie"       OpHelp(""),
+    /*  98 */ "SetCookie"        OpHelp(""),
+    /*  99 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
+    /* 100 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
+    /* 101 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
+    /* 102 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
+    /* 103 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
+    /* 104 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
+    /* 105 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
+    /* 106 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
+    /* 107 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
+    /* 108 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
+    /* 109 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
+    /* 110 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
+    /* 111 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
+    /* 112 */ "OpenDup"          OpHelp(""),
+    /* 113 */ "BitNot"           OpHelp("r[P2]= ~r[P1]"),
+    /* 114 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
+    /* 115 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
+    /* 116 */ "String8"          OpHelp("r[P2]='P4'"),
+    /* 117 */ "SorterOpen"       OpHelp(""),
+    /* 118 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
+    /* 119 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
+    /* 120 */ "Close"            OpHelp(""),
+    /* 121 */ "ColumnsUsed"      OpHelp(""),
+    /* 122 */ "SeekScan"         OpHelp("Scan-ahead up to P1 rows"),
+    /* 123 */ "SeekHit"          OpHelp("set P2<=seekHit<=P3"),
+    /* 124 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
+    /* 125 */ "NewRowid"         OpHelp("r[P2]=rowid"),
+    /* 126 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
+    /* 127 */ "RowCell"          OpHelp(""),
+    /* 128 */ "Delete"           OpHelp(""),
+    /* 129 */ "ResetCount"       OpHelp(""),
+    /* 130 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
+    /* 131 */ "SorterData"       OpHelp("r[P2]=data"),
+    /* 132 */ "RowData"          OpHelp("r[P2]=data"),
+    /* 133 */ "Rowid"            OpHelp("r[P2]=rowid"),
+    /* 134 */ "NullRow"          OpHelp(""),
+    /* 135 */ "SeekEnd"          OpHelp(""),
+    /* 136 */ "IdxInsert"        OpHelp("key=r[P2]"),
+    /* 137 */ "SorterInsert"     OpHelp("key=r[P2]"),
+    /* 138 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
+    /* 139 */ "DeferredSeek"     OpHelp("Move P3 to P1.rowid if needed"),
+    /* 140 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
+    /* 141 */ "FinishSeek"       OpHelp(""),
+    /* 142 */ "Destroy"          OpHelp(""),
+    /* 143 */ "Clear"            OpHelp(""),
+    /* 144 */ "ResetSorter"      OpHelp(""),
+    /* 145 */ "CreateBtree"      OpHelp("r[P2]=root iDb=P1 flags=P3"),
+    /* 146 */ "SqlExec"          OpHelp(""),
+    /* 147 */ "ParseSchema"      OpHelp(""),
+    /* 148 */ "LoadAnalysis"     OpHelp(""),
+    /* 149 */ "DropTable"        OpHelp(""),
+    /* 150 */ "DropIndex"        OpHelp(""),
+    /* 151 */ "DropTrigger"      OpHelp(""),
+    /* 152 */ "Real"             OpHelp("r[P2]=P4"),
+    /* 153 */ "IntegrityCk"      OpHelp(""),
+    /* 154 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
+    /* 155 */ "Param"            OpHelp(""),
+    /* 156 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
+    /* 157 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
+    /* 158 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
+    /* 159 */ "AggInverse"       OpHelp("accum=r[P3] inverse(r[P2@P5])"),
+    /* 160 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
+    /* 161 */ "AggStep1"         OpHelp("accum=r[P3] step(r[P2@P5])"),
+    /* 162 */ "AggValue"         OpHelp("r[P3]=value N=P2"),
+    /* 163 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
+    /* 164 */ "Expire"           OpHelp(""),
+    /* 165 */ "CursorLock"       OpHelp(""),
+    /* 166 */ "CursorUnlock"     OpHelp(""),
+    /* 167 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
+    /* 168 */ "VBegin"           OpHelp(""),
+    /* 169 */ "VCreate"          OpHelp(""),
+    /* 170 */ "VDestroy"         OpHelp(""),
+    /* 171 */ "VOpen"            OpHelp(""),
+    /* 172 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
+    /* 173 */ "VRename"          OpHelp(""),
+    /* 174 */ "Pagecount"        OpHelp(""),
+    /* 175 */ "MaxPgcnt"         OpHelp(""),
+    /* 176 */ "Trace"            OpHelp(""),
+    /* 177 */ "CursorHint"       OpHelp(""),
+    /* 178 */ "ReleaseReg"       OpHelp("release r[P1@P2] mask P3"),
+    /* 179 */ "Noop"             OpHelp(""),
+    /* 180 */ "Explain"          OpHelp(""),
+    /* 181 */ "Abortable"        OpHelp(""),
   };
   return azName[i];
 }
@@ -33734,205 +34532,7 @@ static pid_t randomnessPid = 0;
 /*
 ** Include code that is common to all os_*.c files
 */
-/************** Include os_common.h in the middle of os_unix.c ***************/
-/************** Begin file os_common.h ***************************************/
-/*
-** 2004 May 22
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains macros and a little bit of code that is common to
-** all of the platform-specific files (os_*.c) and is #included into those
-** files.
-**
-** This file should be #included by the os_*.c files only.  It is not a
-** general purpose header file.
-*/
-#ifndef _OS_COMMON_H_
-#define _OS_COMMON_H_
-
-/*
-** At least two bugs have slipped in because we changed the MEMORY_DEBUG
-** macro to SQLITE_DEBUG and some older makefiles have not yet made the
-** switch.  The following code should catch this problem at compile-time.
-*/
-#ifdef MEMORY_DEBUG
-# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."
-#endif
-
-/*
-** Macros for performance tracing.  Normally turned off.  Only works
-** on i486 hardware.
-*/
-#ifdef SQLITE_PERFORMANCE_TRACE
-
-/*
-** hwtime.h contains inline assembler code for implementing
-** high-performance timing routines.
-*/
-/************** Include hwtime.h in the middle of os_common.h ****************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 27
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-/*
-** The following routine only works on pentium-class (or newer) processors.
-** It uses the RDTSC opcode to read the cycle count value out of the
-** processor and returns that value.  This can be used for high-res
-** profiling.
-*/
-#if !defined(__STRICT_ANSI__) && \
-    (defined(__GNUC__) || defined(_MSC_VER)) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  #if defined(__GNUC__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-  #elif defined(_MSC_VER)
-
-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
-     __asm {
-        rdtsc
-        ret       ; return value at EDX:EAX
-     }
-  }
-
-  #endif
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long val;
-      __asm__ __volatile__ ("rdtsc" : "=A" (val));
-      return val;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in os_common.h ******************/
-
-static sqlite_uint64 g_start;
-static sqlite_uint64 g_elapsed;
-#define TIMER_START       g_start=sqlite3Hwtime()
-#define TIMER_END         g_elapsed=sqlite3Hwtime()-g_start
-#define TIMER_ELAPSED     g_elapsed
-#else
-#define TIMER_START
-#define TIMER_END
-#define TIMER_ELAPSED     ((sqlite_uint64)0)
-#endif
-
-/*
-** If we compile with the SQLITE_TEST macro set, then the following block
-** of code will give us the ability to simulate a disk I/O error.  This
-** is used for testing the I/O recovery logic.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_io_error_hit;
-SQLITE_API extern int sqlite3_io_error_hardhit;
-SQLITE_API extern int sqlite3_io_error_pending;
-SQLITE_API extern int sqlite3_io_error_persist;
-SQLITE_API extern int sqlite3_io_error_benign;
-SQLITE_API extern int sqlite3_diskfull_pending;
-SQLITE_API extern int sqlite3_diskfull;
-#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
-#define SimulateIOError(CODE)  \
-  if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
-       || sqlite3_io_error_pending-- == 1 )  \
-              { local_ioerr(); CODE; }
-static void local_ioerr(){
-  IOTRACE(("IOERR\n"));
-  sqlite3_io_error_hit++;
-  if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
-}
-#define SimulateDiskfullError(CODE) \
-   if( sqlite3_diskfull_pending ){ \
-     if( sqlite3_diskfull_pending == 1 ){ \
-       local_ioerr(); \
-       sqlite3_diskfull = 1; \
-       sqlite3_io_error_hit = 1; \
-       CODE; \
-     }else{ \
-       sqlite3_diskfull_pending--; \
-     } \
-   }
-#else
-#define SimulateIOErrorBenign(X)
-#define SimulateIOError(A)
-#define SimulateDiskfullError(A)
-#endif /* defined(SQLITE_TEST) */
-
-/*
-** When testing, keep a count of the number of open files.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_open_file_count;
-#define OpenCounter(X)  sqlite3_open_file_count+=(X)
-#else
-#define OpenCounter(X)
-#endif /* defined(SQLITE_TEST) */
-
-#endif /* !defined(_OS_COMMON_H_) */
-
-/************** End of os_common.h *******************************************/
-/************** Continuing where we left off in os_unix.c ********************/
+/* #include "os_common.h" */
 
 /*
 ** Define various macros that are missing from some systems.
@@ -37586,6 +38186,9 @@ static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
 
 /* Forward declaration */
 static int unixGetTempname(int nBuf, char *zBuf);
+#ifndef SQLITE_OMIT_WAL
+ static int unixFcntlExternalReader(unixFile*, int*);
+#endif
 
 /*
 ** Information and control of an open file handle.
@@ -37702,6 +38305,15 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){
       return proxyFileControl(id,op,pArg);
     }
 #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
+
+    case SQLITE_FCNTL_EXTERNAL_READER: {
+#ifndef SQLITE_OMIT_WAL
+      return unixFcntlExternalReader((unixFile*)id, (int*)pArg);
+#else
+      *(int*)pArg = 0;
+      return SQLITE_OK;
+#endif
+    }
   }
   return SQLITE_NOTFOUND;
 }
@@ -37947,6 +38559,40 @@ struct unixShm {
 #define UNIX_SHM_BASE   ((22+SQLITE_SHM_NLOCK)*4)         /* first lock byte */
 #define UNIX_SHM_DMS    (UNIX_SHM_BASE+SQLITE_SHM_NLOCK)  /* deadman switch */
 
+/*
+** Use F_GETLK to check whether or not there are any readers with open
+** wal-mode transactions in other processes on database file pFile. If
+** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are
+** such transactions, or 0 otherwise. If an error occurs, return an
+** SQLite error code. The final value of *piOut is undefined in this
+** case.
+*/
+static int unixFcntlExternalReader(unixFile *pFile, int *piOut){
+  int rc = SQLITE_OK;
+  *piOut = 0;
+  if( pFile->pShm){
+    unixShmNode *pShmNode = pFile->pShm->pShmNode;
+    struct flock f;
+
+    memset(&f, 0, sizeof(f));
+    f.l_type = F_WRLCK;
+    f.l_whence = SEEK_SET;
+    f.l_start = UNIX_SHM_BASE + 3;
+    f.l_len = SQLITE_SHM_NLOCK - 3;
+
+    sqlite3_mutex_enter(pShmNode->pShmMutex);
+    if( osFcntl(pShmNode->hShm, F_GETLK, &f)<0 ){
+      rc = SQLITE_IOERR_LOCK;
+    }else{
+      *piOut = (f.l_type!=F_UNLCK);
+    }
+    sqlite3_mutex_leave(pShmNode->pShmMutex);
+  }
+
+  return rc;
+}
+
+
 /*
 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
 **
@@ -39387,25 +40033,35 @@ static int fillInUnixFile(
   return rc;
 }
 
+/*
+** Directories to consider for temp files.
+*/
+static const char *azTempDirs[] = {
+  0,
+  0,
+  "/var/tmp",
+  "/usr/tmp",
+  "/tmp",
+  "."
+};
+
+/*
+** Initialize first two members of azTempDirs[] array.
+*/
+static void unixTempFileInit(void){
+  azTempDirs[0] = getenv("SQLITE_TMPDIR");
+  azTempDirs[1] = getenv("TMPDIR");
+}
+
 /*
 ** Return the name of a directory in which to put temporary files.
 ** If no suitable temporary file directory can be found, return NULL.
 */
 static const char *unixTempFileDir(void){
-  static const char *azDirs[] = {
-     0,
-     0,
-     "/var/tmp",
-     "/usr/tmp",
-     "/tmp",
-     "."
-  };
   unsigned int i = 0;
   struct stat buf;
   const char *zDir = sqlite3_temp_directory;
 
-  if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR");
-  if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
   while(1){
     if( zDir!=0
      && osStat(zDir, &buf)==0
@@ -39414,8 +40070,8 @@ static const char *unixTempFileDir(void){
     ){
       return zDir;
     }
-    if( i>=sizeof(azDirs)/sizeof(azDirs[0]) ) break;
-    zDir = azDirs[i++];
+    if( i>=sizeof(azTempDirs)/sizeof(azTempDirs[0]) ) break;
+    zDir = azTempDirs[i++];
   }
   return 0;
 }
@@ -39721,6 +40377,11 @@ static int unixOpen(
   }
   memset(p, 0, sizeof(unixFile));
 
+#ifdef SQLITE_ASSERT_NO_FILES
+  /* Applications that never read or write a persistent disk files */
+  assert( zName==0 );
+#endif
+
   if( eType==SQLITE_OPEN_MAIN_DB ){
     UnixUnusedFd *pUnused;
     pUnused = findReusableFd(zName, flags);
@@ -39996,7 +40657,8 @@ static int unixBackupDir(const char *z, int *pJ){
   int j = *pJ;
   int i;
   if( j<=0 ) return 0;
-  for(i=j-1; ALWAYS(i>0) && z[i-1]!='/'; i--){}
+  for(i=j-1; i>0 && z[i-1]!='/'; i--){}
+  if( i==0 ) return 0;
   if( z[i]=='.' && i==j-2 && z[i+1]=='.' ) return 0;
   *pJ = i-1;
   return 1;
@@ -41662,6 +42324,28 @@ SQLITE_API int sqlite3_os_init(void){
     sqlite3_vfs_register(&aVfs[i], i==0);
   }
   unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
+
+#ifndef SQLITE_OMIT_WAL
+  /* Validate lock assumptions */
+  assert( SQLITE_SHM_NLOCK==8 );  /* Number of available locks */
+  assert( UNIX_SHM_BASE==120  );  /* Start of locking area */
+  /* Locks:
+  **    WRITE       UNIX_SHM_BASE      120
+  **    CKPT        UNIX_SHM_BASE+1    121
+  **    RECOVER     UNIX_SHM_BASE+2    122
+  **    READ-0      UNIX_SHM_BASE+3    123
+  **    READ-1      UNIX_SHM_BASE+4    124
+  **    READ-2      UNIX_SHM_BASE+5    125
+  **    READ-3      UNIX_SHM_BASE+6    126
+  **    READ-4      UNIX_SHM_BASE+7    127
+  **    DMS         UNIX_SHM_BASE+8    128
+  */
+  assert( UNIX_SHM_DMS==128   );  /* Byte offset of the deadman-switch */
+#endif
+
+  /* Initialize temp file dir array. */
+  unixTempFileInit();
+
   return SQLITE_OK;
 }
 
@@ -41701,205 +42385,7 @@ SQLITE_API int sqlite3_os_end(void){
 /*
 ** Include code that is common to all os_*.c files
 */
-/************** Include os_common.h in the middle of os_win.c ****************/
-/************** Begin file os_common.h ***************************************/
-/*
-** 2004 May 22
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains macros and a little bit of code that is common to
-** all of the platform-specific files (os_*.c) and is #included into those
-** files.
-**
-** This file should be #included by the os_*.c files only.  It is not a
-** general purpose header file.
-*/
-#ifndef _OS_COMMON_H_
-#define _OS_COMMON_H_
-
-/*
-** At least two bugs have slipped in because we changed the MEMORY_DEBUG
-** macro to SQLITE_DEBUG and some older makefiles have not yet made the
-** switch.  The following code should catch this problem at compile-time.
-*/
-#ifdef MEMORY_DEBUG
-# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."
-#endif
-
-/*
-** Macros for performance tracing.  Normally turned off.  Only works
-** on i486 hardware.
-*/
-#ifdef SQLITE_PERFORMANCE_TRACE
-
-/*
-** hwtime.h contains inline assembler code for implementing
-** high-performance timing routines.
-*/
-/************** Include hwtime.h in the middle of os_common.h ****************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 27
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-/*
-** The following routine only works on pentium-class (or newer) processors.
-** It uses the RDTSC opcode to read the cycle count value out of the
-** processor and returns that value.  This can be used for high-res
-** profiling.
-*/
-#if !defined(__STRICT_ANSI__) && \
-    (defined(__GNUC__) || defined(_MSC_VER)) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  #if defined(__GNUC__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-  #elif defined(_MSC_VER)
-
-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
-     __asm {
-        rdtsc
-        ret       ; return value at EDX:EAX
-     }
-  }
-
-  #endif
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long val;
-      __asm__ __volatile__ ("rdtsc" : "=A" (val));
-      return val;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in os_common.h ******************/
-
-static sqlite_uint64 g_start;
-static sqlite_uint64 g_elapsed;
-#define TIMER_START       g_start=sqlite3Hwtime()
-#define TIMER_END         g_elapsed=sqlite3Hwtime()-g_start
-#define TIMER_ELAPSED     g_elapsed
-#else
-#define TIMER_START
-#define TIMER_END
-#define TIMER_ELAPSED     ((sqlite_uint64)0)
-#endif
-
-/*
-** If we compile with the SQLITE_TEST macro set, then the following block
-** of code will give us the ability to simulate a disk I/O error.  This
-** is used for testing the I/O recovery logic.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_io_error_hit;
-SQLITE_API extern int sqlite3_io_error_hardhit;
-SQLITE_API extern int sqlite3_io_error_pending;
-SQLITE_API extern int sqlite3_io_error_persist;
-SQLITE_API extern int sqlite3_io_error_benign;
-SQLITE_API extern int sqlite3_diskfull_pending;
-SQLITE_API extern int sqlite3_diskfull;
-#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
-#define SimulateIOError(CODE)  \
-  if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
-       || sqlite3_io_error_pending-- == 1 )  \
-              { local_ioerr(); CODE; }
-static void local_ioerr(){
-  IOTRACE(("IOERR\n"));
-  sqlite3_io_error_hit++;
-  if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
-}
-#define SimulateDiskfullError(CODE) \
-   if( sqlite3_diskfull_pending ){ \
-     if( sqlite3_diskfull_pending == 1 ){ \
-       local_ioerr(); \
-       sqlite3_diskfull = 1; \
-       sqlite3_io_error_hit = 1; \
-       CODE; \
-     }else{ \
-       sqlite3_diskfull_pending--; \
-     } \
-   }
-#else
-#define SimulateIOErrorBenign(X)
-#define SimulateIOError(A)
-#define SimulateDiskfullError(A)
-#endif /* defined(SQLITE_TEST) */
-
-/*
-** When testing, keep a count of the number of open files.
-*/
-#if defined(SQLITE_TEST)
-SQLITE_API extern int sqlite3_open_file_count;
-#define OpenCounter(X)  sqlite3_open_file_count+=(X)
-#else
-#define OpenCounter(X)
-#endif /* defined(SQLITE_TEST) */
-
-#endif /* !defined(_OS_COMMON_H_) */
-
-/************** End of os_common.h *******************************************/
-/************** Continuing where we left off in os_win.c *********************/
+/* #include "os_common.h" */
 
 /*
 ** Include the header file for the Windows VFS.
@@ -48055,31 +48541,88 @@ SQLITE_API int sqlite3_os_end(void){
 ** sqlite3_deserialize().
 */
 /* #include "sqliteInt.h" */
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
 
 /*
 ** Forward declaration of objects used by this utility
 */
 typedef struct sqlite3_vfs MemVfs;
 typedef struct MemFile MemFile;
+typedef struct MemStore MemStore;
 
 /* Access to a lower-level VFS that (might) implement dynamic loading,
 ** access to randomness, etc.
 */
 #define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
 
-/* An open file */
-struct MemFile {
-  sqlite3_file base;              /* IO methods */
+/* Storage for a memdb file.
+**
+** An memdb object can be shared or separate.  Shared memdb objects can be
+** used by more than one database connection.  Mutexes are used by shared
+** memdb objects to coordinate access.  Separate memdb objects are only
+** connected to a single database connection and do not require additional
+** mutexes.
+**
+** Shared memdb objects have .zFName!=0 and .pMutex!=0.  They are created
+** using "file:/name?vfs=memdb".  The first character of the name must be
+** "/" or else the object will be a separate memdb object.  All shared
+** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order.
+**
+** Separate memdb objects are created using a name that does not begin
+** with "/" or using sqlite3_deserialize().
+**
+** Access rules for shared MemStore objects:
+**
+**   *  .zFName is initialized when the object is created and afterwards
+**      is unchanged until the object is destroyed.  So it can be accessed
+**      at any time as long as we know the object is not being destroyed,
+**      which means while either the SQLITE_MUTEX_STATIC_VFS1 or
+**      .pMutex is held or the object is not part of memdb_g.apMemStore[].
+**
+**   *  Can .pMutex can only be changed while holding the
+**      SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part
+**      of memdb_g.apMemStore[].
+**
+**   *  Other fields can only be changed while holding the .pMutex mutex
+**      or when the .nRef is less than zero and the object is not part of
+**      memdb_g.apMemStore[].
+**
+**   *  The .aData pointer has the added requirement that it can can only
+**      be changed (for resizing) when nMmap is zero.
+**
+*/
+struct MemStore {
   sqlite3_int64 sz;               /* Size of the file */
   sqlite3_int64 szAlloc;          /* Space allocated to aData */
   sqlite3_int64 szMax;            /* Maximum allowed size of the file */
   unsigned char *aData;           /* content of the file */
+  sqlite3_mutex *pMutex;          /* Used by shared stores only */
   int nMmap;                      /* Number of memory mapped pages */
   unsigned mFlags;                /* Flags */
+  int nRdLock;                    /* Number of readers */
+  int nWrLock;                    /* Number of writers.  (Always 0 or 1) */
+  int nRef;                       /* Number of users of this MemStore */
+  char *zFName;                   /* The filename for shared stores */
+};
+
+/* An open file */
+struct MemFile {
+  sqlite3_file base;              /* IO methods */
+  MemStore *pStore;               /* The storage */
   int eLock;                      /* Most recent lock against this file */
 };
 
+/*
+** File-scope variables for holding the memdb files that are accessible
+** to multiple database connections in separate threads.
+**
+** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
+*/
+static struct MemFS {
+  int nMemStore;                  /* Number of shared MemStore objects */
+  MemStore **apMemStore;          /* Array of all shared MemStore objects */
+} memdb_g;
+
 /*
 ** Methods for MemFile
 */
@@ -48133,7 +48676,10 @@ static sqlite3_vfs memdb_vfs = {
   memdbSleep,                  /* xSleep */
   0, /* memdbCurrentTime, */   /* xCurrentTime */
   memdbGetLastError,           /* xGetLastError */
-  memdbCurrentTimeInt64        /* xCurrentTimeInt64 */
+  memdbCurrentTimeInt64,       /* xCurrentTimeInt64 */
+  0,                           /* xSetSystemCall */
+  0,                           /* xGetSystemCall */
+  0,                           /* xNextSystemCall */
 };
 
 static const sqlite3_io_methods memdb_io_methods = {
@@ -48158,19 +48704,67 @@ static const sqlite3_io_methods memdb_io_methods = {
   memdbUnfetch                     /* xUnfetch */
 };
 
+/*
+** Enter/leave the mutex on a MemStore
+*/
+#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
+static void memdbEnter(MemStore *p){
+  UNUSED_PARAMETER(p);
+}
+static void memdbLeave(MemStore *p){
+  UNUSED_PARAMETER(p);
+}
+#else
+static void memdbEnter(MemStore *p){
+  sqlite3_mutex_enter(p->pMutex);
+}
+static void memdbLeave(MemStore *p){
+  sqlite3_mutex_leave(p->pMutex);
+}
+#endif
+
 
 
 /*
 ** Close an memdb-file.
-**
-** The pData pointer is owned by the application, so there is nothing
-** to free.  Unless the SQLITE_DESERIALIZE_FREEONCLOSE flag is set,
-** in which case we own the pData pointer and need to free it.
+** Free the underlying MemStore object when its refcount drops to zero
+** or less.
 */
 static int memdbClose(sqlite3_file *pFile){
-  MemFile *p = (MemFile *)pFile;
-  if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){
-    sqlite3_free(p->aData);
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  if( p->zFName ){
+    int i;
+#ifndef SQLITE_MUTEX_OMIT
+    sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
+#endif
+    sqlite3_mutex_enter(pVfsMutex);
+    for(i=0; ALWAYS(i<memdb_g.nMemStore); i++){
+      if( memdb_g.apMemStore[i]==p ){
+        memdbEnter(p);
+        if( p->nRef==1 ){
+          memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore];
+          if( memdb_g.nMemStore==0 ){
+            sqlite3_free(memdb_g.apMemStore);
+            memdb_g.apMemStore = 0;
+          }
+        }
+        break;
+      }
+    }
+    sqlite3_mutex_leave(pVfsMutex);
+  }else{
+    memdbEnter(p);
+  }
+  p->nRef--;
+  if( p->nRef<=0 ){
+    if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){
+      sqlite3_free(p->aData);
+    }
+    memdbLeave(p);
+    sqlite3_mutex_free(p->pMutex);
+    sqlite3_free(p);
+  }else{
+    memdbLeave(p);
   }
   return SQLITE_OK;
 }
@@ -48184,22 +48778,25 @@ static int memdbRead(
   int iAmt,
   sqlite_int64 iOfst
 ){
-  MemFile *p = (MemFile *)pFile;
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  memdbEnter(p);
   if( iOfst+iAmt>p->sz ){
     memset(zBuf, 0, iAmt);
     if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
+    memdbLeave(p);
     return SQLITE_IOERR_SHORT_READ;
   }
   memcpy(zBuf, p->aData+iOfst, iAmt);
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
 /*
 ** Try to enlarge the memory allocation to hold at least sz bytes
 */
-static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){
+static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){
   unsigned char *pNew;
-  if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || p->nMmap>0 ){
+  if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){
     return SQLITE_FULL;
   }
   if( newSz>p->szMax ){
@@ -48208,7 +48805,7 @@ static int memdbEnlarge(MemFile *p, sqlite3_int64 newSz){
   newSz *= 2;
   if( newSz>p->szMax ) newSz = p->szMax;
   pNew = sqlite3Realloc(p->aData, newSz);
-  if( pNew==0 ) return SQLITE_NOMEM;
+  if( pNew==0 ) return SQLITE_IOERR_NOMEM;
   p->aData = pNew;
   p->szAlloc = newSz;
   return SQLITE_OK;
@@ -48223,19 +48820,27 @@ static int memdbWrite(
   int iAmt,
   sqlite_int64 iOfst
 ){
-  MemFile *p = (MemFile *)pFile;
-  if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ) return SQLITE_READONLY;
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  memdbEnter(p);
+  if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
+    /* Can't happen: memdbLock() will return SQLITE_READONLY before
+    ** reaching this point */
+    memdbLeave(p);
+    return SQLITE_IOERR_WRITE;
+  }
   if( iOfst+iAmt>p->sz ){
     int rc;
     if( iOfst+iAmt>p->szAlloc
      && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
     ){
+      memdbLeave(p);
       return rc;
     }
     if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
     p->sz = iOfst+iAmt;
   }
   memcpy(p->aData+iOfst, z, iAmt);
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
@@ -48247,16 +48852,25 @@ static int memdbWrite(
 ** the size of a file, never to increase the size.
 */
 static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
-  MemFile *p = (MemFile *)pFile;
-  if( NEVER(size>p->sz) ) return SQLITE_FULL;
-  p->sz = size;
-  return SQLITE_OK;
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  int rc = SQLITE_OK;
+  memdbEnter(p);
+  if( size>p->sz ){
+    /* This can only happen with a corrupt wal mode db */
+    rc = SQLITE_CORRUPT;
+  }else{
+    p->sz = size;
+  }
+  memdbLeave(p);
+  return rc;
 }
 
 /*
 ** Sync an memdb-file.
 */
 static int memdbSync(sqlite3_file *pFile, int flags){
+  UNUSED_PARAMETER(pFile);
+  UNUSED_PARAMETER(flags);
   return SQLITE_OK;
 }
 
@@ -48264,8 +48878,10 @@ static int memdbSync(sqlite3_file *pFile, int flags){
 ** Return the current file-size of an memdb-file.
 */
 static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
-  MemFile *p = (MemFile *)pFile;
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  memdbEnter(p);
   *pSize = p->sz;
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
@@ -48273,19 +48889,48 @@ static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
 ** Lock an memdb-file.
 */
 static int memdbLock(sqlite3_file *pFile, int eLock){
-  MemFile *p = (MemFile *)pFile;
-  if( eLock>SQLITE_LOCK_SHARED
-   && (p->mFlags & SQLITE_DESERIALIZE_READONLY)!=0
-  ){
-    return SQLITE_READONLY;
+  MemFile *pThis = (MemFile*)pFile;
+  MemStore *p = pThis->pStore;
+  int rc = SQLITE_OK;
+  if( eLock==pThis->eLock ) return SQLITE_OK;
+  memdbEnter(p);
+  if( eLock>SQLITE_LOCK_SHARED ){
+    if( p->mFlags & SQLITE_DESERIALIZE_READONLY ){
+      rc = SQLITE_READONLY;
+    }else if( pThis->eLock<=SQLITE_LOCK_SHARED ){
+      if( p->nWrLock ){
+        rc = SQLITE_BUSY;
+      }else{
+        p->nWrLock = 1;
+      }
+    }
+  }else if( eLock==SQLITE_LOCK_SHARED ){
+    if( pThis->eLock > SQLITE_LOCK_SHARED ){
+      assert( p->nWrLock==1 );
+      p->nWrLock = 0;
+    }else if( p->nWrLock ){
+      rc = SQLITE_BUSY;
+    }else{
+      p->nRdLock++;
+    }
+  }else{
+    assert( eLock==SQLITE_LOCK_NONE );
+    if( pThis->eLock>SQLITE_LOCK_SHARED ){
+      assert( p->nWrLock==1 );
+      p->nWrLock = 0;
+    }
+    assert( p->nRdLock>0 );
+    p->nRdLock--;
   }
-  p->eLock = eLock;
-  return SQLITE_OK;
+  if( rc==SQLITE_OK ) pThis->eLock = eLock;
+  memdbLeave(p);
+  return rc;
 }
 
-#if 0 /* Never used because memdbAccess() always returns false */
+#if 0
 /*
-** Check if another file-handle holds a RESERVED lock on an memdb-file.
+** This interface is only used for crash recovery, which does not
+** occur on an in-memory database.
 */
 static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
   *pResOut = 0;
@@ -48293,12 +48938,14 @@ static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
 }
 #endif
 
+
 /*
 ** File control method. For custom operations on an memdb-file.
 */
 static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
-  MemFile *p = (MemFile *)pFile;
+  MemStore *p = ((MemFile*)pFile)->pStore;
   int rc = SQLITE_NOTFOUND;
+  memdbEnter(p);
   if( op==SQLITE_FCNTL_VFSNAME ){
     *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
     rc = SQLITE_OK;
@@ -48316,6 +48963,7 @@ static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
     *(sqlite3_int64*)pArg = iLimit;
     rc = SQLITE_OK;
   }
+  memdbLeave(p);
   return rc;
 }
 
@@ -48332,6 +48980,7 @@ static int memdbSectorSize(sqlite3_file *pFile){
 ** Return the device characteristic flags supported by an memdb-file.
 */
 static int memdbDeviceCharacteristics(sqlite3_file *pFile){
+  UNUSED_PARAMETER(pFile);
   return SQLITE_IOCAP_ATOMIC |
          SQLITE_IOCAP_POWERSAFE_OVERWRITE |
          SQLITE_IOCAP_SAFE_APPEND |
@@ -48345,20 +48994,26 @@ static int memdbFetch(
   int iAmt,
   void **pp
 ){
-  MemFile *p = (MemFile *)pFile;
-  if( iOfst+iAmt>p->sz ){
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  memdbEnter(p);
+  if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){
     *pp = 0;
   }else{
     p->nMmap++;
     *pp = (void*)(p->aData + iOfst);
   }
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
 /* Release a memory-mapped page */
 static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
-  MemFile *p = (MemFile *)pFile;
+  MemStore *p = ((MemFile*)pFile)->pStore;
+  UNUSED_PARAMETER(iOfst);
+  UNUSED_PARAMETER(pPage);
+  memdbEnter(p);
   p->nMmap--;
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
@@ -48368,20 +49023,79 @@ static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
 static int memdbOpen(
   sqlite3_vfs *pVfs,
   const char *zName,
-  sqlite3_file *pFile,
+  sqlite3_file *pFd,
   int flags,
   int *pOutFlags
 ){
-  MemFile *p = (MemFile*)pFile;
-  if( (flags & SQLITE_OPEN_MAIN_DB)==0 ){
-    return ORIGVFS(pVfs)->xOpen(ORIGVFS(pVfs), zName, pFile, flags, pOutFlags);
+  MemFile *pFile = (MemFile*)pFd;
+  MemStore *p = 0;
+  int szName;
+  UNUSED_PARAMETER(pVfs);
+
+  memset(pFile, 0, sizeof(*pFile));
+  szName = sqlite3Strlen30(zName);
+  if( szName>1 && zName[0]=='/' ){
+    int i;
+#ifndef SQLITE_MUTEX_OMIT
+    sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
+#endif
+    sqlite3_mutex_enter(pVfsMutex);
+    for(i=0; i<memdb_g.nMemStore; i++){
+      if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
+        p = memdb_g.apMemStore[i];
+        break;
+      }
+    }
+    if( p==0 ){
+      MemStore **apNew;
+      p = sqlite3Malloc( sizeof(*p) + szName + 3 );
+      if( p==0 ){
+        sqlite3_mutex_leave(pVfsMutex);
+        return SQLITE_NOMEM;
+      }
+      apNew = sqlite3Realloc(memdb_g.apMemStore,
+                             sizeof(apNew[0])*(memdb_g.nMemStore+1) );
+      if( apNew==0 ){
+        sqlite3_free(p);
+        sqlite3_mutex_leave(pVfsMutex);
+        return SQLITE_NOMEM;
+      }
+      apNew[memdb_g.nMemStore++] = p;
+      memdb_g.apMemStore = apNew;
+      memset(p, 0, sizeof(*p));
+      p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE;
+      p->szMax = sqlite3GlobalConfig.mxMemdbSize;
+      p->zFName = (char*)&p[1];
+      memcpy(p->zFName, zName, szName+1);
+      p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
+      if( p->pMutex==0 ){
+        memdb_g.nMemStore--;
+        sqlite3_free(p);
+        sqlite3_mutex_leave(pVfsMutex);
+        return SQLITE_NOMEM;
+      }
+      p->nRef = 1;
+      memdbEnter(p);
+    }else{
+      memdbEnter(p);
+      p->nRef++;
+    }
+    sqlite3_mutex_leave(pVfsMutex);
+  }else{
+    p = sqlite3Malloc( sizeof(*p) );
+    if( p==0 ){
+      return SQLITE_NOMEM;
+    }
+    memset(p, 0, sizeof(*p));
+    p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
+    p->szMax = sqlite3GlobalConfig.mxMemdbSize;
   }
-  memset(p, 0, sizeof(*p));
-  p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
-  assert( pOutFlags!=0 );  /* True because flags==SQLITE_OPEN_MAIN_DB */
-  *pOutFlags = flags | SQLITE_OPEN_MEMORY;
-  pFile->pMethods = &memdb_io_methods;
-  p->szMax = sqlite3GlobalConfig.mxMemdbSize;
+  pFile->pStore = p;
+  if( pOutFlags!=0 ){
+    *pOutFlags = flags | SQLITE_OPEN_MEMORY;
+  }
+  pFd->pMethods = &memdb_io_methods;
+  memdbLeave(p);
   return SQLITE_OK;
 }
 
@@ -48409,6 +49123,9 @@ static int memdbAccess(
   int flags,
   int *pResOut
 ){
+  UNUSED_PARAMETER(pVfs);
+  UNUSED_PARAMETER(zPath);
+  UNUSED_PARAMETER(flags);
   *pResOut = 0;
   return SQLITE_OK;
 }
@@ -48424,6 +49141,7 @@ static int memdbFullPathname(
   int nOut,
   char *zOut
 ){
+  UNUSED_PARAMETER(pVfs);
   sqlite3_snprintf(nOut, zOut, "%s", zPath);
   return SQLITE_OK;
 }
@@ -48496,9 +49214,14 @@ static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
 */
 static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){
   MemFile *p = 0;
+  MemStore *pStore;
   int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p);
   if( rc ) return 0;
   if( p->base.pMethods!=&memdb_io_methods ) return 0;
+  pStore = p->pStore;
+  memdbEnter(pStore);
+  if( pStore->zFName!=0 ) p = 0;
+  memdbLeave(pStore);
   return p;
 }
 
@@ -48534,12 +49257,14 @@ SQLITE_API unsigned char *sqlite3_serialize(
   if( piSize ) *piSize = -1;
   if( iDb<0 ) return 0;
   if( p ){
-    if( piSize ) *piSize = p->sz;
+    MemStore *pStore = p->pStore;
+    assert( pStore->pMutex==0 );
+    if( piSize ) *piSize = pStore->sz;
     if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
-      pOut = p->aData;
+      pOut = pStore->aData;
     }else{
-      pOut = sqlite3_malloc64( p->sz );
-      if( pOut ) memcpy(pOut, p->aData, p->sz);
+      pOut = sqlite3_malloc64( pStore->sz );
+      if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
     }
     return pOut;
   }
@@ -48609,7 +49334,8 @@ SQLITE_API int sqlite3_deserialize(
   sqlite3_mutex_enter(db->mutex);
   if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
   iDb = sqlite3FindDbName(db, zSchema);
-  if( iDb<0 ){
+  testcase( iDb==1 );
+  if( iDb<2 && iDb!=0 ){
     rc = SQLITE_ERROR;
     goto end_deserialize;
   }
@@ -48633,15 +49359,16 @@ SQLITE_API int sqlite3_deserialize(
   if( p==0 ){
     rc = SQLITE_ERROR;
   }else{
-    p->aData = pData;
+    MemStore *pStore = p->pStore;
+    pStore->aData = pData;
     pData = 0;
-    p->sz = szDb;
-    p->szAlloc = szBuf;
-    p->szMax = szBuf;
-    if( p->szMax<sqlite3GlobalConfig.mxMemdbSize ){
-      p->szMax = sqlite3GlobalConfig.mxMemdbSize;
+    pStore->sz = szDb;
+    pStore->szAlloc = szBuf;
+    pStore->szMax = szBuf;
+    if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
+      pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
     }
-    p->mFlags = mFlags;
+    pStore->mFlags = mFlags;
     rc = SQLITE_OK;
   }
 
@@ -48660,7 +49387,9 @@ SQLITE_API int sqlite3_deserialize(
 */
 SQLITE_PRIVATE int sqlite3MemdbInit(void){
   sqlite3_vfs *pLower = sqlite3_vfs_find(0);
-  int sz = pLower->szOsFile;
+  unsigned int sz;
+  if( NEVER(pLower==0) ) return SQLITE_ERROR;
+  sz = pLower->szOsFile;
   memdb_vfs.pAppData = pLower;
   /* The following conditional can only be true when compiled for
   ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0.  We always leave
@@ -48670,7 +49399,7 @@ SQLITE_PRIVATE int sqlite3MemdbInit(void){
   memdb_vfs.szOsFile = sz;
   return sqlite3_vfs_register(&memdb_vfs, 0);
 }
-#endif /* SQLITE_ENABLE_DESERIALIZE */
+#endif /* SQLITE_OMIT_DESERIALIZE */
 
 /************** End of memdb.c ***********************************************/
 /************** Begin file bitvec.c ******************************************/
@@ -49029,7 +49758,7 @@ SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){
   sqlite3BitvecClear(0, 1, pTmpSpace);
 
   /* Run the program */
-  pc = 0;
+  pc = i = 0;
   while( (op = aOp[pc])!=0 ){
     switch( op ){
       case 1:
@@ -49333,11 +50062,14 @@ static int numberOfCachePages(PCache *p){
     ** suggested cache size is set to N. */
     return p->szCache;
   }else{
+    i64 n;
     /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the
     ** number of cache pages is adjusted to be a number of pages that would
     ** use approximately abs(N*1024) bytes of memory based on the current
     ** page size. */
-    return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
+    n = ((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
+    if( n>1000000000 ) n = 1000000000;
+    return (int)n;
   }
 }
 
@@ -50436,6 +51168,7 @@ static PgHdr1 *pcache1AllocPage(PCache1 *pCache, int benignMalloc){
     p->page.pExtra = &p[1];
     p->isBulkLocal = 0;
     p->isAnchor = 0;
+    p->pLruPrev = 0;           /* Initializing this saves a valgrind error */
   }
   (*pCache->pnPurgeable)++;
   return p;
@@ -50791,12 +51524,18 @@ static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
 */
 static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
   PCache1 *pCache = (PCache1 *)p;
+  u32 n;
+  assert( nMax>=0 );
   if( pCache->bPurgeable ){
     PGroup *pGroup = pCache->pGroup;
     pcache1EnterMutex(pGroup);
-    pGroup->nMaxPage += (nMax - pCache->nMax);
+    n = (u32)nMax;
+    if( n > 0x7fff0000 - pGroup->nMaxPage + pCache->nMax ){
+      n = 0x7fff0000 - pGroup->nMaxPage + pCache->nMax;
+    }
+    pGroup->nMaxPage += (n - pCache->nMax);
     pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
-    pCache->nMax = nMax;
+    pCache->nMax = n;
     pCache->n90pct = pCache->nMax*9/10;
     pcache1EnforceMaxPage(pCache);
     pcache1LeaveMutex(pGroup);
@@ -50812,7 +51551,7 @@ static void pcache1Shrink(sqlite3_pcache *p){
   PCache1 *pCache = (PCache1*)p;
   if( pCache->bPurgeable ){
     PGroup *pGroup = pCache->pGroup;
-    int savedMaxPage;
+    unsigned int savedMaxPage;
     pcache1EnterMutex(pGroup);
     savedMaxPage = pGroup->nMaxPage;
     pGroup->nMaxPage = 0;
@@ -52354,6 +53093,7 @@ struct PagerSavepoint {
   Bitvec *pInSavepoint;        /* Set of pages in this savepoint */
   Pgno nOrig;                  /* Original number of pages in file */
   Pgno iSubRec;                /* Index of first record in sub-journal */
+  int bTruncateOnRelease;      /* If stmt journal may be truncated on RELEASE */
 #ifndef SQLITE_OMIT_WAL
   u32 aWalData[WAL_SAVEPOINT_NDATA];        /* WAL savepoint context */
 #endif
@@ -52548,6 +53288,7 @@ struct Pager {
   u8 noLock;                  /* Do not lock (except in WAL mode) */
   u8 readOnly;                /* True for a read-only database */
   u8 memDb;                   /* True to inhibit all file I/O */
+  u8 memVfs;                  /* VFS-implemented memory database */
 
   /**************************************************************************
   ** The following block contains those class members that change during
@@ -52597,8 +53338,8 @@ struct Pager {
   i16 nReserve;               /* Number of unused bytes at end of each page */
   u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */
   u32 sectorSize;             /* Assumed sector size during rollback */
-  int pageSize;               /* Number of bytes in a page */
   Pgno mxPgno;                /* Maximum allowed size of the database */
+  i64 pageSize;               /* Number of bytes in a page */
   i64 journalSizeLimit;       /* Size limit for persistent journal files */
   char *zFilename;            /* Name of the database file */
   char *zJournal;             /* Name of the journal file */
@@ -52989,6 +53730,9 @@ static int subjRequiresPage(PgHdr *pPg){
   for(i=0; i<pPager->nSavepoint; i++){
     p = &pPager->aSavepoint[i];
     if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
+      for(i=i+1; i<pPager->nSavepoint; i++){
+        pPager->aSavepoint[i].bTruncateOnRelease = 0;
+      }
       return 1;
     }
   }
@@ -54939,6 +55683,7 @@ static int readDbPage(PgHdr *pPg){
 */
 static void pager_write_changecounter(PgHdr *pPg){
   u32 change_counter;
+  if( NEVER(pPg==0) ) return;
 
   /* Increment the value just read and write it back to byte 24. */
   change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
@@ -55851,7 +56596,8 @@ static void assertTruncateConstraint(Pager *pPager){
 ** then continue writing to the database.
 */
 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
-  assert( pPager->dbSize>=nPage );
+  assert( pPager->dbSize>=nPage || CORRUPT_DB );
+  testcase( pPager->dbSize<nPage );
   assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
   pPager->dbSize = nPage;
 
@@ -56579,7 +57325,7 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
   int rc = SQLITE_OK;      /* Return code */
   int tempFile = 0;        /* True for temp files (incl. in-memory files) */
   int memDb = 0;           /* True if this is an in-memory file */
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
   int memJM = 0;           /* Memory journal mode */
 #else
 # define memJM 0
@@ -56772,6 +57518,7 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
     pPager->zWal = 0;
   }
 #endif
+  (void)pPtr;  /* Suppress warning about unused pPtr value */
 
   if( nPathname ) sqlite3DbFree(0, zPathname);
   pPager->pVfs = pVfs;
@@ -56783,8 +57530,8 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
     int fout = 0;                    /* VFS flags returned by xOpen() */
     rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
     assert( !memDb );
-#ifdef SQLITE_ENABLE_DESERIALIZE
-    memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
+#ifndef SQLITE_OMIT_DESERIALIZE
+    pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
 #endif
     readOnly = (fout&SQLITE_OPEN_READONLY)!=0;
 
@@ -57751,7 +58498,7 @@ SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory
   assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
   pPager->subjInMemory = (u8)subjInMemory;
 
-  if( ALWAYS(pPager->eState==PAGER_READER) ){
+  if( pPager->eState==PAGER_READER ){
     assert( pPager->pInJournal==0 );
 
     if( pagerUseWal(pPager) ){
@@ -58651,8 +59398,8 @@ SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
 ** used by the pager and its associated cache.
 */
 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
-  int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
-                                     + 5*sizeof(void*);
+  int perPageSize = pPager->pageSize + pPager->nExtra
+    + (int)(sizeof(PgHdr) + 5*sizeof(void*));
   return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
            + sqlite3MallocSize(pPager)
            + pPager->pageSize;
@@ -58721,7 +59468,7 @@ SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, i
 ** Return true if this is an in-memory or temp-file backed pager.
 */
 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
-  return pPager->tempFile;
+  return pPager->tempFile || pPager->memVfs;
 }
 
 /*
@@ -58767,6 +59514,7 @@ static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
     }
     aNew[ii].iSubRec = pPager->nSubRec;
     aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
+    aNew[ii].bTruncateOnRelease = 1;
     if( !aNew[ii].pInSavepoint ){
       return SQLITE_NOMEM_BKPT;
     }
@@ -58845,16 +59593,18 @@ SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
     }
     pPager->nSavepoint = nNew;
 
-    /* If this is a release of the outermost savepoint, truncate
-    ** the sub-journal to zero bytes in size. */
+    /* Truncate the sub-journal so that it only includes the parts
+    ** that are still in use. */
     if( op==SAVEPOINT_RELEASE ){
-      if( nNew==0 && isOpen(pPager->sjfd) ){
+      PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
+      if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){
         /* Only truncate if it is an in-memory sub-journal. */
         if( sqlite3JournalIsInMemory(pPager->sjfd) ){
-          rc = sqlite3OsTruncate(pPager->sjfd, 0);
+          i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec;
+          rc = sqlite3OsTruncate(pPager->sjfd, sz);
           assert( rc==SQLITE_OK );
         }
-        pPager->nSubRec = 0;
+        pPager->nSubRec = pRel->iSubRec;
       }
     }
     /* Else this is a rollback operation, playback the specified savepoint.
@@ -59038,7 +59788,7 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i
   pPgOld = sqlite3PagerLookup(pPager, pgno);
   assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
   if( pPgOld ){
-    if( pPgOld->nRef>1 ){
+    if( NEVER(pPgOld->nRef>1) ){
       sqlite3PagerUnrefNotNull(pPgOld);
       return SQLITE_CORRUPT_BKPT;
     }
@@ -59784,7 +60534,10 @@ SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){
 ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and
 ** HASHTABLE_NPAGE are selected so that together the wal-index header and
 ** first index block are the same size as all other index blocks in the
-** wal-index.
+** wal-index.  The values are:
+**
+**   HASHTABLE_NPAGE      4096
+**   HASHTABLE_NPAGE_ONE  4062
 **
 ** Each index block contains two sections, a page-mapping that contains the
 ** database page number associated with each wal frame, and a hash-table
@@ -60020,6 +60773,70 @@ struct WalCkptInfo {
 };
 #define READMARK_NOT_USED  0xffffffff
 
+/*
+** This is a schematic view of the complete 136-byte header of the
+** wal-index file (also known as the -shm file):
+**
+**      +-----------------------------+
+**   0: | iVersion                    | \
+**      +-----------------------------+  |
+**   4: | (unused padding)            |  |
+**      +-----------------------------+  |
+**   8: | iChange                     |  |
+**      +-------+-------+-------------+  |
+**  12: | bInit |  bBig |   szPage    |  |
+**      +-------+-------+-------------+  |
+**  16: | mxFrame                     |  |  First copy of the
+**      +-----------------------------+  |  WalIndexHdr object
+**  20: | nPage                       |  |
+**      +-----------------------------+  |
+**  24: | aFrameCksum                 |  |
+**      |                             |  |
+**      +-----------------------------+  |
+**  32: | aSalt                       |  |
+**      |                             |  |
+**      +-----------------------------+  |
+**  40: | aCksum                      |  |
+**      |                             | /
+**      +-----------------------------+
+**  48: | iVersion                    | \
+**      +-----------------------------+  |
+**  52: | (unused padding)            |  |
+**      +-----------------------------+  |
+**  56: | iChange                     |  |
+**      +-------+-------+-------------+  |
+**  60: | bInit |  bBig |   szPage    |  |
+**      +-------+-------+-------------+  |  Second copy of the
+**  64: | mxFrame                     |  |  WalIndexHdr
+**      +-----------------------------+  |
+**  68: | nPage                       |  |
+**      +-----------------------------+  |
+**  72: | aFrameCksum                 |  |
+**      |                             |  |
+**      +-----------------------------+  |
+**  80: | aSalt                       |  |
+**      |                             |  |
+**      +-----------------------------+  |
+**  88: | aCksum                      |  |
+**      |                             | /
+**      +-----------------------------+
+**  96: | nBackfill                   |
+**      +-----------------------------+
+** 100: | 5 read marks                |
+**      |                             |
+**      |                             |
+**      |                             |
+**      |                             |
+**      +-------+-------+------+------+
+** 120: | Write | Ckpt  | Rcvr | Rd0  | \
+**      +-------+-------+------+------+  ) 8 lock bytes
+**      | Read1 | Read2 | Rd3  | Rd4  | /
+**      +-------+-------+------+------+
+** 128: | nBackfillAttempted          |
+**      +-----------------------------+
+** 132: | (unused padding)            |
+**      +-----------------------------+
+*/
 
 /* A block of WALINDEX_LOCK_RESERVED bytes beginning at
 ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems
@@ -60176,9 +60993,13 @@ struct WalIterator {
 ** so.  It is safe to enlarge the wal-index if pWal->writeLock is true
 ** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE.
 **
-** If this call is successful, *ppPage is set to point to the wal-index
-** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
-** then an SQLite error code is returned and *ppPage is set to 0.
+** Three possible result scenarios:
+**
+**   (1)  rc==SQLITE_OK    and *ppPage==Requested-Wal-Index-Page
+**   (2)  rc>=SQLITE_ERROR and *ppPage==NULL
+**   (3)  rc==SQLITE_OK    and *ppPage==NULL  // only if iPage==0
+**
+** Scenario (3) can only occur when pWal->writeLock is false and iPage==0
 */
 static SQLITE_NOINLINE int walIndexPageRealloc(
   Wal *pWal,               /* The WAL context */
@@ -60211,7 +61032,9 @@ static SQLITE_NOINLINE int walIndexPageRealloc(
     rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
         pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
     );
-    assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 );
+    assert( pWal->apWiData[iPage]!=0
+         || rc!=SQLITE_OK
+         || (pWal->writeLock==0 && iPage==0) );
     testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
     if( rc==SQLITE_OK ){
       if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM;
@@ -60550,8 +61373,8 @@ struct WalHashLoc {
 ** slot in the hash table is set to N, it refers to frame number
 ** (pLoc->iZero+N) in the log.
 **
-** Finally, set pLoc->aPgno so that pLoc->aPgno[1] is the page number of the
-** first frame indexed by the hash table, frame (pLoc->iZero+1).
+** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the
+** first frame indexed by the hash table, frame (pLoc->iZero).
 */
 static int walHashGet(
   Wal *pWal,                      /* WAL handle */
@@ -60563,7 +61386,7 @@ static int walHashGet(
   rc = walIndexPage(pWal, iHash, &pLoc->aPgno);
   assert( rc==SQLITE_OK || iHash>0 );
 
-  if( rc==SQLITE_OK ){
+  if( pLoc->aPgno ){
     pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE];
     if( iHash==0 ){
       pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
@@ -60571,7 +61394,8 @@ static int walHashGet(
     }else{
       pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;
     }
-    pLoc->aPgno = &pLoc->aPgno[-1];
+  }else if( NEVER(rc==SQLITE_OK) ){
+    rc = SQLITE_ERROR;
   }
   return rc;
 }
@@ -60622,7 +61446,6 @@ static void walCleanupHash(Wal *pWal){
   int iLimit = 0;                 /* Zero values greater than this */
   int nByte;                      /* Number of bytes to zero in aPgno[] */
   int i;                          /* Used to iterate through aHash[] */
-  int rc;                         /* Return code form walHashGet() */
 
   assert( pWal->writeLock );
   testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
@@ -60637,8 +61460,8 @@ static void walCleanupHash(Wal *pWal){
   */
   assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
   assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
-  rc = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
-  if( NEVER(rc) ) return; /* Defense-in-depth, in case (1) above is wrong */
+  i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
+  if( NEVER(i) ) return; /* Defense-in-depth, in case (1) above is wrong */
 
   /* Zero all hash-table entries that correspond to frame numbers greater
   ** than pWal->hdr.mxFrame.
@@ -60654,8 +61477,9 @@ static void walCleanupHash(Wal *pWal){
   /* Zero the entries in the aPgno array that correspond to frames with
   ** frame numbers greater than pWal->hdr.mxFrame.
   */
-  nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]);
-  memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte);
+  nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit]);
+  assert( nByte>=0 );
+  memset((void *)&sLoc.aPgno[iLimit], 0, nByte);
 
 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
   /* Verify that the every entry in the mapping region is still reachable
@@ -60664,11 +61488,11 @@ static void walCleanupHash(Wal *pWal){
   if( iLimit ){
     int j;           /* Loop counter */
     int iKey;        /* Hash key */
-    for(j=1; j<=iLimit; j++){
+    for(j=0; j<iLimit; j++){
       for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){
-        if( sLoc.aHash[iKey]==j ) break;
+        if( sLoc.aHash[iKey]==j+1 ) break;
       }
-      assert( sLoc.aHash[iKey]==j );
+      assert( sLoc.aHash[iKey]==j+1 );
     }
   }
 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
@@ -60700,9 +61524,9 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     ** entire hash table and aPgno[] array before proceeding.
     */
     if( idx==1 ){
-      int nByte = (int)((u8 *)&sLoc.aHash[HASHTABLE_NSLOT]
-                               - (u8 *)&sLoc.aPgno[1]);
-      memset((void*)&sLoc.aPgno[1], 0, nByte);
+      int nByte = (int)((u8*)&sLoc.aHash[HASHTABLE_NSLOT] - (u8*)sLoc.aPgno);
+      assert( nByte>=0 );
+      memset((void*)sLoc.aPgno, 0, nByte);
     }
 
     /* If the entry in aPgno[] is already set, then the previous writer
@@ -60711,9 +61535,9 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     ** Remove the remnants of that writers uncommitted transaction from
     ** the hash-table before writing any new entries.
     */
-    if( sLoc.aPgno[idx] ){
+    if( sLoc.aPgno[idx-1] ){
       walCleanupHash(pWal);
-      assert( !sLoc.aPgno[idx] );
+      assert( !sLoc.aPgno[idx-1] );
     }
 
     /* Write the aPgno[] array entry and the hash-table slot. */
@@ -60721,7 +61545,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){
       if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
     }
-    sLoc.aPgno[idx] = iPage;
+    sLoc.aPgno[idx-1] = iPage;
     AtomicStore(&sLoc.aHash[iKey], (ht_slot)idx);
 
 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
@@ -60742,19 +61566,18 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     */
     if( (idx&0x3ff)==0 ){
       int i;           /* Loop counter */
-      for(i=1; i<=idx; i++){
+      for(i=0; i<idx; i++){
         for(iKey=walHash(sLoc.aPgno[i]);
             sLoc.aHash[iKey];
             iKey=walNextHash(iKey)){
-          if( sLoc.aHash[iKey]==i ) break;
+          if( sLoc.aHash[iKey]==i+1 ) break;
         }
-        assert( sLoc.aHash[iKey]==i );
+        assert( sLoc.aHash[iKey]==i+1 );
       }
     }
 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
   }
 
-
   return rc;
 }
 
@@ -60875,7 +61698,8 @@ static int walIndexRecover(Wal *pWal){
       u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE);
       u32 nHdr, nHdr32;
       rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare);
-      if( rc ) break;
+      assert( aShare!=0 || rc!=SQLITE_OK );
+      if( aShare==0 ) break;
       pWal->apWiData[iPg] = aPrivate;
 
       for(iFrame=iFirst; iFrame<=iLast; iFrame++){
@@ -61034,14 +61858,43 @@ SQLITE_PRIVATE int sqlite3WalOpen(
   assert( zWalName && zWalName[0] );
   assert( pDbFd );
 
+  /* Verify the values of various constants.  Any changes to the values
+  ** of these constants would result in an incompatible on-disk format
+  ** for the -shm file.  Any change that causes one of these asserts to
+  ** fail is a backward compatibility problem, even if the change otherwise
+  ** works.
+  **
+  ** This table also serves as a helpful cross-reference when trying to
+  ** interpret hex dumps of the -shm file.
+  */
+  assert(    48 ==  sizeof(WalIndexHdr)  );
+  assert(    40 ==  sizeof(WalCkptInfo)  );
+  assert(   120 ==  WALINDEX_LOCK_OFFSET );
+  assert(   136 ==  WALINDEX_HDR_SIZE    );
+  assert(  4096 ==  HASHTABLE_NPAGE      );
+  assert(  4062 ==  HASHTABLE_NPAGE_ONE  );
+  assert(  8192 ==  HASHTABLE_NSLOT      );
+  assert(   383 ==  HASHTABLE_HASH_1     );
+  assert( 32768 ==  WALINDEX_PGSZ        );
+  assert(     8 ==  SQLITE_SHM_NLOCK     );
+  assert(     5 ==  WAL_NREADER          );
+  assert(    24 ==  WAL_FRAME_HDRSIZE    );
+  assert(    32 ==  WAL_HDRSIZE          );
+  assert(   120 ==  WALINDEX_LOCK_OFFSET + WAL_WRITE_LOCK   );
+  assert(   121 ==  WALINDEX_LOCK_OFFSET + WAL_CKPT_LOCK    );
+  assert(   122 ==  WALINDEX_LOCK_OFFSET + WAL_RECOVER_LOCK );
+  assert(   123 ==  WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(0) );
+  assert(   124 ==  WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(1) );
+  assert(   125 ==  WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(2) );
+  assert(   126 ==  WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(3) );
+  assert(   127 ==  WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(4) );
+
   /* In the amalgamation, the os_unix.c and os_win.c source files come before
   ** this source file.  Verify that the #defines of the locking byte offsets
   ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
   ** For that matter, if the lock offset ever changes from its initial design
   ** value of 120, we need to know that so there is an assert() to check it.
   */
-  assert( 120==WALINDEX_LOCK_OFFSET );
-  assert( 136==WALINDEX_HDR_SIZE );
 #ifdef WIN_SHM_BASE
   assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
 #endif
@@ -61343,7 +62196,6 @@ static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
       int nEntry;                 /* Number of entries in this segment */
       ht_slot *aIndex;            /* Sorted index for this segment */
 
-      sLoc.aPgno++;
       if( (i+1)==nSegment ){
         nEntry = (int)(iLast - sLoc.iZero);
       }else{
@@ -62482,7 +63334,8 @@ SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){
 
           rc = walHashGet(pWal, walFramePage(i), &sLoc);
           if( rc!=SQLITE_OK ) break;
-          pgno = sLoc.aPgno[i-sLoc.iZero];
+          assert( i - sLoc.iZero - 1 >=0 );
+          pgno = sLoc.aPgno[i-sLoc.iZero-1];
           iDbOff = (i64)(pgno-1) * szPage;
 
           if( iDbOff+szPage<=szDb ){
@@ -62715,7 +63568,7 @@ SQLITE_PRIVATE int sqlite3WalFindFrame(
     iKey = walHash(pgno);
     while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
       u32 iFrame = iH + sLoc.iZero;
-      if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH]==pgno ){
+      if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
         assert( iFrame>iRead || CORRUPT_DB );
         iRead = iFrame;
       }
@@ -63967,7 +64820,6 @@ typedef struct CellInfo CellInfo;
 */
 struct MemPage {
   u8 isInit;           /* True if previously initialized. MUST BE FIRST! */
-  u8 bBusy;            /* Prevent endless loops on corrupt database files */
   u8 intKey;           /* True if table b-trees.  False for index b-trees */
   u8 intKeyLeaf;       /* True if the leaf of an intKey table */
   Pgno pgno;           /* Page number for this page */
@@ -64045,7 +64897,7 @@ struct Btree {
   u8 hasIncrblobCur; /* True if there are one or more Incrblob cursors */
   int wantToLock;    /* Number of nested calls to sqlite3BtreeEnter() */
   int nBackup;       /* Number of backup operations reading this btree */
-  u32 iDataVersion;  /* Combines with pBt->pPager->iDataVersion */
+  u32 iBDataVersion; /* Combines with pBt->pPager->iDataVersion */
   Btree *pNext;      /* List of other sharable Btrees from the same db */
   Btree *pPrev;      /* Back pointer of the same list */
 #ifdef SQLITE_DEBUG
@@ -64150,6 +65002,7 @@ struct BtShared {
   Btree *pWriter;       /* Btree with currently open write transaction */
 #endif
   u8 *pTmpSpace;        /* Temp space sufficient to hold a single cell */
+  int nPreformatSize;   /* Size of last cell written by TransferRow() */
 };
 
 /*
@@ -65267,7 +66120,7 @@ static void invalidateIncrblobCursors(
   int isClearTable        /* True if all rows are being deleted */
 ){
   BtCursor *p;
-  if( pBtree->hasIncrblobCur==0 ) return;
+  assert( pBtree->hasIncrblobCur );
   assert( sqlite3BtreeHoldsMutex(pBtree) );
   pBtree->hasIncrblobCur = 0;
   for(p=pBtree->pBt->pCursor; p; p=p->pNext){
@@ -65547,15 +66400,13 @@ static int btreeMoveto(
     sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
     if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
       rc = SQLITE_CORRUPT_BKPT;
-      goto moveto_done;
+    }else{
+      rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes);
     }
+    sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
   }else{
     pIdxKey = 0;
-  }
-  rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
-moveto_done:
-  if( pIdxKey ){
-    sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
+    rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes);
   }
   return rc;
 }
@@ -65863,6 +66714,24 @@ static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow(
   pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4;
 }
 
+/*
+** Given a record with nPayload bytes of payload stored within btree
+** page pPage, return the number of bytes of payload stored locally.
+*/
+static int btreePayloadToLocal(MemPage *pPage, i64 nPayload){
+  int maxLocal;  /* Maximum amount of payload held locally */
+  maxLocal = pPage->maxLocal;
+  if( nPayload<=maxLocal ){
+    return nPayload;
+  }else{
+    int minLocal;  /* Minimum amount of payload held locally */
+    int surplus;   /* Overflow payload available for local storage */
+    minLocal = pPage->minLocal;
+    surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize-4);
+    return ( surplus <= maxLocal ) ? surplus : minLocal;
+  }
+}
+
 /*
 ** The following routines are implementations of the MemPage.xParseCell()
 ** method.
@@ -66150,6 +67019,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
   unsigned char *src;        /* Source of content */
   int iCellFirst;            /* First allowable cell index */
   int iCellLast;             /* Last possible cell index */
+  int iCellStart;            /* First cell offset in input */
 
   assert( sqlite3PagerIswriteable(pPage->pDbPage) );
   assert( pPage->pBt!=0 );
@@ -66210,6 +67080,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
 
   cbrk = usableSize;
   iCellLast = usableSize - 4;
+  iCellStart = get2byte(&data[hdr+5]);
   for(i=0; i<nCell; i++){
     u8 *pAddr;     /* The i-th cell pointer */
     pAddr = &data[cellOffset + i*2];
@@ -66219,25 +67090,23 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
     /* These conditions have already been verified in btreeInitPage()
     ** if PRAGMA cell_size_check=ON.
     */
-    if( pc<iCellFirst || pc>iCellLast ){
+    if( pc<iCellStart || pc>iCellLast ){
       return SQLITE_CORRUPT_PAGE(pPage);
     }
-    assert( pc>=iCellFirst && pc<=iCellLast );
+    assert( pc>=iCellStart && pc<=iCellLast );
     size = pPage->xCellSize(pPage, &src[pc]);
     cbrk -= size;
-    if( cbrk<iCellFirst || pc+size>usableSize ){
+    if( cbrk<iCellStart || pc+size>usableSize ){
       return SQLITE_CORRUPT_PAGE(pPage);
     }
-    assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
+    assert( cbrk+size<=usableSize && cbrk>=iCellStart );
     testcase( cbrk+size==usableSize );
     testcase( pc+size==usableSize );
     put2byte(pAddr, cbrk);
     if( temp==0 ){
-      int x;
       if( cbrk==pc ) continue;
       temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
-      x = get2byte(&data[hdr+5]);
-      memcpy(&temp[x], &data[x], (cbrk+size) - x);
+      memcpy(&temp[iCellStart], &data[iCellStart], usableSize - iCellStart);
       src = temp;
     }
     memcpy(&data[cbrk], &src[pc], size);
@@ -66386,7 +67255,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
       int g2;
       assert( pSpace+nByte<=data+pPage->pBt->usableSize );
       *pIdx = g2 = (int)(pSpace-data);
-      if( NEVER(g2<=gap) ){
+      if( g2<=gap ){
         return SQLITE_CORRUPT_PAGE(pPage);
       }else{
         return SQLITE_OK;
@@ -67439,19 +68308,23 @@ static void freeTempSpace(BtShared *pBt){
 */
 SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){
   BtShared *pBt = p->pBt;
-  BtCursor *pCur;
 
   /* Close all cursors opened via this handle.  */
   assert( sqlite3_mutex_held(p->db->mutex) );
   sqlite3BtreeEnter(p);
-  pCur = pBt->pCursor;
-  while( pCur ){
-    BtCursor *pTmp = pCur;
-    pCur = pCur->pNext;
-    if( pTmp->pBtree==p ){
-      sqlite3BtreeCloseCursor(pTmp);
+
+  /* Verify that no other cursors have this Btree open */
+#ifdef SQLITE_DEBUG
+  {
+    BtCursor *pCur = pBt->pCursor;
+    while( pCur ){
+      BtCursor *pTmp = pCur;
+      pCur = pCur->pNext;
+      assert( pTmp->pBtree!=p );
+
     }
   }
+#endif
 
   /* Rollback any active transaction and free the handle structure.
   ** The call to sqlite3BtreeRollback() drops any table-locks held by
@@ -67603,6 +68476,7 @@ SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve,
         ((pageSize-1)&pageSize)==0 ){
     assert( (pageSize & 7)==0 );
     assert( !pBt->pCursor );
+    if( nReserve>32 && pageSize==512 ) pageSize = 1024;
     pBt->pageSize = (u32)pageSize;
     freeTempSpace(pBt);
   }
@@ -67794,7 +68668,6 @@ static int lockBtree(BtShared *pBt){
   MemPage *pPage1;     /* Page 1 of the database file */
   u32 nPage;           /* Number of pages in the database */
   u32 nPageFile = 0;   /* Number of pages in the database file */
-  u32 nPageHeader;     /* Number of pages in the database according to hdr */
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( pBt->pPage1==0 );
@@ -67806,7 +68679,7 @@ static int lockBtree(BtShared *pBt){
   /* Do some checking to help insure the file we opened really is
   ** a valid database file.
   */
-  nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
+  nPage = get4byte(28+(u8*)pPage1->aData);
   sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
   if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
     nPage = nPageFile;
@@ -67841,7 +68714,7 @@ static int lockBtree(BtShared *pBt){
       goto page1_init_failed;
     }
 
-    /* If the write version is set to 2, this database should be accessed
+    /* If the read version is set to 2, this database should be accessed
     ** in WAL mode. If the log is not already open, open it now. Then
     ** return SQLITE_OK and return without populating BtShared.pPage1.
     ** The caller detects this and calls this function again. This is
@@ -68639,16 +69512,18 @@ SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *p){
 /*
 ** This routine is called prior to sqlite3PagerCommit when a transaction
 ** is committed for an auto-vacuum database.
-**
-** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
-** the database file should be truncated to during the commit process.
-** i.e. the database has been reorganized so that only the first *pnTrunc
-** pages are in use.
 */
-static int autoVacuumCommit(BtShared *pBt){
+static int autoVacuumCommit(Btree *p){
   int rc = SQLITE_OK;
-  Pager *pPager = pBt->pPager;
-  VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); )
+  Pager *pPager;
+  BtShared *pBt;
+  sqlite3 *db;
+  VVA_ONLY( int nRef );
+
+  assert( p!=0 );
+  pBt = p->pBt;
+  pPager = pBt->pPager;
+  VVA_ONLY( nRef = sqlite3PagerRefcount(pPager); )
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   invalidateAllOverflowCache(pBt);
@@ -68656,6 +69531,7 @@ static int autoVacuumCommit(BtShared *pBt){
   if( !pBt->incrVacuum ){
     Pgno nFin;         /* Number of pages in database after autovacuuming */
     Pgno nFree;        /* Number of pages on the freelist initially */
+    Pgno nVac;         /* Number of pages to vacuum */
     Pgno iFree;        /* The next page to be freed */
     Pgno nOrig;        /* Database size before freeing */
 
@@ -68669,18 +69545,42 @@ static int autoVacuumCommit(BtShared *pBt){
     }
 
     nFree = get4byte(&pBt->pPage1->aData[36]);
-    nFin = finalDbSize(pBt, nOrig, nFree);
+    db = p->db;
+    if( db->xAutovacPages ){
+      int iDb;
+      for(iDb=0; ALWAYS(iDb<db->nDb); iDb++){
+        if( db->aDb[iDb].pBt==p ) break;
+      }
+      nVac = db->xAutovacPages(
+        db->pAutovacPagesArg,
+        db->aDb[iDb].zDbSName,
+        nOrig,
+        nFree,
+        pBt->pageSize
+      );
+      if( nVac>nFree ){
+        nVac = nFree;
+      }
+      if( nVac==0 ){
+        return SQLITE_OK;
+      }
+    }else{
+      nVac = nFree;
+    }
+    nFin = finalDbSize(pBt, nOrig, nVac);
     if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT;
     if( nFin<nOrig ){
       rc = saveAllCursors(pBt, 0, 0);
     }
     for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
-      rc = incrVacuumStep(pBt, nFin, iFree, 1);
+      rc = incrVacuumStep(pBt, nFin, iFree, nVac==nFree);
     }
     if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
       rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
-      put4byte(&pBt->pPage1->aData[32], 0);
-      put4byte(&pBt->pPage1->aData[36], 0);
+      if( nVac==nFree ){
+        put4byte(&pBt->pPage1->aData[32], 0);
+        put4byte(&pBt->pPage1->aData[36], 0);
+      }
       put4byte(&pBt->pPage1->aData[28], nFin);
       pBt->bDoTruncate = 1;
       pBt->nPage = nFin;
@@ -68731,7 +69631,7 @@ SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zSuperJrnl){
     sqlite3BtreeEnter(p);
 #ifndef SQLITE_OMIT_AUTOVACUUM
     if( pBt->autoVacuum ){
-      rc = autoVacuumCommit(pBt);
+      rc = autoVacuumCommit(p);
       if( rc!=SQLITE_OK ){
         sqlite3BtreeLeave(p);
         return rc;
@@ -68832,7 +69732,7 @@ SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
       sqlite3BtreeLeave(p);
       return rc;
     }
-    p->iDataVersion--;  /* Compensate for pPager->iDataVersion++; */
+    p->iBDataVersion--;  /* Compensate for pPager->iDataVersion++; */
     pBt->inTransaction = TRANS_READ;
     btreeClearHasContent(pBt);
   }
@@ -69242,7 +70142,14 @@ SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
     unlockBtreeIfUnused(pBt);
     sqlite3_free(pCur->aOverflow);
     sqlite3_free(pCur->pKey);
-    sqlite3BtreeLeave(pBtree);
+    if( (pBt->openFlags & BTREE_SINGLE) && pBt->pCursor==0 ){
+      /* Since the BtShared is not sharable, there is no need to
+      ** worry about the missing sqlite3BtreeLeave() call here.  */
+      assert( pBtree->sharable==0 );
+      sqlite3BtreeClose(pBtree);
+    }else{
+      sqlite3BtreeLeave(pBtree);
+    }
     pCur->pBtree = 0;
   }
   return SQLITE_OK;
@@ -69529,7 +70436,9 @@ static int accessPayload(
   assert( pPage );
   assert( eOp==0 || eOp==1 );
   assert( pCur->eState==CURSOR_VALID );
-  assert( pCur->ix<pPage->nCell );
+  if( pCur->ix>=pPage->nCell ){
+    return SQLITE_CORRUPT_PAGE(pPage);
+  }
   assert( cursorHoldsMutex(pCur) );
 
   getCellInfo(pCur);
@@ -69716,7 +70625,6 @@ SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void
   assert( cursorHoldsMutex(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage>=0 && pCur->pPage );
-  assert( pCur->ix<pCur->pPage->nCell );
   return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
 }
 
@@ -69778,7 +70686,7 @@ static const void *fetchPayload(
   assert( pCur->eState==CURSOR_VALID );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( cursorOwnsBtShared(pCur) );
-  assert( pCur->ix<pCur->pPage->nCell );
+  assert( pCur->ix<pCur->pPage->nCell || CORRUPT_DB );
   assert( pCur->info.nSize>0 );
   assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
   assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
@@ -70084,7 +70992,9 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
     for(ii=0; ii<pCur->iPage; ii++){
       assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
     }
-    assert( pCur->ix==pCur->pPage->nCell-1 );
+    assert( pCur->ix==pCur->pPage->nCell-1 || CORRUPT_DB );
+    testcase( pCur->ix!=pCur->pPage->nCell-1 );
+    /* ^-- dbsqlfuzz b92b72e4de80b5140c30ab71372ca719b8feb618 */
     assert( pCur->pPage->leaf );
 #endif
     *pRes = 0;
@@ -70109,12 +71019,8 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
   return rc;
 }
 
-/* Move the cursor so that it points to an entry near the key
-** specified by pIdxKey or intKey.   Return a success code.
-**
-** For INTKEY tables, the intKey parameter is used.  pIdxKey
-** must be NULL.  For index tables, pIdxKey is used and intKey
-** is ignored.
+/* Move the cursor so that it points to an entry in a table (a.k.a INTKEY)
+** table near the key intKey.   Return a success code.
 **
 ** If an exact match is not found, then the cursor is always
 ** left pointing at a leaf page which would hold the entry if it
@@ -70127,39 +71033,32 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
 ** *pRes is as follows:
 **
 **     *pRes<0      The cursor is left pointing at an entry that
-**                  is smaller than intKey/pIdxKey or if the table is empty
+**                  is smaller than intKey or if the table is empty
 **                  and the cursor is therefore left point to nothing.
 **
 **     *pRes==0     The cursor is left pointing at an entry that
-**                  exactly matches intKey/pIdxKey.
+**                  exactly matches intKey.
 **
 **     *pRes>0      The cursor is left pointing at an entry that
-**                  is larger than intKey/pIdxKey.
-**
-** For index tables, the pIdxKey->eqSeen field is set to 1 if there
-** exists an entry in the table that exactly matches pIdxKey.
+**                  is larger than intKey.
 */
-SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
+SQLITE_PRIVATE int sqlite3BtreeTableMoveto(
   BtCursor *pCur,          /* The cursor to be moved */
-  UnpackedRecord *pIdxKey, /* Unpacked index key */
   i64 intKey,              /* The table key */
   int biasRight,           /* If true, bias the search to the high end */
   int *pRes                /* Write search results here */
 ){
   int rc;
-  RecordCompare xRecordCompare;
 
   assert( cursorOwnsBtShared(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( pRes );
-  assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
-  assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );
+  assert( pCur->pKeyInfo==0 );
+  assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 );
 
   /* If the cursor is already positioned at the point we are trying
   ** to move to, then just return without doing any work */
-  if( pIdxKey==0
-   && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
-  ){
+  if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){
     if( pCur->info.nKey==intKey ){
       *pRes = 0;
       return SQLITE_OK;
@@ -70181,9 +71080,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
           if( pCur->info.nKey==intKey ){
             return SQLITE_OK;
           }
-        }else if( rc==SQLITE_DONE ){
-          rc = SQLITE_OK;
-        }else{
+        }else if( rc!=SQLITE_DONE ){
           return rc;
         }
       }
@@ -70194,17 +71091,6 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
   pCur->pBtree->nSeek++;   /* Performance measurement during testing */
 #endif
 
-  if( pIdxKey ){
-    xRecordCompare = sqlite3VdbeFindCompare(pIdxKey);
-    pIdxKey->errCode = 0;
-    assert( pIdxKey->default_rc==1
-         || pIdxKey->default_rc==0
-         || pIdxKey->default_rc==-1
-    );
-  }else{
-    xRecordCompare = 0; /* All keys are integers */
-  }
-
   rc = moveToRoot(pCur);
   if( rc ){
     if( rc==SQLITE_EMPTY ){
@@ -70219,7 +71105,8 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->pPage->nCell > 0 );
   assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
-  assert( pCur->curIntKey || pIdxKey );
+  assert( pCur->curIntKey );
+
   for(;;){
     int lwr, upr, idx, c;
     Pgno chldPg;
@@ -70233,133 +71120,238 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
     ** be the right kind (index or table) of b-tree page. Otherwise
     ** a moveToChild() or moveToRoot() call would have detected corruption.  */
     assert( pPage->nCell>0 );
-    assert( pPage->intKey==(pIdxKey==0) );
+    assert( pPage->intKey );
     lwr = 0;
     upr = pPage->nCell-1;
     assert( biasRight==0 || biasRight==1 );
     idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */
     pCur->ix = (u16)idx;
-    if( xRecordCompare==0 ){
-      for(;;){
-        i64 nCellKey;
-        pCell = findCellPastPtr(pPage, idx);
-        if( pPage->intKeyLeaf ){
-          while( 0x80 <= *(pCell++) ){
-            if( pCell>=pPage->aDataEnd ){
-              return SQLITE_CORRUPT_PAGE(pPage);
-            }
+    for(;;){
+      i64 nCellKey;
+      pCell = findCellPastPtr(pPage, idx);
+      if( pPage->intKeyLeaf ){
+        while( 0x80 <= *(pCell++) ){
+          if( pCell>=pPage->aDataEnd ){
+            return SQLITE_CORRUPT_PAGE(pPage);
           }
         }
-        getVarint(pCell, (u64*)&nCellKey);
-        if( nCellKey<intKey ){
-          lwr = idx+1;
-          if( lwr>upr ){ c = -1; break; }
-        }else if( nCellKey>intKey ){
-          upr = idx-1;
-          if( lwr>upr ){ c = +1; break; }
+      }
+      getVarint(pCell, (u64*)&nCellKey);
+      if( nCellKey<intKey ){
+        lwr = idx+1;
+        if( lwr>upr ){ c = -1; break; }
+      }else if( nCellKey>intKey ){
+        upr = idx-1;
+        if( lwr>upr ){ c = +1; break; }
+      }else{
+        assert( nCellKey==intKey );
+        pCur->ix = (u16)idx;
+        if( !pPage->leaf ){
+          lwr = idx;
+          goto moveto_table_next_layer;
         }else{
-          assert( nCellKey==intKey );
-          pCur->ix = (u16)idx;
-          if( !pPage->leaf ){
-            lwr = idx;
-            goto moveto_next_layer;
-          }else{
-            pCur->curFlags |= BTCF_ValidNKey;
-            pCur->info.nKey = nCellKey;
-            pCur->info.nSize = 0;
-            *pRes = 0;
-            return SQLITE_OK;
-          }
+          pCur->curFlags |= BTCF_ValidNKey;
+          pCur->info.nKey = nCellKey;
+          pCur->info.nSize = 0;
+          *pRes = 0;
+          return SQLITE_OK;
         }
-        assert( lwr+upr>=0 );
-        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2; */
       }
+      assert( lwr+upr>=0 );
+      idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2; */
+    }
+    assert( lwr==upr+1 || !pPage->leaf );
+    assert( pPage->isInit );
+    if( pPage->leaf ){
+      assert( pCur->ix<pCur->pPage->nCell );
+      pCur->ix = (u16)idx;
+      *pRes = c;
+      rc = SQLITE_OK;
+      goto moveto_table_finish;
+    }
+moveto_table_next_layer:
+    if( lwr>=pPage->nCell ){
+      chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
     }else{
-      for(;;){
-        int nCell;  /* Size of the pCell cell in bytes */
-        pCell = findCellPastPtr(pPage, idx);
-
-        /* The maximum supported page-size is 65536 bytes. This means that
-        ** the maximum number of record bytes stored on an index B-Tree
-        ** page is less than 16384 bytes and may be stored as a 2-byte
-        ** varint. This information is used to attempt to avoid parsing
-        ** the entire cell by checking for the cases where the record is
-        ** stored entirely within the b-tree page by inspecting the first
-        ** 2 bytes of the cell.
-        */
-        nCell = pCell[0];
-        if( nCell<=pPage->max1bytePayload ){
-          /* This branch runs if the record-size field of the cell is a
-          ** single byte varint and the record fits entirely on the main
-          ** b-tree page.  */
-          testcase( pCell+nCell+1==pPage->aDataEnd );
-          c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
-        }else if( !(pCell[1] & 0x80)
-          && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
-        ){
-          /* The record-size field is a 2 byte varint and the record
-          ** fits entirely on the main b-tree page.  */
-          testcase( pCell+nCell+2==pPage->aDataEnd );
-          c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
-        }else{
-          /* The record flows over onto one or more overflow pages. In
-          ** this case the whole cell needs to be parsed, a buffer allocated
-          ** and accessPayload() used to retrieve the record into the
-          ** buffer before VdbeRecordCompare() can be called.
-          **
-          ** If the record is corrupt, the xRecordCompare routine may read
-          ** up to two varints past the end of the buffer. An extra 18
-          ** bytes of padding is allocated at the end of the buffer in
-          ** case this happens.  */
-          void *pCellKey;
-          u8 * const pCellBody = pCell - pPage->childPtrSize;
-          const int nOverrun = 18;  /* Size of the overrun padding */
-          pPage->xParseCell(pPage, pCellBody, &pCur->info);
-          nCell = (int)pCur->info.nKey;
-          testcase( nCell<0 );   /* True if key size is 2^32 or more */
-          testcase( nCell==0 );  /* Invalid key size:  0x80 0x80 0x00 */
-          testcase( nCell==1 );  /* Invalid key size:  0x80 0x80 0x01 */
-          testcase( nCell==2 );  /* Minimum legal index key size */
-          if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
-            rc = SQLITE_CORRUPT_PAGE(pPage);
-            goto moveto_finish;
-          }
-          pCellKey = sqlite3Malloc( nCell+nOverrun );
-          if( pCellKey==0 ){
-            rc = SQLITE_NOMEM_BKPT;
-            goto moveto_finish;
-          }
-          pCur->ix = (u16)idx;
-          rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
-          memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */
-          pCur->curFlags &= ~BTCF_ValidOvfl;
-          if( rc ){
-            sqlite3_free(pCellKey);
-            goto moveto_finish;
-          }
-          c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
-          sqlite3_free(pCellKey);
+      chldPg = get4byte(findCell(pPage, lwr));
+    }
+    pCur->ix = (u16)lwr;
+    rc = moveToChild(pCur, chldPg);
+    if( rc ) break;
+  }
+moveto_table_finish:
+  pCur->info.nSize = 0;
+  assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
+  return rc;
+}
+
+/* Move the cursor so that it points to an entry in an index table
+** near the key pIdxKey.   Return a success code.
+**
+** If an exact match is not found, then the cursor is always
+** left pointing at a leaf page which would hold the entry if it
+** were present.  The cursor might point to an entry that comes
+** before or after the key.
+**
+** An integer is written into *pRes which is the result of
+** comparing the key with the entry to which the cursor is
+** pointing.  The meaning of the integer written into
+** *pRes is as follows:
+**
+**     *pRes<0      The cursor is left pointing at an entry that
+**                  is smaller than pIdxKey or if the table is empty
+**                  and the cursor is therefore left point to nothing.
+**
+**     *pRes==0     The cursor is left pointing at an entry that
+**                  exactly matches pIdxKey.
+**
+**     *pRes>0      The cursor is left pointing at an entry that
+**                  is larger than pIdxKey.
+**
+** The pIdxKey->eqSeen field is set to 1 if there
+** exists an entry in the table that exactly matches pIdxKey.
+*/
+SQLITE_PRIVATE int sqlite3BtreeIndexMoveto(
+  BtCursor *pCur,          /* The cursor to be moved */
+  UnpackedRecord *pIdxKey, /* Unpacked index key */
+  int *pRes                /* Write search results here */
+){
+  int rc;
+  RecordCompare xRecordCompare;
+
+  assert( cursorOwnsBtShared(pCur) );
+  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
+  assert( pRes );
+  assert( pCur->pKeyInfo!=0 );
+
+#ifdef SQLITE_DEBUG
+  pCur->pBtree->nSeek++;   /* Performance measurement during testing */
+#endif
+
+  xRecordCompare = sqlite3VdbeFindCompare(pIdxKey);
+  pIdxKey->errCode = 0;
+  assert( pIdxKey->default_rc==1
+       || pIdxKey->default_rc==0
+       || pIdxKey->default_rc==-1
+  );
+
+  rc = moveToRoot(pCur);
+  if( rc ){
+    if( rc==SQLITE_EMPTY ){
+      assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
+      *pRes = -1;
+      return SQLITE_OK;
+    }
+    return rc;
+  }
+  assert( pCur->pPage );
+  assert( pCur->pPage->isInit );
+  assert( pCur->eState==CURSOR_VALID );
+  assert( pCur->pPage->nCell > 0 );
+  assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
+  assert( pCur->curIntKey || pIdxKey );
+  for(;;){
+    int lwr, upr, idx, c;
+    Pgno chldPg;
+    MemPage *pPage = pCur->pPage;
+    u8 *pCell;                          /* Pointer to current cell in pPage */
+
+    /* pPage->nCell must be greater than zero. If this is the root-page
+    ** the cursor would have been INVALID above and this for(;;) loop
+    ** not run. If this is not the root-page, then the moveToChild() routine
+    ** would have already detected db corruption. Similarly, pPage must
+    ** be the right kind (index or table) of b-tree page. Otherwise
+    ** a moveToChild() or moveToRoot() call would have detected corruption.  */
+    assert( pPage->nCell>0 );
+    assert( pPage->intKey==(pIdxKey==0) );
+    lwr = 0;
+    upr = pPage->nCell-1;
+    idx = upr>>1; /* idx = (lwr+upr)/2; */
+    pCur->ix = (u16)idx;
+    for(;;){
+      int nCell;  /* Size of the pCell cell in bytes */
+      pCell = findCellPastPtr(pPage, idx);
+
+      /* The maximum supported page-size is 65536 bytes. This means that
+      ** the maximum number of record bytes stored on an index B-Tree
+      ** page is less than 16384 bytes and may be stored as a 2-byte
+      ** varint. This information is used to attempt to avoid parsing
+      ** the entire cell by checking for the cases where the record is
+      ** stored entirely within the b-tree page by inspecting the first
+      ** 2 bytes of the cell.
+      */
+      nCell = pCell[0];
+      if( nCell<=pPage->max1bytePayload ){
+        /* This branch runs if the record-size field of the cell is a
+        ** single byte varint and the record fits entirely on the main
+        ** b-tree page.  */
+        testcase( pCell+nCell+1==pPage->aDataEnd );
+        c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
+      }else if( !(pCell[1] & 0x80)
+        && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
+      ){
+        /* The record-size field is a 2 byte varint and the record
+        ** fits entirely on the main b-tree page.  */
+        testcase( pCell+nCell+2==pPage->aDataEnd );
+        c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
+      }else{
+        /* The record flows over onto one or more overflow pages. In
+        ** this case the whole cell needs to be parsed, a buffer allocated
+        ** and accessPayload() used to retrieve the record into the
+        ** buffer before VdbeRecordCompare() can be called.
+        **
+        ** If the record is corrupt, the xRecordCompare routine may read
+        ** up to two varints past the end of the buffer. An extra 18
+        ** bytes of padding is allocated at the end of the buffer in
+        ** case this happens.  */
+        void *pCellKey;
+        u8 * const pCellBody = pCell - pPage->childPtrSize;
+        const int nOverrun = 18;  /* Size of the overrun padding */
+        pPage->xParseCell(pPage, pCellBody, &pCur->info);
+        nCell = (int)pCur->info.nKey;
+        testcase( nCell<0 );   /* True if key size is 2^32 or more */
+        testcase( nCell==0 );  /* Invalid key size:  0x80 0x80 0x00 */
+        testcase( nCell==1 );  /* Invalid key size:  0x80 0x80 0x01 */
+        testcase( nCell==2 );  /* Minimum legal index key size */
+        if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
+          rc = SQLITE_CORRUPT_PAGE(pPage);
+          goto moveto_index_finish;
+        }
+        pCellKey = sqlite3Malloc( nCell+nOverrun );
+        if( pCellKey==0 ){
+          rc = SQLITE_NOMEM_BKPT;
+          goto moveto_index_finish;
         }
-        assert(
-            (pIdxKey->errCode!=SQLITE_CORRUPT || c==0)
-         && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
-        );
-        if( c<0 ){
-          lwr = idx+1;
-        }else if( c>0 ){
-          upr = idx-1;
-        }else{
-          assert( c==0 );
-          *pRes = 0;
-          rc = SQLITE_OK;
-          pCur->ix = (u16)idx;
-          if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT;
-          goto moveto_finish;
+        pCur->ix = (u16)idx;
+        rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
+        memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */
+        pCur->curFlags &= ~BTCF_ValidOvfl;
+        if( rc ){
+          sqlite3_free(pCellKey);
+          goto moveto_index_finish;
         }
-        if( lwr>upr ) break;
-        assert( lwr+upr>=0 );
-        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2 */
+        c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
+        sqlite3_free(pCellKey);
+      }
+      assert(
+          (pIdxKey->errCode!=SQLITE_CORRUPT || c==0)
+       && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
+      );
+      if( c<0 ){
+        lwr = idx+1;
+      }else if( c>0 ){
+        upr = idx-1;
+      }else{
+        assert( c==0 );
+        *pRes = 0;
+        rc = SQLITE_OK;
+        pCur->ix = (u16)idx;
+        if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT;
+        goto moveto_index_finish;
       }
+      if( lwr>upr ) break;
+      assert( lwr+upr>=0 );
+      idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2 */
     }
     assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
     assert( pPage->isInit );
@@ -70368,9 +71360,8 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
       pCur->ix = (u16)idx;
       *pRes = c;
       rc = SQLITE_OK;
-      goto moveto_finish;
+      goto moveto_index_finish;
     }
-moveto_next_layer:
     if( lwr>=pPage->nCell ){
       chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
     }else{
@@ -70380,7 +71371,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
     rc = moveToChild(pCur, chldPg);
     if( rc ) break;
   }
-moveto_finish:
+moveto_index_finish:
   pCur->info.nSize = 0;
   assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
   return rc;
@@ -70481,16 +71472,6 @@ static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
     return SQLITE_CORRUPT_BKPT;
   }
 
-  /* If the database file is corrupt, it is possible for the value of idx
-  ** to be invalid here. This can only occur if a second cursor modifies
-  ** the page while cursor pCur is holding a reference to it. Which can
-  ** only happen if the database is corrupt in such a way as to link the
-  ** page into more than one b-tree structure.
-  **
-  ** Update 2019-12-23: appears to long longer be possible after the
-  ** addition of anotherValidCursor() condition on balance_deeper().  */
-  harmless( idx>pPage->nCell );
-
   if( idx>=pPage->nCell ){
     if( !pPage->leaf ){
       rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
@@ -70851,7 +71832,7 @@ static int allocateBtreePage(
 
         iPage = get4byte(&aData[8+closest*4]);
         testcase( iPage==mxPage );
-        if( iPage>mxPage ){
+        if( iPage>mxPage || iPage<2 ){
           rc = SQLITE_CORRUPT_PGNO(iTrunk);
           goto end_allocate_page;
         }
@@ -70978,7 +71959,7 @@ static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
   assert( CORRUPT_DB || iPage>1 );
   assert( !pMemPage || pMemPage->pgno==iPage );
 
-  if( iPage<2 || iPage>pBt->nPage ){
+  if( NEVER(iPage<2) || iPage>pBt->nPage ){
     return SQLITE_CORRUPT_BKPT;
   }
   if( pMemPage ){
@@ -71107,10 +72088,9 @@ static void freePage(MemPage *pPage, int *pRC){
 }
 
 /*
-** Free any overflow pages associated with the given Cell.  Store
-** size information about the cell in pInfo.
+** Free the overflow pages associated with the given Cell.
 */
-static int clearCell(
+static SQLITE_NOINLINE int clearCellOverflow(
   MemPage *pPage,          /* The page that contains the Cell */
   unsigned char *pCell,    /* First byte of the Cell */
   CellInfo *pInfo          /* Size information about the cell */
@@ -71122,10 +72102,7 @@ static int clearCell(
   u32 ovflPageSize;
 
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
-  pPage->xParseCell(pPage, pCell, pInfo);
-  if( pInfo->nLocal==pInfo->nPayload ){
-    return SQLITE_OK;  /* No overflow pages. Return without doing anything */
-  }
+  assert( pInfo->nLocal!=pInfo->nPayload );
   testcase( pCell + pInfo->nSize == pPage->aDataEnd );
   testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
   if( pCell + pInfo->nSize > pPage->aDataEnd ){
@@ -71181,6 +72158,21 @@ static int clearCell(
   return SQLITE_OK;
 }
 
+/* Call xParseCell to compute the size of a cell.  If the cell contains
+** overflow, then invoke cellClearOverflow to clear out that overflow.
+** STore the result code (SQLITE_OK or some error code) in rc.
+**
+** Implemented as macro to force inlining for performance.
+*/
+#define BTREE_CLEAR_CELL(rc, pPage, pCell, sInfo)   \
+  pPage->xParseCell(pPage, pCell, &sInfo);          \
+  if( sInfo.nLocal!=sInfo.nPayload ){               \
+    rc = clearCellOverflow(pPage, pCell, &sInfo);   \
+  }else{                                            \
+    rc = SQLITE_OK;                                 \
+  }
+
+
 /*
 ** Create the byte sequence used to represent a cell on page pPage
 ** and write that byte sequence into pCell[].  Overflow pages are
@@ -71703,7 +72695,7 @@ static int rebuildPage(
     u8 *pCell = pCArray->apCell[i];
     u16 sz = pCArray->szCell[i];
     assert( sz>0 );
-    if( SQLITE_WITHIN(pCell,aData,pEnd) ){
+    if( SQLITE_WITHIN(pCell,aData+j,pEnd) ){
       if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT;
       pCell = &pTmp[pCell - aData];
     }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd
@@ -71716,9 +72708,8 @@ static int rebuildPage(
     put2byte(pCellptr, (pData - aData));
     pCellptr += 2;
     if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT;
-    memcpy(pData, pCell, sz);
+    memmove(pData, pCell, sz);
     assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
-    testcase( sz!=pPg->xCellSize(pPg,pCell) )
     i++;
     if( i>=iEnd ) break;
     if( pCArray->ixNx[k]<=i ){
@@ -71857,7 +72848,9 @@ static int pageFreeArray(
         }
         pFree = pCell;
         szFree = sz;
-        if( pFree+sz>pEnd ) return 0;
+        if( pFree+sz>pEnd ){
+          return 0;
+        }
       }else{
         pFree = pCell;
         szFree += sz;
@@ -71922,6 +72915,7 @@ static int editPage(
 
   pData = &aData[get2byteNotZero(&aData[hdr+5])];
   if( pData<pBegin ) goto editpage_fail;
+  if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail;
 
   /* Add cells to the start of the page */
   if( iNew<iOld ){
@@ -72283,11 +73277,10 @@ static int balance_nonroot(
   Pgno aPgno[NB+2];            /* Page numbers of new pages before shuffling */
   Pgno aPgOrder[NB+2];         /* Copy of aPgno[] used for sorting pages */
   u16 aPgFlags[NB+2];          /* flags field of new pages before shuffling */
-  CellArray b;                  /* Parsed information on cells being balanced */
+  CellArray b;                 /* Parsed information on cells being balanced */
 
   memset(abDone, 0, sizeof(abDone));
-  b.nCell = 0;
-  b.apCell = 0;
+  memset(&b, 0, sizeof(b));
   pBt = pParent->pBt;
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( sqlite3PagerIswriteable(pParent->pDbPage) );
@@ -72338,7 +73331,9 @@ static int balance_nonroot(
   }
   pgno = get4byte(pRight);
   while( 1 ){
-    rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
+    if( rc==SQLITE_OK ){
+      rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
+    }
     if( rc ){
       memset(apOld, 0, (i+1)*sizeof(MemPage*));
       goto balance_cleanup;
@@ -72350,6 +73345,7 @@ static int balance_nonroot(
         goto balance_cleanup;
       }
     }
+    nMaxCells += apOld[i]->nCell + ArraySize(pParent->apOvfl);
     if( (i--)==0 ) break;
 
     if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){
@@ -72377,12 +73373,10 @@ static int balance_nonroot(
       if( pBt->btsFlags & BTS_FAST_SECURE ){
         int iOff;
 
+        /* If the following if() condition is not true, the db is corrupted.
+        ** The call to dropCell() below will detect this.  */
         iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
-        if( (iOff+szNew[i])>(int)pBt->usableSize ){
-          rc = SQLITE_CORRUPT_BKPT;
-          memset(apOld, 0, (i+1)*sizeof(MemPage*));
-          goto balance_cleanup;
-        }else{
+        if( (iOff+szNew[i])<=(int)pBt->usableSize ){
           memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
           apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
         }
@@ -72393,7 +73387,6 @@ static int balance_nonroot(
 
   /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
   ** alignment */
-  nMaxCells = nOld*(MX_CELL(pBt) + ArraySize(pParent->apOvfl));
   nMaxCells = (nMaxCells + 3)&~3;
 
   /*
@@ -72510,7 +73503,7 @@ static int balance_nonroot(
       b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection;
       if( !pOld->leaf ){
         assert( leafCorrection==0 );
-        assert( pOld->hdrOffset==0 );
+        assert( pOld->hdrOffset==0 || CORRUPT_DB );
         /* The right pointer of the child page pOld becomes the left
         ** pointer of the divider cell */
         memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
@@ -72676,6 +73669,11 @@ static int balance_nonroot(
       apOld[i] = 0;
       rc = sqlite3PagerWrite(pNew->pDbPage);
       nNew++;
+      if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv))
+       && rc==SQLITE_OK
+      ){
+        rc = SQLITE_CORRUPT_BKPT;
+      }
       if( rc ) goto balance_cleanup;
     }else{
       assert( i>0 );
@@ -72712,7 +73710,7 @@ static int balance_nonroot(
     aPgOrder[i] = aPgno[i] = apNew[i]->pgno;
     aPgFlags[i] = apNew[i]->pDbPage->flags;
     for(j=0; j<i; j++){
-      if( aPgno[j]==aPgno[i] ){
+      if( NEVER(aPgno[j]==aPgno[i]) ){
         /* This branch is taken if the set of sibling pages somehow contains
         ** duplicate entries. This can happen if the database is corrupt.
         ** It would be simpler to detect this as part of the loop below, but
@@ -72830,6 +73828,7 @@ static int balance_nonroot(
     u8 *pCell;
     u8 *pTemp;
     int sz;
+    u8 *pSrcEnd;
     MemPage *pNew = apNew[i];
     j = cntNew[i];
 
@@ -72873,6 +73872,12 @@ static int balance_nonroot(
     iOvflSpace += sz;
     assert( sz<=pBt->maxLocal+23 );
     assert( iOvflSpace <= (int)pBt->pageSize );
+    for(k=0; b.ixNx[k]<=i && ALWAYS(k<NB*2); k++){}
+    pSrcEnd = b.apEnd[k];
+    if( SQLITE_WITHIN(pSrcEnd, pCell, pCell+sz) ){
+      rc = SQLITE_CORRUPT_BKPT;
+      goto balance_cleanup;
+    }
     insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);
     if( rc!=SQLITE_OK ) goto balance_cleanup;
     assert( sqlite3PagerIswriteable(pParent->pDbPage) );
@@ -73086,7 +74091,7 @@ static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
 ** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid
 ** on the same B-tree as pCur.
 **
-** This can if a database is corrupt with two or more SQL tables
+** This can occur if a database is corrupt with two or more SQL tables
 ** pointing to the same b-tree.  If an insert occurs on one SQL table
 ** and causes a BEFORE TRIGGER to do a secondary insert on the other SQL
 ** table linked to the same b-tree.  If the secondary insert causes a
@@ -73315,7 +74320,7 @@ static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
   do{
     rc = btreeGetPage(pBt, ovflPgno, &pPage, 0);
     if( rc ) return rc;
-    if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 ){
+    if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){
       rc = SQLITE_CORRUPT_BKPT;
     }else{
       if( iOffset+ovflPageSize<(u32)nTotal ){
@@ -73380,7 +74385,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   unsigned char *oldCell;
   unsigned char *newCell = 0;
 
-  assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND))==flags );
+  assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND|BTREE_PREFORMAT))==flags );
+  assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
 
   if( pCur->eState==CURSOR_FAULT ){
     assert( pCur->skipNext!=SQLITE_OK );
@@ -73398,7 +74404,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   ** keys with no associated data. If the cursor was opened expecting an
   ** intkey table, the caller should be inserting integer keys with a
   ** blob of associated data.  */
-  assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
+  assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
 
   /* Save the positions of any other cursors open on this table.
   **
@@ -73414,13 +74420,23 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   if( pCur->curFlags & BTCF_Multiple ){
     rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
     if( rc ) return rc;
+    if( loc && pCur->iPage<0 ){
+      /* This can only happen if the schema is corrupt such that there is more
+      ** than one table or index with the same root page as used by the cursor.
+      ** Which can only happen if the SQLITE_NoSchemaError flag was set when
+      ** the schema was loaded. This cannot be asserted though, as a user might
+      ** set the flag, load the schema, and then unset the flag.  */
+      return SQLITE_CORRUPT_BKPT;
+    }
   }
 
   if( pCur->pKeyInfo==0 ){
     assert( pX->pKey==0 );
     /* If this is an insert into a table b-tree, invalidate any incrblob
     ** cursors open on the row being replaced */
-    invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
+    if( p->hasIncrblobCur ){
+      invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0);
+    }
 
     /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
     ** to a row with the same key as the new entry being inserted.
@@ -73453,7 +74469,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
       ** to an adjacent cell.  Move the cursor so that it is pointing either
       ** to the cell to be overwritten or an adjacent cell.
       */
-      rc = sqlite3BtreeMovetoUnpacked(pCur, 0, pX->nKey, flags!=0, &loc);
+      rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
+               (flags & BTREE_APPEND)!=0, &loc);
       if( rc ) return rc;
     }
   }else{
@@ -73476,13 +74493,11 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
         r.aMem = pX->aMem;
         r.nField = pX->nMem;
         r.default_rc = 0;
-        r.errCode = 0;
-        r.r1 = 0;
-        r.r2 = 0;
         r.eqSeen = 0;
-        rc = sqlite3BtreeMovetoUnpacked(pCur, &r, 0, flags!=0, &loc);
+        rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc);
       }else{
-        rc = btreeMoveto(pCur, pX->pKey, pX->nKey, flags!=0, &loc);
+        rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
+                    (flags & BTREE_APPEND)!=0, &loc);
       }
       if( rc ) return rc;
     }
@@ -73501,17 +74516,16 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
         return btreeOverwriteCell(pCur, &x2);
       }
     }
-
   }
   assert( pCur->eState==CURSOR_VALID
        || (pCur->eState==CURSOR_INVALID && loc)
        || CORRUPT_DB );
 
   pPage = pCur->pPage;
-  assert( pPage->intKey || pX->nKey>=0 );
+  assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
   assert( pPage->leaf || !pPage->intKey );
   if( pPage->nFree<0 ){
-    if( pCur->eState>CURSOR_INVALID ){
+    if( NEVER(pCur->eState>CURSOR_INVALID) ){
       rc = SQLITE_CORRUPT_BKPT;
     }else{
       rc = btreeComputeFreeSpace(pPage);
@@ -73525,14 +74539,31 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   assert( pPage->isInit );
   newCell = pBt->pTmpSpace;
   assert( newCell!=0 );
-  rc = fillInCell(pPage, newCell, pX, &szNew);
+  if( flags & BTREE_PREFORMAT ){
+    rc = SQLITE_OK;
+    szNew = pBt->nPreformatSize;
+    if( szNew<4 ) szNew = 4;
+    if( ISAUTOVACUUM && szNew>pPage->maxLocal ){
+      CellInfo info;
+      pPage->xParseCell(pPage, newCell, &info);
+      if( info.nPayload!=info.nLocal ){
+        Pgno ovfl = get4byte(&newCell[szNew-4]);
+        ptrmapPut(pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);
+      }
+    }
+  }else{
+    rc = fillInCell(pPage, newCell, pX, &szNew);
+  }
   if( rc ) goto end_insert;
   assert( szNew==pPage->xCellSize(pPage, newCell) );
   assert( szNew <= MX_CELL_SIZE(pBt) );
   idx = pCur->ix;
   if( loc==0 ){
     CellInfo info;
-    assert( idx<pPage->nCell );
+    assert( idx>=0 );
+    if( idx>=pPage->nCell ){
+      return SQLITE_CORRUPT_BKPT;
+    }
     rc = sqlite3PagerWrite(pPage->pDbPage);
     if( rc ){
       goto end_insert;
@@ -73541,7 +74572,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
     if( !pPage->leaf ){
       memcpy(newCell, oldCell, 4);
     }
-    rc = clearCell(pPage, oldCell, &info);
+    BTREE_CLEAR_CELL(rc, pPage, oldCell, info);
     testcase( pCur->curFlags & BTCF_ValidOvfl );
     invalidateOverflowCache(pCur);
     if( info.nSize==szNew && info.nLocal==info.nPayload
@@ -73632,6 +74663,114 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   return rc;
 }
 
+/*
+** This function is used as part of copying the current row from cursor
+** pSrc into cursor pDest. If the cursors are open on intkey tables, then
+** parameter iKey is used as the rowid value when the record is copied
+** into pDest. Otherwise, the record is copied verbatim.
+**
+** This function does not actually write the new value to cursor pDest.
+** Instead, it creates and populates any required overflow pages and
+** writes the data for the new cell into the BtShared.pTmpSpace buffer
+** for the destination database. The size of the cell, in bytes, is left
+** in BtShared.nPreformatSize. The caller completes the insertion by
+** calling sqlite3BtreeInsert() with the BTREE_PREFORMAT flag specified.
+**
+** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
+*/
+SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64 iKey){
+  int rc = SQLITE_OK;
+  BtShared *pBt = pDest->pBt;
+  u8 *aOut = pBt->pTmpSpace;    /* Pointer to next output buffer */
+  const u8 *aIn;                /* Pointer to next input buffer */
+  u32 nIn;                      /* Size of input buffer aIn[] */
+  u32 nRem;                     /* Bytes of data still to copy */
+
+  getCellInfo(pSrc);
+  aOut += putVarint32(aOut, pSrc->info.nPayload);
+  if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey);
+  nIn = pSrc->info.nLocal;
+  aIn = pSrc->info.pPayload;
+  if( aIn+nIn>pSrc->pPage->aDataEnd ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+  nRem = pSrc->info.nPayload;
+  if( nIn==nRem && nIn<pDest->pPage->maxLocal ){
+    memcpy(aOut, aIn, nIn);
+    pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace);
+  }else{
+    Pager *pSrcPager = pSrc->pBt->pPager;
+    u8 *pPgnoOut = 0;
+    Pgno ovflIn = 0;
+    DbPage *pPageIn = 0;
+    MemPage *pPageOut = 0;
+    u32 nOut;                     /* Size of output buffer aOut[] */
+
+    nOut = btreePayloadToLocal(pDest->pPage, pSrc->info.nPayload);
+    pBt->nPreformatSize = nOut + (aOut - pBt->pTmpSpace);
+    if( nOut<pSrc->info.nPayload ){
+      pPgnoOut = &aOut[nOut];
+      pBt->nPreformatSize += 4;
+    }
+
+    if( nRem>nIn ){
+      if( aIn+nIn+4>pSrc->pPage->aDataEnd ){
+        return SQLITE_CORRUPT_BKPT;
+      }
+      ovflIn = get4byte(&pSrc->info.pPayload[nIn]);
+    }
+
+    do {
+      nRem -= nOut;
+      do{
+        assert( nOut>0 );
+        if( nIn>0 ){
+          int nCopy = MIN(nOut, nIn);
+          memcpy(aOut, aIn, nCopy);
+          nOut -= nCopy;
+          nIn -= nCopy;
+          aOut += nCopy;
+          aIn += nCopy;
+        }
+        if( nOut>0 ){
+          sqlite3PagerUnref(pPageIn);
+          pPageIn = 0;
+          rc = sqlite3PagerGet(pSrcPager, ovflIn, &pPageIn, PAGER_GET_READONLY);
+          if( rc==SQLITE_OK ){
+            aIn = (const u8*)sqlite3PagerGetData(pPageIn);
+            ovflIn = get4byte(aIn);
+            aIn += 4;
+            nIn = pSrc->pBt->usableSize - 4;
+          }
+        }
+      }while( rc==SQLITE_OK && nOut>0 );
+
+      if( rc==SQLITE_OK && nRem>0 && ALWAYS(pPgnoOut) ){
+        Pgno pgnoNew;
+        MemPage *pNew = 0;
+        rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
+        put4byte(pPgnoOut, pgnoNew);
+        if( ISAUTOVACUUM && pPageOut ){
+          ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);
+        }
+        releasePage(pPageOut);
+        pPageOut = pNew;
+        if( pPageOut ){
+          pPgnoOut = pPageOut->aData;
+          put4byte(pPgnoOut, 0);
+          aOut = &pPgnoOut[4];
+          nOut = MIN(pBt->usableSize - 4, nRem);
+        }
+      }
+    }while( nRem>0 && rc==SQLITE_OK );
+
+    releasePage(pPageOut);
+    sqlite3PagerUnref(pPageIn);
+  }
+
+  return rc;
+}
+
 /*
 ** Delete the entry that the cursor is pointing to.
 **
@@ -73670,9 +74809,10 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
   if( pCur->eState==CURSOR_REQUIRESEEK ){
     rc = btreeRestoreCursorPosition(pCur);
-    if( rc ) return rc;
+    assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
+    if( rc || pCur->eState!=CURSOR_VALID ) return rc;
   }
-  assert( pCur->eState==CURSOR_VALID );
+  assert( CORRUPT_DB || pCur->eState==CURSOR_VALID );
 
   iCellDepth = pCur->iPage;
   iCellIdx = pCur->ix;
@@ -73725,7 +74865,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
 
   /* If this is a delete operation to remove a row from a table b-tree,
   ** invalidate any incrblob cursors open on the row being deleted.  */
-  if( pCur->pKeyInfo==0 ){
+  if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
     invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0);
   }
 
@@ -73734,7 +74874,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   ** itself from within the page.  */
   rc = sqlite3PagerWrite(pPage->pDbPage);
   if( rc ) return rc;
-  rc = clearCell(pPage, pCell, &info);
+  BTREE_CLEAR_CELL(rc, pPage, pCell, info);
   dropCell(pPage, iCellIdx, info.nSize, &rc);
   if( rc ) return rc;
 
@@ -73994,7 +75134,7 @@ static int clearDatabasePage(
   BtShared *pBt,           /* The BTree that contains the table */
   Pgno pgno,               /* Page number to clear */
   int freePageFlag,        /* Deallocate page if true */
-  int *pnChange            /* Add number of Cells freed to this counter */
+  i64 *pnChange            /* Add number of Cells freed to this counter */
 ){
   MemPage *pPage;
   int rc;
@@ -74009,11 +75149,12 @@ static int clearDatabasePage(
   }
   rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
   if( rc ) return rc;
-  if( pPage->bBusy ){
+  if( (pBt->openFlags & BTREE_SINGLE)==0
+   && sqlite3PagerPageRefcount(pPage->pDbPage)!=1
+  ){
     rc = SQLITE_CORRUPT_BKPT;
     goto cleardatabasepage_out;
   }
-  pPage->bBusy = 1;
   hdr = pPage->hdrOffset;
   for(i=0; i<pPage->nCell; i++){
     pCell = findCell(pPage, i);
@@ -74021,14 +75162,15 @@ static int clearDatabasePage(
       rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
       if( rc ) goto cleardatabasepage_out;
     }
-    rc = clearCell(pPage, pCell, &info);
+    BTREE_CLEAR_CELL(rc, pPage, pCell, info);
     if( rc ) goto cleardatabasepage_out;
   }
   if( !pPage->leaf ){
     rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
     if( rc ) goto cleardatabasepage_out;
-  }else if( pnChange ){
-    assert( pPage->intKey || CORRUPT_DB );
+    if( pPage->intKey ) pnChange = 0;
+  }
+  if( pnChange ){
     testcase( !pPage->intKey );
     *pnChange += pPage->nCell;
   }
@@ -74039,7 +75181,6 @@ static int clearDatabasePage(
   }
 
 cleardatabasepage_out:
-  pPage->bBusy = 0;
   releasePage(pPage);
   return rc;
 }
@@ -74053,11 +75194,10 @@ static int clearDatabasePage(
 ** read cursors on the table.  Open write cursors are moved to the
 ** root of the table.
 **
-** If pnChange is not NULL, then table iTable must be an intkey table. The
-** integer value pointed to by pnChange is incremented by the number of
-** entries in the table.
+** If pnChange is not NULL, then the integer value pointed to by pnChange
+** is incremented by the number of entries in the table.
 */
-SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){
+SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, i64 *pnChange){
   int rc;
   BtShared *pBt = p->pBt;
   sqlite3BtreeEnter(p);
@@ -74069,7 +75209,9 @@ SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){
     /* Invalidate all incrblob cursors open on table iTable (assuming iTable
     ** is the root of a table b-tree - if it is not, the following call is
     ** a no-op).  */
-    invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1);
+    if( p->hasIncrblobCur ){
+      invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1);
+    }
     rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
   }
   sqlite3BtreeLeave(p);
@@ -74117,10 +75259,10 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
     return SQLITE_CORRUPT_BKPT;
   }
 
-  rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
-  if( rc ) return rc;
   rc = sqlite3BtreeClearTable(p, iTable, 0);
-  if( rc ){
+  if( rc ) return rc;
+  rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
+  if( NEVER(rc) ){
     releasePage(pPage);
     return rc;
   }
@@ -74229,7 +75371,7 @@ SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
   assert( idx>=0 && idx<=15 );
 
   if( idx==BTREE_DATA_VERSION ){
-    *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
+    *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion;
   }else{
     *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
   }
@@ -76152,7 +77294,9 @@ SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
 
   /* The szMalloc field holds the correct memory allocation size */
   assert( p->szMalloc==0
-       || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
+       || (p->flags==MEM_Undefined
+           && p->szMalloc<=sqlite3DbMallocSize(p->db,p->zMalloc))
+       || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc));
 
   /* If p holds a string or blob, the Mem.z must point to exactly
   ** one of the following:
@@ -76275,6 +77419,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
 #ifndef SQLITE_OMIT_UTF16
   int rc;
 #endif
+  assert( pMem!=0 );
   assert( !sqlite3VdbeMemIsRowSet(pMem) );
   assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
            || desiredEnc==SQLITE_UTF16BE );
@@ -76316,7 +77461,9 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPre
   testcase( bPreserve && pMem->z==0 );
 
   assert( pMem->szMalloc==0
-       || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
+       || (pMem->flags==MEM_Undefined
+           && pMem->szMalloc<=sqlite3DbMallocSize(pMem->db,pMem->zMalloc))
+       || pMem->szMalloc==sqlite3DbMallocSize(pMem->db,pMem->zMalloc));
   if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
     if( pMem->db ){
       pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
@@ -76405,6 +77552,7 @@ static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( !sqlite3VdbeMemIsRowSet(pMem) );
   if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
@@ -76429,6 +77577,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
 #ifndef SQLITE_OMIT_INCRBLOB
 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
   int nByte;
+  assert( pMem!=0 );
   assert( pMem->flags & MEM_Zero );
   assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
   testcase( sqlite3_value_nochange(pMem) );
@@ -76444,6 +77593,8 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
   if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
     return SQLITE_NOMEM_BKPT;
   }
+  assert( pMem->z!=0 );
+  assert( sqlite3DbMallocSize(pMem->db,pMem->z) >= nByte );
 
   memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
   pMem->n += pMem->u.nZero;
@@ -76456,6 +77607,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
 ** Make sure the given Mem is \u0000 terminated.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
   testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
@@ -76483,6 +77635,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
   const int nByte = 32;
 
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( !(pMem->flags&MEM_Zero) );
   assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
@@ -76518,6 +77671,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
   sqlite3_context ctx;
   Mem t;
   assert( pFunc!=0 );
+  assert( pMem!=0 );
   assert( pFunc->xFinalize!=0 );
   assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
@@ -76668,6 +77822,7 @@ static SQLITE_NOINLINE i64 memIntValue(Mem *pMem){
 }
 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
   int flags;
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
   flags = pMem->flags;
@@ -76696,6 +77851,7 @@ static SQLITE_NOINLINE double memRealValue(Mem *pMem){
   return val;
 }
 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
   if( pMem->flags & MEM_Real ){
@@ -76728,6 +77884,7 @@ SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){
 */
 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
   i64 ix;
+  assert( pMem!=0 );
   assert( pMem->flags & MEM_Real );
   assert( !sqlite3VdbeMemIsRowSet(pMem) );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
@@ -76755,6 +77912,7 @@ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
 ** Convert pMem to type integer.  Invalidate any prior representations.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( !sqlite3VdbeMemIsRowSet(pMem) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
@@ -76769,6 +77927,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
 ** Invalidate any prior representations.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
@@ -76802,6 +77961,7 @@ SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){
 ** as much of the string as we can and ignore the rest.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
+  assert( pMem!=0 );
   testcase( pMem->flags & MEM_Int );
   testcase( pMem->flags & MEM_Real );
   testcase( pMem->flags & MEM_IntReal );
@@ -76911,6 +78071,7 @@ SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){
 ** Delete any previous value and set the value to be a BLOB of length
 ** n containing all zeros.
 */
+#ifndef SQLITE_OMIT_INCRBLOB
 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
   sqlite3VdbeMemRelease(pMem);
   pMem->flags = MEM_Blob|MEM_Zero;
@@ -76920,6 +78081,21 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
   pMem->enc = SQLITE_UTF8;
   pMem->z = 0;
 }
+#else
+SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
+  int nByte = n>0?n:1;
+  if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
+    return SQLITE_NOMEM_BKPT;
+  }
+  assert( pMem->z!=0 );
+  assert( sqlite3DbMallocSize(pMem->db, pMem->z)>=nByte );
+  memset(pMem->z, 0, nByte);
+  pMem->n = n>0?n:0;
+  pMem->flags = MEM_Blob;
+  pMem->enc = SQLITE_UTF8;
+  return SQLITE_OK;
+}
+#endif
 
 /*
 ** The pMem is known to contain content that needs to be destroyed prior
@@ -77145,14 +78321,15 @@ SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
   Mem *pMem,          /* Memory cell to set to string value */
   const char *z,      /* String pointer */
-  int n,              /* Bytes in string, or negative */
+  i64 n,              /* Bytes in string, or negative */
   u8 enc,             /* Encoding of z.  0 for BLOBs */
   void (*xDel)(void*) /* Destructor function */
 ){
-  int nByte = n;      /* New value for pMem->n */
+  i64 nByte = n;      /* New value for pMem->n */
   int iLimit;         /* Maximum allowed string or blob size */
   u16 flags = 0;      /* New value for pMem->flags */
 
+  assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( !sqlite3VdbeMemIsRowSet(pMem) );
 
@@ -77171,7 +78348,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
   if( nByte<0 ){
     assert( enc!=0 );
     if( enc==SQLITE_UTF8 ){
-      nByte = 0x7fffffff & (int)strlen(z);
+      nByte = strlen(z);
     }else{
       for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
     }
@@ -77183,7 +78360,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
   ** management (one of MEM_Dyn or MEM_Static).
   */
   if( xDel==SQLITE_TRANSIENT ){
-    u32 nAlloc = nByte;
+    i64 nAlloc = nByte;
     if( flags&MEM_Term ){
       nAlloc += (enc==SQLITE_UTF8?1:2);
     }
@@ -77209,7 +78386,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
     }
   }
 
-  pMem->n = nByte;
+  pMem->n = (int)(nByte & 0x7fffffff);
   pMem->flags = flags;
   if( enc ){
     pMem->enc = enc;
@@ -77229,7 +78406,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
 #endif
 
   if( nByte>iLimit ){
-    return SQLITE_TOOBIG;
+    return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
   }
 
   return SQLITE_OK;
@@ -77461,7 +78638,7 @@ static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
 #ifdef SQLITE_ENABLE_STAT4
 static int valueFromFunction(
   sqlite3 *db,                    /* The database connection */
-  Expr *p,                        /* The expression to evaluate */
+  const Expr *p,                  /* The expression to evaluate */
   u8 enc,                         /* Encoding to use */
   u8 aff,                         /* Affinity to use */
   sqlite3_value **ppVal,          /* Write the new value here */
@@ -77478,8 +78655,10 @@ static int valueFromFunction(
 
   assert( pCtx!=0 );
   assert( (p->flags & EP_TokenOnly)==0 );
+  assert( ExprUseXList(p) );
   pList = p->x.pList;
   if( pList ) nVal = pList->nExpr;
+  assert( !ExprHasProperty(p, EP_IntValue) );
   pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
   assert( pFunc );
   if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
@@ -77555,7 +78734,7 @@ static int valueFromFunction(
 */
 static int valueFromExpr(
   sqlite3 *db,                    /* The database connection */
-  Expr *pExpr,                    /* The expression to evaluate */
+  const Expr *pExpr,              /* The expression to evaluate */
   u8 enc,                         /* Encoding to use */
   u8 affinity,                    /* Affinity to use */
   sqlite3_value **ppVal,          /* Write the new value here */
@@ -77583,7 +78762,9 @@ static int valueFromExpr(
   assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
 
   if( op==TK_CAST ){
-    u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
+    u8 aff;
+    assert( !ExprHasProperty(pExpr, EP_IntValue) );
+    aff = sqlite3AffinityType(pExpr->u.zToken,0);
     rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
     testcase( rc!=SQLITE_OK );
     if( *ppVal ){
@@ -77656,6 +78837,7 @@ static int valueFromExpr(
 #ifndef SQLITE_OMIT_BLOB_LITERAL
   else if( op==TK_BLOB ){
     int nVal;
+    assert( !ExprHasProperty(pExpr, EP_IntValue) );
     assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
     assert( pExpr->u.zToken[1]=='\'' );
     pVal = valueNew(db, pCtx);
@@ -77673,6 +78855,7 @@ static int valueFromExpr(
   }
 #endif
   else if( op==TK_TRUEFALSE ){
+    assert( !ExprHasProperty(pExpr, EP_IntValue) );
     pVal = valueNew(db, pCtx);
     if( pVal ){
       pVal->flags = MEM_Int;
@@ -77710,7 +78893,7 @@ static int valueFromExpr(
 */
 SQLITE_PRIVATE int sqlite3ValueFromExpr(
   sqlite3 *db,              /* The database connection */
-  Expr *pExpr,              /* The expression to evaluate */
+  const Expr *pExpr,        /* The expression to evaluate */
   u8 enc,                   /* Encoding to use */
   u8 affinity,              /* Affinity to use */
   sqlite3_value **ppVal     /* Write the new value here */
@@ -78020,7 +79203,7 @@ SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
   p->pNext = db->pVdbe;
   p->pPrev = 0;
   db->pVdbe = p;
-  p->magic = VDBE_MAGIC_INIT;
+  p->iVdbeMagic = VDBE_MAGIC_INIT;
   p->pParse = pParse;
   pParse->pVdbe = p;
   assert( pParse->aLabel==0 );
@@ -78221,13 +79404,15 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
   VdbeOp *pOp;
 
   i = p->nOp;
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   assert( op>=0 && op<0xff );
   if( p->nOpAlloc<=i ){
     return growOp3(p, op, p1, p2, p3);
   }
+  assert( p->aOp!=0 );
   p->nOp++;
   pOp = &p->aOp[i];
+  assert( pOp!=0 );
   pOp->opcode = (u8)op;
   pOp->p5 = 0;
   pOp->p1 = p1;
@@ -78456,9 +79641,10 @@ SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){
 ** The zWhere string must have been obtained from sqlite3_malloc().
 ** This routine will take ownership of the allocated memory.
 */
-SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
+SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){
   int j;
   sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
+  sqlite3VdbeChangeP5(p, p5);
   for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
   sqlite3MayAbort(p->pParse);
 }
@@ -78550,7 +79736,7 @@ static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){
   Parse *p = v->pParse;
   int j = ADDR(x);
-  assert( v->magic==VDBE_MAGIC_INIT );
+  assert( v->iVdbeMagic==VDBE_MAGIC_INIT );
   assert( j<-p->nLabel );
   assert( j>=0 );
 #ifdef SQLITE_DEBUG
@@ -78875,7 +80061,7 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
 ** Return the address of the next instruction to be inserted.
 */
 SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   return p->nOp;
 }
 
@@ -78960,7 +80146,7 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(
   int i;
   VdbeOp *pOut, *pFirst;
   assert( nOp>0 );
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
     return 0;
   }
@@ -79284,7 +80470,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int
   sqlite3 *db;
   assert( p!=0 );
   db = p->db;
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   assert( p->aOp!=0 || db->mallocFailed );
   if( db->mallocFailed ){
     if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
@@ -79413,7 +80599,7 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
   /* C89 specifies that the constant "dummy" will be initialized to all
   ** zeros, which is correct.  MSVC generates a warning, nevertheless. */
   static VdbeOp dummy;  /* Ignore the MSVC warning about no initializer */
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   if( addr<0 ){
     addr = p->nOp - 1;
   }
@@ -79469,13 +80655,9 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayComment(
   if( zOpName[nOpName+1] ){
     int seenCom = 0;
     char c;
-    zSynopsis = zOpName += nOpName + 1;
+    zSynopsis = zOpName + nOpName + 1;
     if( strncmp(zSynopsis,"IF ",3)==0 ){
-      if( pOp->p5 & SQLITE_STOREP2 ){
-        sqlite3_snprintf(sizeof(zAlt), zAlt, "r[P2] = (%s)", zSynopsis+3);
-      }else{
-        sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3);
-      }
+      sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3);
       zSynopsis = zAlt;
     }
     for(ii=0; (c = zSynopsis[ii])!=0; ii++){
@@ -79546,6 +80728,7 @@ static void displayP4Expr(StrAccum *p, Expr *pExpr){
   const char *zOp = 0;
   switch( pExpr->op ){
     case TK_STRING:
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
       break;
     case TK_INTEGER:
@@ -79648,7 +80831,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
     case P4_COLLSEQ: {
       static const char *const encnames[] = {"?", "8", "16LE", "16BE"};
       CollSeq *pColl = pOp->p4.pColl;
-      assert( pColl->enc>=0 && pColl->enc<4 );
+      assert( pColl->enc<4 );
       sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName,
                           encnames[pColl->enc]);
       break;
@@ -79892,8 +81075,8 @@ static void releaseMemArray(Mem *p, int N){
       */
       testcase( p->flags & MEM_Agg );
       testcase( p->flags & MEM_Dyn );
-      testcase( p->xDel==sqlite3VdbeFrameMemDel );
       if( p->flags&(MEM_Agg|MEM_Dyn) ){
+        testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel );
         sqlite3VdbeMemRelease(p);
       }else if( p->szMalloc ){
         sqlite3DbFreeNN(db, p->zMalloc);
@@ -80098,7 +81281,7 @@ SQLITE_PRIVATE int sqlite3VdbeList(
   Op *pOp;                             /* Current opcode */
 
   assert( p->explain );
-  assert( p->magic==VDBE_MAGIC_RUN );
+  assert( p->iVdbeMagic==VDBE_MAGIC_RUN );
   assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
 
   /* Even though this opcode does not use dynamic strings for
@@ -80278,14 +81461,14 @@ SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
   int i;
 #endif
   assert( p!=0 );
-  assert( p->magic==VDBE_MAGIC_INIT || p->magic==VDBE_MAGIC_RESET );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT || p->iVdbeMagic==VDBE_MAGIC_RESET );
 
   /* There should be at least one opcode.
   */
   assert( p->nOp>0 );
 
   /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
-  p->magic = VDBE_MAGIC_RUN;
+  p->iVdbeMagic = VDBE_MAGIC_RUN;
 
 #ifdef SQLITE_DEBUG
   for(i=0; i<p->nMem; i++){
@@ -80341,8 +81524,10 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   assert( p!=0 );
   assert( p->nOp>0 );
   assert( pParse!=0 );
-  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   assert( pParse==p->pParse );
+  p->pVList = pParse->pVList;
+  pParse->pVList =  0;
   db = p->db;
   assert( db->mallocFailed==0 );
   nVar = pParse->nVar;
@@ -80427,8 +81612,6 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
     }
   }
 
-  p->pVList = pParse->pVList;
-  pParse->pVList =  0;
   if( db->mallocFailed ){
     p->nVar = 0;
     p->nCursor = 0;
@@ -80456,20 +81639,15 @@ SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
     return;
   }
   assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
+  assert( pCx->pBtx==0 || pCx->isEphemeral );
   switch( pCx->eCurType ){
     case CURTYPE_SORTER: {
       sqlite3VdbeSorterClose(p->db, pCx);
       break;
     }
     case CURTYPE_BTREE: {
-      if( pCx->isEphemeral ){
-        if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
-        /* The pCx->pCursor will be close automatically, if it exists, by
-        ** the call above. */
-      }else{
-        assert( pCx->uc.pCursor!=0 );
-        sqlite3BtreeCloseCursor(pCx->uc.pCursor);
-      }
+      assert( pCx->uc.pCursor!=0 );
+      sqlite3BtreeCloseCursor(pCx->uc.pCursor);
       break;
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -80998,9 +82176,9 @@ SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
 ** has made changes and is in autocommit mode, then commit those
 ** changes.  If a rollback is needed, then do the rollback.
 **
-** This routine is the only way to move the state of a VM from
-** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT.  It is harmless to
-** call this on a VM that is in the SQLITE_MAGIC_HALT state.
+** This routine is the only way to move the sqlite3eOpenState of a VM from
+** SQLITE_STATE_RUN to SQLITE_STATE_HALT.  It is harmless to
+** call this on a VM that is in the SQLITE_STATE_HALT state.
 **
 ** Return an error code.  If the commit could not complete because of
 ** lock contention, return SQLITE_BUSY.  If SQLITE_BUSY is returned, it
@@ -81026,7 +82204,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
   ** one, or the complete transaction if there is no statement transaction.
   */
 
-  if( p->magic!=VDBE_MAGIC_RUN ){
+  if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){
     return SQLITE_OK;
   }
   if( db->mallocFailed ){
@@ -81046,9 +82224,15 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
     sqlite3VdbeEnter(p);
 
     /* Check for one of the special errors */
-    mrc = p->rc & 0xff;
-    isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
-                     || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
+    if( p->rc ){
+      mrc = p->rc & 0xff;
+      isSpecialError = mrc==SQLITE_NOMEM
+                    || mrc==SQLITE_IOERR
+                    || mrc==SQLITE_INTERRUPT
+                    || mrc==SQLITE_FULL;
+    }else{
+      mrc = isSpecialError = 0;
+    }
     if( isSpecialError ){
       /* If the query was read-only and the error code is SQLITE_INTERRUPT,
       ** no rollback is necessary. Otherwise, at least a savepoint
@@ -81100,6 +82284,9 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
             return SQLITE_ERROR;
           }
           rc = SQLITE_CONSTRAINT_FOREIGNKEY;
+        }else if( db->flags & SQLITE_CorruptRdOnly ){
+          rc = SQLITE_CORRUPT;
+          db->flags &= ~SQLITE_CorruptRdOnly;
         }else{
           /* The auto-commit flag is true, the vdbe program was successful
           ** or hit an 'OR FAIL' constraint and there are no deferred foreign
@@ -81184,7 +82371,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
     assert( db->nVdbeRead>=db->nVdbeWrite );
     assert( db->nVdbeWrite>=0 );
   }
-  p->magic = VDBE_MAGIC_HALT;
+  p->iVdbeMagic = VDBE_MAGIC_HALT;
   checkActiveVdbeCnt(db);
   if( db->mallocFailed ){
     p->rc = SQLITE_NOMEM_BKPT;
@@ -81357,7 +82544,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
     }
   }
 #endif
-  p->magic = VDBE_MAGIC_RESET;
+  p->iVdbeMagic = VDBE_MAGIC_RESET;
   return p->rc & db->errMask;
 }
 
@@ -81367,7 +82554,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
 */
 SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){
   int rc = SQLITE_OK;
-  if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
+  if( p->iVdbeMagic==VDBE_MAGIC_RUN || p->iVdbeMagic==VDBE_MAGIC_HALT ){
     rc = sqlite3VdbeReset(p);
     assert( (rc & p->db->errMask)==rc );
   }
@@ -81428,7 +82615,7 @@ SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
     vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
     sqlite3DbFree(db, pSub);
   }
-  if( p->magic!=VDBE_MAGIC_INIT ){
+  if( p->iVdbeMagic!=VDBE_MAGIC_INIT ){
     releaseMemArray(p->aVar, p->nVar);
     sqlite3DbFree(db, p->pVList);
     sqlite3DbFree(db, p->pFree);
@@ -81476,7 +82663,7 @@ SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
   if( p->pNext ){
     p->pNext->pPrev = p->pPrev;
   }
-  p->magic = VDBE_MAGIC_DEAD;
+  p->iVdbeMagic = VDBE_MAGIC_DEAD;
   p->db = 0;
   sqlite3DbFreeNN(db, p);
 }
@@ -81494,7 +82681,7 @@ SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){
   assert( p->deferredMoveto );
   assert( p->isTable );
   assert( p->eCurType==CURTYPE_BTREE );
-  rc = sqlite3BtreeMovetoUnpacked(p->uc.pCursor, 0, p->movetoTarget, 0, &res);
+  rc = sqlite3BtreeTableMoveto(p->uc.pCursor, p->movetoTarget, 0, &res);
   if( rc ) return rc;
   if( res!=0 ) return SQLITE_CORRUPT_BKPT;
 #ifdef SQLITE_TEST
@@ -81553,6 +82740,7 @@ SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor **pp, u32 *piCol){
   assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
   if( p->deferredMoveto ){
     u32 iMap;
+    assert( !p->isEphemeral );
     if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 && !p->nullRow ){
       *pp = p->pAltCursor;
       *piCol = iMap - 1;
@@ -82277,7 +83465,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem
 ** number.  Return negative, zero, or positive if the first (i64) is less than,
 ** equal to, or greater than the second (double).
 */
-static int sqlite3IntFloatCompare(i64 i, double r){
+SQLITE_PRIVATE int sqlite3IntFloatCompare(i64 i, double r){
   if( sizeof(LONGDOUBLE_TYPE)>8 ){
     LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
     testcase( x<r );
@@ -83001,7 +84189,7 @@ SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(
 ** This routine sets the value to be returned by subsequent calls to
 ** sqlite3_changes() on the database handle 'db'.
 */
-SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
+SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, i64 nChange){
   assert( sqlite3_mutex_held(db->mutex) );
   db->nChange = nChange;
   db->nTotalChange += nChange;
@@ -83181,7 +84369,8 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
   const char *zDb,                /* Database name */
   Table *pTab,                    /* Modified table */
   i64 iKey1,                      /* Initial key value */
-  int iReg                        /* Register for new.* record */
+  int iReg,                       /* Register for new.* record */
+  int iBlobWrite
 ){
   sqlite3 *db = v->db;
   i64 iKey2;
@@ -83202,6 +84391,8 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
     }
   }
 
+  assert( pCsr!=0 );
+  assert( pCsr->eCurType==CURTYPE_BTREE );
   assert( pCsr->nField==pTab->nCol
        || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
   );
@@ -83217,6 +84408,7 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
   preupdate.iKey1 = iKey1;
   preupdate.iKey2 = iKey2;
   preupdate.pTab = pTab;
+  preupdate.iBlobWrite = iBlobWrite;
 
   db->pPreUpdate = &preupdate;
   db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2);
@@ -83600,8 +84792,8 @@ SQLITE_API void sqlite3_value_free(sqlite3_value *pOld){
 ** the function result.
 **
 ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the
-** result as a string or blob but if the string or blob is too large, it
-** then sets the error code to SQLITE_TOOBIG
+** result as a string or blob.  Appropriate errors are set if the string/blob
+** is too big or if an OOM occurs.
 **
 ** The invokeValueDestructor(P,X) routine invokes destructor function X()
 ** on value P is not going to be used and need to be destroyed.
@@ -83613,8 +84805,16 @@ static void setResultStrOrError(
   u8 enc,                 /* Encoding of z.  0 for BLOBs */
   void (*xDel)(void*)     /* Destructor function */
 ){
-  if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){
-    sqlite3_result_error_toobig(pCtx);
+  int rc = sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel);
+  if( rc ){
+    if( rc==SQLITE_TOOBIG ){
+      sqlite3_result_error_toobig(pCtx);
+    }else{
+      /* The only errors possible from sqlite3VdbeMemSetStr are
+      ** SQLITE_TOOBIG and SQLITE_NOMEM */
+      assert( rc==SQLITE_NOMEM );
+      sqlite3_result_error_nomem(pCtx);
+    }
   }
 }
 static int invokeValueDestructor(
@@ -83630,7 +84830,7 @@ static int invokeValueDestructor(
   }else{
     xDel((void*)p);
   }
-  if( pCtx ) sqlite3_result_error_toobig(pCtx);
+  sqlite3_result_error_toobig(pCtx);
   return SQLITE_TOOBIG;
 }
 SQLITE_API void sqlite3_result_blob(
@@ -83771,8 +84971,12 @@ SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
   if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
     return SQLITE_TOOBIG;
   }
+#ifndef SQLITE_OMIT_INCRBLOB
   sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
   return SQLITE_OK;
+#else
+  return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
+#endif
 }
 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
   pCtx->isError = errCode ? errCode : -1;
@@ -83855,7 +85059,7 @@ static int sqlite3Step(Vdbe *p){
   int rc;
 
   assert(p);
-  if( p->magic!=VDBE_MAGIC_RUN ){
+  if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){
     /* We used to require that sqlite3_reset() be called before retrying
     ** sqlite3_step() after any error or after SQLITE_DONE.  But beginning
     ** with version 3.7.0, we changed this so that sqlite3_reset() would
@@ -84571,7 +85775,7 @@ static int vdbeUnbind(Vdbe *p, int i){
     return SQLITE_MISUSE_BKPT;
   }
   sqlite3_mutex_enter(p->db->mutex);
-  if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
+  if( p->iVdbeMagic!=VDBE_MAGIC_RUN || p->pc>=0 ){
     sqlite3Error(p->db, SQLITE_MISUSE);
     sqlite3_mutex_leave(p->db->mutex);
     sqlite3_log(SQLITE_MISUSE,
@@ -84612,7 +85816,7 @@ static int bindText(
   sqlite3_stmt *pStmt,   /* The statement to bind against */
   int i,                 /* Index of the parameter to bind */
   const void *zData,     /* Pointer to the data to be bound */
-  int nData,             /* Number of bytes of data to be bound */
+  i64 nData,             /* Number of bytes of data to be bound */
   void (*xDel)(void*),   /* Destructor for the data */
   u8 encoding            /* Encoding for the data */
 ){
@@ -84664,11 +85868,7 @@ SQLITE_API int sqlite3_bind_blob64(
   void (*xDel)(void*)
 ){
   assert( xDel!=SQLITE_DYNAMIC );
-  if( nData>0x7fffffff ){
-    return invokeValueDestructor(zData, xDel, 0);
-  }else{
-    return bindText(pStmt, i, zData, (int)nData, xDel, 0);
-  }
+  return bindText(pStmt, i, zData, nData, xDel, 0);
 }
 SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
   int rc;
@@ -84738,12 +85938,8 @@ SQLITE_API int sqlite3_bind_text64(
   unsigned char enc
 ){
   assert( xDel!=SQLITE_DYNAMIC );
-  if( nData>0x7fffffff ){
-    return invokeValueDestructor(zData, xDel, 0);
-  }else{
-    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
-    return bindText(pStmt, i, zData, (int)nData, xDel, enc);
-  }
+  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
+  return bindText(pStmt, i, zData, nData, xDel, enc);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API int sqlite3_bind_text16(
@@ -84792,7 +85988,11 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);
   if( rc==SQLITE_OK ){
+#ifndef SQLITE_OMIT_INCRBLOB
     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
+#else
+    rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
+#endif
     sqlite3_mutex_leave(p->db->mutex);
   }
   return rc;
@@ -84925,7 +86125,7 @@ SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
 */
 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
   Vdbe *v = (Vdbe*)pStmt;
-  return v!=0 && v->magic==VDBE_MAGIC_RUN && v->pc>=0;
+  return v!=0 && v->iVdbeMagic==VDBE_MAGIC_RUN && v->pc>=0;
 }
 
 /*
@@ -85080,6 +86280,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppVa
     u32 nRec;
     u8 *aRec;
 
+    assert( p->pCsr->eCurType==CURTYPE_BTREE );
     nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
     aRec = sqlite3DbMallocRaw(db, nRec);
     if( !aRec ) goto preupdate_old_out;
@@ -85143,6 +86344,17 @@ SQLITE_API int sqlite3_preupdate_depth(sqlite3 *db){
 }
 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
 
+#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
+/*
+** This function is designed to be called from within a pre-update callback
+** only.
+*/
+SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *db){
+  PreUpdate *p = db->pPreUpdate;
+  return (p ? p->iBlobWrite : -1);
+}
+#endif
+
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
 /*
 ** This function is called from within a pre-update callback to retrieve
@@ -85376,11 +86588,9 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
 #ifndef SQLITE_OMIT_UTF16
   Mem utf8;                /* Used to convert UTF16 into UTF8 for display */
 #endif
-  char zBase[100];         /* Initial working space */
 
   db = p->db;
-  sqlite3StrAccumInit(&out, 0, zBase, sizeof(zBase),
-                      db->aLimit[SQLITE_LIMIT_LENGTH]);
+  sqlite3StrAccumInit(&out, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
   if( db->nVdbeExec>1 ){
     while( *zRawSql ){
       const char *zStart = zRawSql;
@@ -85417,7 +86627,7 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
         assert( idx>0 );
       }
       zRawSql += nToken;
-      nextIndex = idx + 1;
+      nextIndex = MAX(idx + 1, nextIndex);
       assert( idx>0 && idx<=p->nVar );
       pVar = &p->aVar[idx-1];
       if( pVar->flags & MEM_Null ){
@@ -85761,26 +86971,39 @@ static VdbeCursor *allocateCursor(
 
   assert( iCur>=0 && iCur<p->nCursor );
   if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
-    /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag
-    ** is clear. Otherwise, if this is an ephemeral cursor created by
-    ** OP_OpenDup, the cursor will not be closed and will still be part
-    ** of a BtShared.pCursor list.  */
-    if( p->apCsr[iCur]->pBtx==0 ) p->apCsr[iCur]->isEphemeral = 0;
     sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
     p->apCsr[iCur] = 0;
   }
-  if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){
-    p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
-    memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
-    pCx->eCurType = eCurType;
-    pCx->iDb = iDb;
-    pCx->nField = nField;
-    pCx->aOffset = &pCx->aType[nField];
-    if( eCurType==CURTYPE_BTREE ){
-      pCx->uc.pCursor = (BtCursor*)
-          &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
-      sqlite3BtreeCursorZero(pCx->uc.pCursor);
+
+  /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure
+  ** the pMem used to hold space for the cursor has enough storage available
+  ** in pMem->zMalloc.  But for the special case of the aMem[] entries used
+  ** to hold cursors, it is faster to in-line the logic. */
+  assert( pMem->flags==MEM_Undefined );
+  assert( (pMem->flags & MEM_Dyn)==0 );
+  assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc );
+  if( pMem->szMalloc<nByte ){
+    if( pMem->szMalloc>0 ){
+      sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
+    }
+    pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte);
+    if( pMem->zMalloc==0 ){
+      pMem->szMalloc = 0;
+      return 0;
     }
+    pMem->szMalloc = nByte;
+  }
+
+  p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc;
+  memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
+  pCx->eCurType = eCurType;
+  pCx->iDb = iDb;
+  pCx->nField = nField;
+  pCx->aOffset = &pCx->aType[nField];
+  if( eCurType==CURTYPE_BTREE ){
+    pCx->uc.pCursor = (BtCursor*)
+        &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
+    sqlite3BtreeCursorZero(pCx->uc.pCursor);
   }
   return pCx;
 }
@@ -85927,7 +87150,10 @@ static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
   sqlite3_int64 ix;
   assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
   assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
-  ExpandBlob(pMem);
+  if( ExpandBlob(pMem) ){
+    pMem->u.i = 0;
+    return MEM_Int;
+  }
   rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
   if( rc<=0 ){
     if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
@@ -86065,6 +87291,11 @@ static void registerTrace(int iReg, Mem *p){
   printf("\n");
   sqlite3VdbeCheckMemInvariants(p);
 }
+/**/ void sqlite3PrintMem(Mem *pMem){
+  memTracePrint(pMem);
+  printf("\n");
+  fflush(stdout);
+}
 #endif
 
 #ifdef SQLITE_DEBUG
@@ -86092,96 +87323,7 @@ SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){
 ** hwtime.h contains inline assembler code for implementing
 ** high-performance timing routines.
 */
-/************** Include hwtime.h in the middle of vdbe.c *********************/
-/************** Begin file hwtime.h ******************************************/
-/*
-** 2008 May 27
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file contains inline asm code for retrieving "high-performance"
-** counters for x86 and x86_64 class CPUs.
-*/
-#ifndef SQLITE_HWTIME_H
-#define SQLITE_HWTIME_H
-
-/*
-** The following routine only works on pentium-class (or newer) processors.
-** It uses the RDTSC opcode to read the cycle count value out of the
-** processor and returns that value.  This can be used for high-res
-** profiling.
-*/
-#if !defined(__STRICT_ANSI__) && \
-    (defined(__GNUC__) || defined(_MSC_VER)) && \
-    (defined(i386) || defined(__i386__) || defined(_M_IX86))
-
-  #if defined(__GNUC__)
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-     unsigned int lo, hi;
-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
-     return (sqlite_uint64)hi << 32 | lo;
-  }
-
-  #elif defined(_MSC_VER)
-
-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
-     __asm {
-        rdtsc
-        ret       ; return value at EDX:EAX
-     }
-  }
-
-  #endif
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long val;
-      __asm__ __volatile__ ("rdtsc" : "=A" (val));
-      return val;
-  }
-
-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
-
-  __inline__ sqlite_uint64 sqlite3Hwtime(void){
-      unsigned long long retval;
-      unsigned long junk;
-      __asm__ __volatile__ ("\n\
-          1:      mftbu   %1\n\
-                  mftb    %L0\n\
-                  mftbu   %0\n\
-                  cmpw    %0,%1\n\
-                  bne     1b"
-                  : "=r" (retval), "=r" (junk));
-      return retval;
-  }
-
-#else
-
-  /*
-  ** asm() is needed for hardware timing support.  Without asm(),
-  ** disable the sqlite3Hwtime() routine.
-  **
-  ** sqlite3Hwtime() is only used for some obscure debugging
-  ** and analysis configurations, not in any deliverable, so this
-  ** should not be a great loss.
-  */
-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
-
-#endif
-
-#endif /* !defined(SQLITE_HWTIME_H) */
-
-/************** End of hwtime.h **********************************************/
-/************** Continuing where we left off in vdbe.c ***********************/
+/* #include "hwtime.h" */
 
 #endif
 
@@ -86228,6 +87370,19 @@ static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
   }
 }
 
+/*
+** Return the symbolic name for the data type of a pMem
+*/
+static const char *vdbeMemTypeName(Mem *pMem){
+  static const char *azTypes[] = {
+      /* SQLITE_INTEGER */ "INT",
+      /* SQLITE_FLOAT   */ "REAL",
+      /* SQLITE_TEXT    */ "TEXT",
+      /* SQLITE_BLOB    */ "BLOB",
+      /* SQLITE_NULL    */ "NULL"
+  };
+  return azTypes[sqlite3_value_type(pMem)-1];
+}
 
 /*
 ** Execute as much of a VDBE program as we can.
@@ -86263,7 +87418,7 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
 #endif
   /*** INSERT STACK UNION HERE ***/
 
-  assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
+  assert( p->iVdbeMagic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
   sqlite3VdbeEnter(p);
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
   if( db->xProgress ){
@@ -87023,6 +88178,26 @@ case OP_IntCopy: {            /* out2 */
   break;
 }
 
+/* Opcode: ChngCntRow P1 P2 * * *
+** Synopsis: output=r[P1]
+**
+** Output value in register P1 as the chance count for a DML statement,
+** due to the "PRAGMA count_changes=ON" setting.  Or, if there was a
+** foreign key error in the statement, trigger the error now.
+**
+** This opcode is a variant of OP_ResultRow that checks the foreign key
+** immediate constraint count and throws an error if the count is
+** non-zero.  The P2 opcode must be 1.
+*/
+case OP_ChngCntRow: {
+  assert( pOp->p2==1 );
+  if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){
+    goto abort_due_to_error;
+  }
+  /* Fall through to the next case, OP_ResultRow */
+  /* no break */ deliberate_fall_through
+}
+
 /* Opcode: ResultRow P1 P2 * * *
 ** Synopsis: output=r[P1@P2]
 **
@@ -87036,37 +88211,9 @@ case OP_ResultRow: {
   Mem *pMem;
   int i;
   assert( p->nResColumn==pOp->p2 );
-  assert( pOp->p1>0 );
+  assert( pOp->p1>0 || CORRUPT_DB );
   assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
 
-  /* If this statement has violated immediate foreign key constraints, do
-  ** not return the number of rows modified. And do not RELEASE the statement
-  ** transaction. It needs to be rolled back.  */
-  if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
-    assert( db->flags&SQLITE_CountRows );
-    assert( p->usesStmtJournal );
-    goto abort_due_to_error;
-  }
-
-  /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
-  ** DML statements invoke this opcode to return the number of rows
-  ** modified to the user. This is the only way that a VM that
-  ** opens a statement transaction may invoke this opcode.
-  **
-  ** In case this is such a statement, close any statement transaction
-  ** opened by this VM before returning control to the user. This is to
-  ** ensure that statement-transactions are always nested, not overlapping.
-  ** If the open statement-transaction is not closed here, then the user
-  ** may step another VM that opens its own statement transaction. This
-  ** may lead to overlapping statement transactions.
-  **
-  ** The statement transaction is never a top-level transaction.  Hence
-  ** the RELEASE call below can never fail.
-  */
-  assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
-  rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
-  assert( rc==SQLITE_OK );
-
   /* Invalidate all ephemeral cursor row caches */
   p->cacheCtr = (p->cacheCtr + 2)|1;
 
@@ -87506,8 +88653,7 @@ case OP_Cast: {                  /* in1 */
 ** Synopsis: IF r[P3]==r[P1]
 **
 ** Compare the values in register P1 and P3.  If reg(P3)==reg(P1) then
-** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5, then
-** store the result of comparison in register P2.
+** jump to address P2.
 **
 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
 ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
@@ -87533,9 +88679,8 @@ case OP_Cast: {                  /* in1 */
 ** If neither operand is NULL the result is the same as it would be if
 ** the SQLITE_NULLEQ flag were omitted from P5.
 **
-** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
-** content of r[P2] is only changed if the new value is NULL or 0 (false).
-** In other words, a prior r[P2] value will not be overwritten by 1 (true).
+** This opcode saves the result of comparison for use by the new
+** OP_Jump opcode.
 */
 /* Opcode: Ne P1 P2 P3 P4 P5
 ** Synopsis: IF r[P3]!=r[P1]
@@ -87543,17 +88688,12 @@ case OP_Cast: {                  /* in1 */
 ** This works just like the Eq opcode except that the jump is taken if
 ** the operands in registers P1 and P3 are not equal.  See the Eq opcode for
 ** additional information.
-**
-** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
-** content of r[P2] is only changed if the new value is NULL or 1 (true).
-** In other words, a prior r[P2] value will not be overwritten by 0 (false).
 */
 /* Opcode: Lt P1 P2 P3 P4 P5
 ** Synopsis: IF r[P3]<r[P1]
 **
 ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
-** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5 store
-** the result of comparison (0 or 1 or NULL) into register P2.
+** jump to address P2.
 **
 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
 ** reg(P3) is NULL then the take the jump.  If the SQLITE_JUMPIFNULL
@@ -87576,6 +88716,9 @@ case OP_Cast: {                  /* in1 */
 ** numeric, then a numeric comparison is used. If the two values
 ** are of different types, then numbers are considered less than
 ** strings and strings are considered less than blobs.
+**
+** This opcode saves the result of comparison for use by the new
+** OP_Jump opcode.
 */
 /* Opcode: Le P1 P2 P3 P4 P5
 ** Synopsis: IF r[P3]<=r[P1]
@@ -87613,6 +88756,31 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
   pIn3 = &aMem[pOp->p3];
   flags1 = pIn1->flags;
   flags3 = pIn3->flags;
+  if( (flags1 & flags3 & MEM_Int)!=0 ){
+    assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB );
+    /* Common case of comparison of two integers */
+    if( pIn3->u.i > pIn1->u.i ){
+      iCompare = +1;
+      if( sqlite3aGTb[pOp->opcode] ){
+        VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
+        goto jump_to_p2;
+      }
+    }else if( pIn3->u.i < pIn1->u.i ){
+      iCompare = -1;
+      if( sqlite3aLTb[pOp->opcode] ){
+        VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
+        goto jump_to_p2;
+      }
+    }else{
+      iCompare = 0;
+      if( sqlite3aEQb[pOp->opcode] ){
+        VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
+        goto jump_to_p2;
+      }
+    }
+    VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
+    break;
+  }
   if( (flags1 | flags3)&MEM_Null ){
     /* One or both operands are NULL */
     if( pOp->p5 & SQLITE_NULLEQ ){
@@ -87635,22 +88803,16 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
       ** then the result is always NULL.
       ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
       */
-      if( pOp->p5 & SQLITE_STOREP2 ){
-        pOut = &aMem[pOp->p2];
-        iCompare = 1;    /* Operands are not equal */
-        memAboutToChange(p, pOut);
-        MemSetTypeFlag(pOut, MEM_Null);
-        REGISTER_TRACE(pOp->p2, pOut);
-      }else{
-        VdbeBranchTaken(2,3);
-        if( pOp->p5 & SQLITE_JUMPIFNULL ){
-          goto jump_to_p2;
-        }
+      iCompare = 1;    /* Operands are not equal */
+      VdbeBranchTaken(2,3);
+      if( pOp->p5 & SQLITE_JUMPIFNULL ){
+        goto jump_to_p2;
       }
       break;
     }
   }else{
-    /* Neither operand is NULL.  Do a comparison. */
+    /* Neither operand is NULL and we couldn't do the special high-speed
+    ** integer comparison case.  So do a general-case comparison. */
     affinity = pOp->p5 & SQLITE_AFF_MASK;
     if( affinity>=SQLITE_AFF_NUMERIC ){
       if( (flags1 | flags3)&MEM_Str ){
@@ -87663,14 +88825,6 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
           applyNumericAffinity(pIn3,0);
         }
       }
-      /* Handle the common case of integer comparison here, as an
-      ** optimization, to avoid a call to sqlite3MemCompare() */
-      if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){
-        if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; }
-        if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; }
-        res = 0;
-        goto compare_op;
-      }
     }else if( affinity==SQLITE_AFF_TEXT ){
       if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
         testcase( pIn1->flags & MEM_Int );
@@ -87693,7 +88847,7 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
     assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
     res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
   }
-compare_op:
+
   /* At this point, res is negative, zero, or positive if reg[P1] is
   ** less than, equal to, or greater than reg[P3], respectively.  Compute
   ** the answer to this operator in res2, depending on what the comparison
@@ -87702,16 +88856,14 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
   ** order:  NE, EQ, GT, LE, LT, GE */
   assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
   assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
-  if( res<0 ){                        /* ne, eq, gt, le, lt, ge */
-    static const unsigned char aLTb[] = { 1,  0,  0,  1,  1,  0 };
-    res2 = aLTb[pOp->opcode - OP_Ne];
+  if( res<0 ){
+    res2 = sqlite3aLTb[pOp->opcode];
   }else if( res==0 ){
-    static const unsigned char aEQb[] = { 0,  1,  0,  1,  0,  1 };
-    res2 = aEQb[pOp->opcode - OP_Ne];
+    res2 = sqlite3aEQb[pOp->opcode];
   }else{
-    static const unsigned char aGTb[] = { 1,  0,  1,  0,  0,  1 };
-    res2 = aGTb[pOp->opcode - OP_Ne];
+    res2 = sqlite3aGTb[pOp->opcode];
   }
+  iCompare = res;
 
   /* Undo any changes made by applyAffinity() to the input registers. */
   assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
@@ -87719,67 +88871,39 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
   assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
   pIn1->flags = flags1;
 
-  if( pOp->p5 & SQLITE_STOREP2 ){
-    pOut = &aMem[pOp->p2];
-    iCompare = res;
-    if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){
-      /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1
-      ** and prevents OP_Ne from overwriting NULL with 0.  This flag
-      ** is only used in contexts where either:
-      **   (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0)
-      **   (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1)
-      ** Therefore it is not necessary to check the content of r[P2] for
-      ** NULL. */
-      assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq );
-      assert( res2==0 || res2==1 );
-      testcase( res2==0 && pOp->opcode==OP_Eq );
-      testcase( res2==1 && pOp->opcode==OP_Eq );
-      testcase( res2==0 && pOp->opcode==OP_Ne );
-      testcase( res2==1 && pOp->opcode==OP_Ne );
-      if( (pOp->opcode==OP_Eq)==res2 ) break;
-    }
-    memAboutToChange(p, pOut);
-    MemSetTypeFlag(pOut, MEM_Int);
-    pOut->u.i = res2;
-    REGISTER_TRACE(pOp->p2, pOut);
-  }else{
-    VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
-    if( res2 ){
-      goto jump_to_p2;
-    }
+  VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
+  if( res2 ){
+    goto jump_to_p2;
   }
   break;
 }
 
-/* Opcode: ElseNotEq * P2 * * *
+/* Opcode: ElseEq * P2 * * *
 **
 ** This opcode must follow an OP_Lt or OP_Gt comparison operator.  There
 ** can be zero or more OP_ReleaseReg opcodes intervening, but no other
 ** opcodes are allowed to occur between this instruction and the previous
-** OP_Lt or OP_Gt.  Furthermore, the prior OP_Lt or OP_Gt must have the
-** SQLITE_STOREP2 bit set in the P5 field.
+** OP_Lt or OP_Gt.
 **
 ** If result of an OP_Eq comparison on the same two operands as the
-** prior OP_Lt or OP_Gt would have been NULL or false (0), then then
-** jump to P2.  If the result of an OP_Eq comparison on the two previous
-** operands would have been true (1), then fall through.
+** prior OP_Lt or OP_Gt would have been true, then jump to P2.
+** If the result of an OP_Eq comparison on the two previous
+** operands would have been false or NULL, then fall through.
 */
-case OP_ElseNotEq: {       /* same as TK_ESCAPE, jump */
+case OP_ElseEq: {       /* same as TK_ESCAPE, jump */
 
 #ifdef SQLITE_DEBUG
   /* Verify the preconditions of this opcode - that it follows an OP_Lt or
-  ** OP_Gt with the SQLITE_STOREP2 flag set, with zero or more intervening
-  ** OP_ReleaseReg opcodes */
+  ** OP_Gt with zero or more intervening OP_ReleaseReg opcodes */
   int iAddr;
   for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
     if( aOp[iAddr].opcode==OP_ReleaseReg ) continue;
     assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt );
-    assert( aOp[iAddr].p5 & SQLITE_STOREP2 );
     break;
   }
 #endif /* SQLITE_DEBUG */
-  VdbeBranchTaken(iCompare!=0, 2);
-  if( iCompare!=0 ) goto jump_to_p2;
+  VdbeBranchTaken(iCompare==0, 2);
+  if( iCompare==0 ) goto jump_to_p2;
   break;
 }
 
@@ -88090,6 +89214,40 @@ case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
   break;
 }
 
+/* Opcode: IsNullOrType P1 P2 P3 * *
+** Synopsis: if typeof(r[P1]) IN (P3,5) goto P2
+**
+** Jump to P2 if the value in register P1 is NULL or has a datatype P3.
+** P3 is an integer which should be one of SQLITE_INTEGER, SQLITE_FLOAT,
+** SQLITE_BLOB, SQLITE_NULL, or SQLITE_TEXT.
+*/
+case OP_IsNullOrType: {      /* jump, in1 */
+  int doTheJump;
+  pIn1 = &aMem[pOp->p1];
+  doTheJump = (pIn1->flags & MEM_Null)!=0 || sqlite3_value_type(pIn1)==pOp->p3;
+  VdbeBranchTaken( doTheJump, 2);
+  if( doTheJump ) goto jump_to_p2;
+  break;
+}
+
+/* Opcode: ZeroOrNull P1 P2 P3 * *
+** Synopsis: r[P2] = 0 OR NULL
+**
+** If all both registers P1 and P3 are NOT NULL, then store a zero in
+** register P2.  If either registers P1 or P3 are NULL then put
+** a NULL in register P2.
+*/
+case OP_ZeroOrNull: {            /* in1, in2, out2, in3 */
+  if( (aMem[pOp->p1].flags & MEM_Null)!=0
+   || (aMem[pOp->p3].flags & MEM_Null)!=0
+  ){
+    sqlite3VdbeMemSetNull(aMem + pOp->p2);
+  }else{
+    sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0);
+  }
+  break;
+}
+
 /* Opcode: NotNull P1 P2 * * *
 ** Synopsis: if r[P1]!=NULL goto P2
 **
@@ -88440,6 +89598,108 @@ case OP_Column: {
   }
 }
 
+/* Opcode: TypeCheck P1 P2 P3 P4 *
+** Synopsis: typecheck(r[P1@P2])
+**
+** Apply affinities to the range of P2 registers beginning with P1.
+** Take the affinities from the Table object in P4.  If any value
+** cannot be coerced into the correct type, then raise an error.
+**
+** This opcode is similar to OP_Affinity except that this opcode
+** forces the register type to the Table column type.  This is used
+** to implement "strict affinity".
+**
+** GENERATED ALWAYS AS ... STATIC columns are only checked if P3
+** is zero.  When P3 is non-zero, no type checking occurs for
+** static generated columns.  Virtual columns are computed at query time
+** and so they are never checked.
+**
+** Preconditions:
+**
+** <ul>
+** <li> P2 should be the number of non-virtual columns in the
+**      table of P4.
+** <li> Table P4 should be a STRICT table.
+** </ul>
+**
+** If any precondition is false, an assertion fault occurs.
+*/
+case OP_TypeCheck: {
+  Table *pTab;
+  Column *aCol;
+  int i;
+
+  assert( pOp->p4type==P4_TABLE );
+  pTab = pOp->p4.pTab;
+  assert( pTab->tabFlags & TF_Strict );
+  assert( pTab->nNVCol==pOp->p2 );
+  aCol = pTab->aCol;
+  pIn1 = &aMem[pOp->p1];
+  for(i=0; i<pTab->nCol; i++){
+    if( aCol[i].colFlags & COLFLAG_GENERATED ){
+      if( aCol[i].colFlags & COLFLAG_VIRTUAL ) continue;
+      if( pOp->p3 ){ pIn1++; continue; }
+    }
+    assert( pIn1 < &aMem[pOp->p1+pOp->p2] );
+    applyAffinity(pIn1, aCol[i].affinity, encoding);
+    if( (pIn1->flags & MEM_Null)==0 ){
+      switch( aCol[i].eCType ){
+        case COLTYPE_BLOB: {
+          if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error;
+          break;
+        }
+        case COLTYPE_INTEGER:
+        case COLTYPE_INT: {
+          if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error;
+          break;
+        }
+        case COLTYPE_TEXT: {
+          if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error;
+          break;
+        }
+        case COLTYPE_REAL: {
+          if( pIn1->flags & MEM_Int ){
+            /* When applying REAL affinity, if the result is still an MEM_Int
+            ** that will fit in 6 bytes, then change the type to MEM_IntReal
+            ** so that we keep the high-resolution integer value but know that
+            ** the type really wants to be REAL. */
+            testcase( pIn1->u.i==140737488355328LL );
+            testcase( pIn1->u.i==140737488355327LL );
+            testcase( pIn1->u.i==-140737488355328LL );
+            testcase( pIn1->u.i==-140737488355329LL );
+            if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){
+              pIn1->flags |= MEM_IntReal;
+              pIn1->flags &= ~MEM_Int;
+            }else{
+              pIn1->u.r = (double)pIn1->u.i;
+              pIn1->flags |= MEM_Real;
+              pIn1->flags &= ~MEM_Int;
+            }
+          }else if( (pIn1->flags & MEM_Real)==0 ){
+            goto vdbe_type_error;
+          }
+          break;
+        }
+        default: {
+          /* COLTYPE_ANY.  Accept anything. */
+          break;
+        }
+      }
+    }
+    REGISTER_TRACE((int)(pIn1-aMem), pIn1);
+    pIn1++;
+  }
+  assert( pIn1 == &aMem[pOp->p1+pOp->p2] );
+  break;
+
+vdbe_type_error:
+  sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s",
+     vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1],
+     pTab->zName, aCol[i].zCnName);
+  rc = SQLITE_CONSTRAINT_DATATYPE;
+  goto abort_due_to_error;
+}
+
 /* Opcode: Affinity P1 P2 * P4 *
 ** Synopsis: affinity(r[P1@P2])
 **
@@ -89103,8 +90363,16 @@ case OP_Transaction: {
   assert( pOp->p2>=0 && pOp->p2<=2 );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( DbMaskTest(p->btreeMask, pOp->p1) );
-  if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
-    rc = SQLITE_READONLY;
+  assert( rc==SQLITE_OK );
+  if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){
+    if( db->flags & SQLITE_QueryOnly ){
+      /* Writes prohibited by the "PRAGMA query_only=TRUE" statement */
+      rc = SQLITE_READONLY;
+    }else{
+      /* Writes prohibited due to a prior SQLITE_CORRUPT in the current
+      ** transaction */
+      rc = SQLITE_CORRUPT;
+    }
     goto abort_due_to_error;
   }
   pBt = db->aDb[pOp->p1].pBt;
@@ -89146,7 +90414,8 @@ case OP_Transaction: {
     }
   }
   assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
-  if( pOp->p5
+  if( rc==SQLITE_OK
+   && pOp->p5
    && (iMeta!=pOp->p3
       || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
   ){
@@ -89356,6 +90625,8 @@ case OP_ReopenIdx: {
   pCur = p->apCsr[pOp->p1];
   if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
     assert( pCur->iDb==pOp->p3 );      /* Guaranteed by the code generator */
+    assert( pCur->eCurType==CURTYPE_BTREE );
+    sqlite3BtreeClearCursor(pCur->uc.pCursor);
     goto open_cursor_set_hints;
   }
   /* If the cursor is not currently open or is open on a different
@@ -89459,7 +90730,7 @@ case OP_OpenDup: {
 
   pOrig = p->apCsr[pOp->p2];
   assert( pOrig );
-  assert( pOrig->pBtx!=0 );  /* Only ephemeral cursors can be duplicated */
+  assert( pOrig->isEphemeral );  /* Only ephemeral cursors can be duplicated */
 
   pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE);
   if( pCx==0 ) goto no_mem;
@@ -89469,7 +90740,10 @@ case OP_OpenDup: {
   pCx->isTable = pOrig->isTable;
   pCx->pgnoRoot = pOrig->pgnoRoot;
   pCx->isOrdered = pOrig->isOrdered;
-  rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
+  pCx->pBtx = pOrig->pBtx;
+  pCx->hasBeenDuped = 1;
+  pOrig->hasBeenDuped = 1;
+  rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
                           pCx->pKeyInfo, pCx->uc.pCursor);
   /* The sqlite3BtreeCursor() routine can only fail for the first cursor
   ** opened for a database.  Since there is already an open cursor when this
@@ -89535,9 +90809,10 @@ case OP_OpenEphemeral: {
     aMem[pOp->p3].z = "";
   }
   pCx = p->apCsr[pOp->p1];
-  if( pCx && pCx->pBtx ){
-    /* If the ephermeral table is already open, erase all existing content
-    ** so that the table is empty again, rather than creating a new table. */
+  if( pCx && !pCx->hasBeenDuped &&  ALWAYS(pOp->p2<=pCx->nField) ){
+    /* If the ephermeral table is already open and has no duplicates from
+    ** OP_OpenDup, then erase all existing content so that the table is
+    ** empty again, rather than creating a new table. */
     assert( pCx->isEphemeral );
     pCx->seqCount = 0;
     pCx->cacheStatus = CACHE_STALE;
@@ -89551,33 +90826,36 @@ case OP_OpenEphemeral: {
                           vfsFlags);
     if( rc==SQLITE_OK ){
       rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0);
-    }
-    if( rc==SQLITE_OK ){
-      /* If a transient index is required, create it by calling
-      ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
-      ** opening it. If a transient table is required, just use the
-      ** automatically created table with root-page 1 (an BLOB_INTKEY table).
-      */
-      if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
-        assert( pOp->p4type==P4_KEYINFO );
-        rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot,
-                                     BTREE_BLOBKEY | pOp->p5);
-        if( rc==SQLITE_OK ){
-          assert( pCx->pgnoRoot==SCHEMA_ROOT+1 );
-          assert( pKeyInfo->db==db );
-          assert( pKeyInfo->enc==ENC(db) );
-          rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
-                                  pKeyInfo, pCx->uc.pCursor);
+      if( rc==SQLITE_OK ){
+        /* If a transient index is required, create it by calling
+        ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
+        ** opening it. If a transient table is required, just use the
+        ** automatically created table with root-page 1 (an BLOB_INTKEY table).
+        */
+        if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
+          assert( pOp->p4type==P4_KEYINFO );
+          rc = sqlite3BtreeCreateTable(pCx->pBtx, &pCx->pgnoRoot,
+              BTREE_BLOBKEY | pOp->p5);
+          if( rc==SQLITE_OK ){
+            assert( pCx->pgnoRoot==SCHEMA_ROOT+1 );
+            assert( pKeyInfo->db==db );
+            assert( pKeyInfo->enc==ENC(db) );
+            rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
+                pKeyInfo, pCx->uc.pCursor);
+          }
+          pCx->isTable = 0;
+        }else{
+          pCx->pgnoRoot = SCHEMA_ROOT;
+          rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR,
+              0, pCx->uc.pCursor);
+          pCx->isTable = 1;
         }
-        pCx->isTable = 0;
-      }else{
-        pCx->pgnoRoot = SCHEMA_ROOT;
-        rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR,
-                                0, pCx->uc.pCursor);
-        pCx->isTable = 1;
+      }
+      pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
+      if( rc ){
+        sqlite3BtreeClose(pCx->pBtx);
       }
     }
-    pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
   }
   if( rc ) goto abort_due_to_error;
   pCx->nullRow = 1;
@@ -89836,6 +91114,7 @@ case OP_SeekGT: {       /* jump, in3, group */
     /* If the P3 value could not be converted into an integer without
     ** loss of information, then special processing is required... */
     if( (newType & (MEM_Int|MEM_IntReal))==0 ){
+      int c;
       if( (newType & MEM_Real)==0 ){
         if( (newType & MEM_Null) || oc>=OP_SeekGE ){
           VdbeBranchTaken(1,2);
@@ -89845,7 +91124,8 @@ case OP_SeekGT: {       /* jump, in3, group */
           if( rc!=SQLITE_OK ) goto abort_due_to_error;
           goto seek_not_found;
         }
-      }else
+      }
+      c = sqlite3IntFloatCompare(iKey, pIn3->u.r);
 
       /* If the approximation iKey is larger than the actual real search
       ** term, substitute >= for > and < for <=. e.g. if the search term
@@ -89854,7 +91134,7 @@ case OP_SeekGT: {       /* jump, in3, group */
       **        (x >  4.9)    ->     (x >= 5)
       **        (x <= 4.9)    ->     (x <  5)
       */
-      if( pIn3->u.r<(double)iKey ){
+      if( c>0 ){
         assert( OP_SeekGE==(OP_SeekGT-1) );
         assert( OP_SeekLT==(OP_SeekLE-1) );
         assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
@@ -89863,14 +91143,14 @@ case OP_SeekGT: {       /* jump, in3, group */
 
       /* If the approximation iKey is smaller than the actual real search
       ** term, substitute <= for < and > for >=.  */
-      else if( pIn3->u.r>(double)iKey ){
+      else if( c<0 ){
         assert( OP_SeekLE==(OP_SeekLT+1) );
         assert( OP_SeekGT==(OP_SeekGE+1) );
         assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
         if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
       }
     }
-    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
+    rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
     pC->movetoTarget = iKey;  /* Used by OP_Delete */
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
@@ -89917,7 +91197,7 @@ case OP_SeekGT: {       /* jump, in3, group */
     { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
 #endif
     r.eqSeen = 0;
-    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
+    rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res);
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
     }
@@ -90011,13 +91291,13 @@ case OP_SeekGT: {       /* jump, in3, group */
 **
 ** There are three possible outcomes from this opcode:<ol>
 **
-** <li> If after This.P1 steps, the cursor is still point to a place that
-**      is earlier in the btree than the target row,
-**      then fall through into the subsquence OP_SeekGE opcode.
+** <li> If after This.P1 steps, the cursor is still pointing to a place that
+**      is earlier in the btree than the target row, then fall through
+**      into the subsquence OP_SeekGE opcode.
 **
 ** <li> If the cursor is successfully moved to the target row by 0 or more
 **      sqlite3BtreeNext() calls, then jump to This.P2, which will land just
-**      past the OP_IdxGT opcode that follows the OP_SeekGE.
+**      past the OP_IdxGT or OP_IdxGE opcode that follows the OP_SeekGE.
 **
 ** <li> If the cursor ends up past the target row (indicating the the target
 **      row does not exist in the btree) then jump to SeekOP.P2.
@@ -90034,7 +91314,8 @@ case OP_SeekScan: {
   /* pOp->p2 points to the first instruction past the OP_IdxGT that
   ** follows the OP_SeekGE.  */
   assert( pOp->p2>=(int)(pOp-aOp)+2 );
-  assert( aOp[pOp->p2-1].opcode==OP_IdxGT );
+  assert( aOp[pOp->p2-1].opcode==OP_IdxGT || aOp[pOp->p2-1].opcode==OP_IdxGE );
+  testcase( aOp[pOp->p2-1].opcode==OP_IdxGE );
   assert( pOp[1].p1==aOp[pOp->p2-1].p1 );
   assert( pOp[1].p2==aOp[pOp->p2-1].p2 );
   assert( pOp[1].p3==aOp[pOp->p2-1].p3 );
@@ -90138,8 +91419,18 @@ case OP_SeekHit: {
   assert( pC!=0 );
   assert( pOp->p3>=pOp->p2 );
   if( pC->seekHit<pOp->p2 ){
+#ifdef SQLITE_DEBUG
+    if( db->flags&SQLITE_VdbeTrace ){
+      printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
+    }
+#endif
     pC->seekHit = pOp->p2;
   }else if( pC->seekHit>pOp->p3 ){
+#ifdef SQLITE_DEBUG
+    if( db->flags&SQLITE_VdbeTrace ){
+      printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
+    }
+#endif
     pC->seekHit = pOp->p3;
   }
   break;
@@ -90254,6 +91545,11 @@ case OP_IfNoHope: {     /* jump, in3 */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
+#ifdef SQLITE_DEBUG
+  if( db->flags&SQLITE_VdbeTrace ){
+    printf("seekHit is %d\n", pC->seekHit);
+  }
+#endif
   if( pC->seekHit>=pOp->p4.i ) break;
   /* Fall through into OP_NotFound */
   /* no break */ deliberate_fall_through
@@ -90320,7 +91616,7 @@ case OP_Found: {        /* jump, in3 */
       }
     }
   }
-  rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
+  rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &res);
   if( pFree ) sqlite3DbFreeNN(db, pFree);
   if( rc!=SQLITE_OK ){
     goto abort_due_to_error;
@@ -90429,7 +91725,7 @@ case OP_NotExists:          /* jump, in3 */
   pCrsr = pC->uc.pCursor;
   assert( pCrsr!=0 );
   res = 0;
-  rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
+  rc = sqlite3BtreeTableMoveto(pCrsr, iKey, 0, &res);
   assert( rc==SQLITE_OK || res==0 );
   pC->movetoTarget = iKey;  /* Used by OP_Delete */
   pC->nullRow = 0;
@@ -90487,8 +91783,10 @@ case OP_NewRowid: {           /* out2 */
   VdbeCursor *pC;        /* Cursor of table to get the new rowid */
   int res;               /* Result of an sqlite3BtreeLast() */
   int cnt;               /* Counter to limit the number of searches */
+#ifndef SQLITE_OMIT_AUTOINCREMENT
   Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
   VdbeFrame *pFrame;     /* Root frame of VDBE */
+#endif
 
   v = 0;
   res = 0;
@@ -90584,7 +91882,7 @@ case OP_NewRowid: {           /* out2 */
       do{
         sqlite3_randomness(sizeof(v), &v);
         v &= (MAX_ROWID>>1); v++;  /* Ensure that v is greater than zero */
-      }while(  ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
+      }while(  ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
                                                  0, &res))==SQLITE_OK)
             && (res==0)
             && (++cnt<100));
@@ -90674,14 +91972,14 @@ case OP_Insert: {
     assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
   }else{
     pTab = 0;
-    zDb = 0;  /* Not needed.  Silence a compiler warning. */
+    zDb = 0;
   }
 
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
   /* Invoke the pre-update hook, if any */
   if( pTab ){
     if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
-      sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
+      sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
     }
     if( db->xUpdateCallback==0 || pTab->aCol==0 ){
       /* Prevent post-update hook from running in cases when it should not */
@@ -90704,7 +92002,8 @@ case OP_Insert: {
   }
   x.pKey = 0;
   rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
-      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult
+      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
+      seekResult
   );
   pC->deferredMoveto = 0;
   pC->cacheStatus = CACHE_STALE;
@@ -90721,6 +92020,33 @@ case OP_Insert: {
   break;
 }
 
+/* Opcode: RowCell P1 P2 P3 * *
+**
+** P1 and P2 are both open cursors. Both must be opened on the same type
+** of table - intkey or index. This opcode is used as part of copying
+** the current row from P2 into P1. If the cursors are opened on intkey
+** tables, register P3 contains the rowid to use with the new record in
+** P1. If they are opened on index tables, P3 is not used.
+**
+** This opcode must be followed by either an Insert or InsertIdx opcode
+** with the OPFLAG_PREFORMAT flag set to complete the insert operation.
+*/
+case OP_RowCell: {
+  VdbeCursor *pDest;              /* Cursor to write to */
+  VdbeCursor *pSrc;               /* Cursor to read from */
+  i64 iKey;                       /* Rowid value to insert with */
+  assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert );
+  assert( pOp[1].opcode==OP_Insert    || pOp->p3==0 );
+  assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 );
+  assert( pOp[1].p5 & OPFLAG_PREFORMAT );
+  pDest = p->apCsr[pOp->p1];
+  pSrc = p->apCsr[pOp->p2];
+  iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0;
+  rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey);
+  if( rc!=SQLITE_OK ) goto abort_due_to_error;
+  break;
+};
+
 /* Opcode: Delete P1 P2 P3 P4 P5
 **
 ** Delete the record at which the P1 cursor is currently pointing.
@@ -90799,13 +92125,14 @@ case OP_Delete: {
       pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
     }
   }else{
-    zDb = 0;   /* Not needed.  Silence a compiler warning. */
-    pTab = 0;  /* Not needed.  Silence a compiler warning. */
+    zDb = 0;
+    pTab = 0;
   }
 
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
   /* Invoke the pre-update-hook if required. */
-  if( db->xPreUpdateCallback && pOp->p4.pTab ){
+  assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab );
+  if( db->xPreUpdateCallback && pTab ){
     assert( !(opflags & OPFLAG_ISUPDATE)
          || HasRowid(pTab)==0
          || (aMem[pOp->p3].flags & MEM_Int)
@@ -90813,7 +92140,7 @@ case OP_Delete: {
     sqlite3VdbePreUpdateHook(p, pC,
         (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE,
         zDb, pTab, pC->movetoTarget,
-        pOp->p3
+        pOp->p3, -1
     );
   }
   if( opflags & OPFLAG_ISNOOP ) break;
@@ -90846,7 +92173,7 @@ case OP_Delete: {
   /* Invoke the update-hook if required. */
   if( opflags & OPFLAG_NCHANGE ){
     p->nChange++;
-    if( db->xUpdateCallback && HasRowid(pTab) ){
+    if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){
       db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
           pC->movetoTarget);
       assert( pC->iDb>=0 );
@@ -91376,7 +92703,7 @@ case OP_IdxInsert: {        /* in2 */
   assert( pC!=0 );
   assert( !isSorter(pC) );
   pIn2 = &aMem[pOp->p2];
-  assert( pIn2->flags & MEM_Blob );
+  assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
   if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
   assert( pC->eCurType==CURTYPE_BTREE );
   assert( pC->isTable==0 );
@@ -91387,7 +92714,7 @@ case OP_IdxInsert: {        /* in2 */
   x.aMem = aMem + pOp->p3;
   x.nMem = (u16)pOp->p4.i;
   rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
-       (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)),
+       (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
       ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
       );
   assert( pC->deferredMoveto==0 );
@@ -91433,7 +92760,8 @@ case OP_SorterInsert: {     /* in2 */
 ** an UPDATE or DELETE statement and the index entry to be updated
 ** or deleted is not found.  For some uses of IdxDelete
 ** (example:  the EXCEPT operator) it does not matter that no matching
-** entry is found.  For those cases, P5 is zero.
+** entry is found.  For those cases, P5 is zero.  Also, do not raise
+** this (self-correcting and non-critical) error if in writable_schema mode.
 */
 case OP_IdxDelete: {
   VdbeCursor *pC;
@@ -91454,13 +92782,13 @@ case OP_IdxDelete: {
   r.nField = (u16)pOp->p3;
   r.default_rc = 0;
   r.aMem = &aMem[pOp->p2];
-  rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
+  rc = sqlite3BtreeIndexMoveto(pCrsr, &r, &res);
   if( rc ) goto abort_due_to_error;
   if( res==0 ){
     rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
     if( rc ) goto abort_due_to_error;
-  }else if( pOp->p5 ){
-    rc = SQLITE_CORRUPT_INDEX;
+  }else if( pOp->p5 && !sqlite3WritableSchema(db) ){
+    rc = sqlite3ReportError(SQLITE_CORRUPT_INDEX, __LINE__, "index corruption");
     goto abort_due_to_error;
   }
   assert( pC->deferredMoveto==0 );
@@ -91539,6 +92867,8 @@ case OP_IdxRowid: {           /* out2 */
       pTabCur->deferredMoveto = 1;
       assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
       pTabCur->aAltMap = pOp->p4.ai;
+      assert( !pC->isEphemeral );
+      assert( !pTabCur->isEphemeral );
       pTabCur->pAltCursor = pC;
     }else{
       pOut = out2Prerelease(p, pOp);
@@ -91757,24 +93087,21 @@ case OP_Destroy: {     /* out2 */
 ** P2==1 then the table to be clear is in the auxiliary database file
 ** that is used to store tables create using CREATE TEMPORARY TABLE.
 **
-** If the P3 value is non-zero, then the table referred to must be an
-** intkey table (an SQL table, not an index). In this case the row change
-** count is incremented by the number of rows in the table being cleared.
-** If P3 is greater than zero, then the value stored in register P3 is
-** also incremented by the number of rows in the table being cleared.
+** If the P3 value is non-zero, then the row change count is incremented
+** by the number of rows in the table being cleared. If P3 is greater
+** than zero, then the value stored in register P3 is also incremented
+** by the number of rows in the table being cleared.
 **
 ** See also: Destroy
 */
 case OP_Clear: {
-  int nChange;
+  i64 nChange;
 
   sqlite3VdbeIncrWriteCounter(p, 0);
   nChange = 0;
   assert( p->readOnly==0 );
   assert( DbMaskTest(p->btreeMask, pOp->p2) );
-  rc = sqlite3BtreeClearTable(
-      db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0)
-  );
+  rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);
   if( pOp->p3 ){
     p->nChange += nChange;
     if( pOp->p3>0 ){
@@ -91880,19 +93207,21 @@ case OP_ParseSchema: {
 
   iDb = pOp->p1;
   assert( iDb>=0 && iDb<db->nDb );
-  assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
+  assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
+           || db->mallocFailed
+           || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) );
 
 #ifndef SQLITE_OMIT_ALTERTABLE
   if( pOp->p4.z==0 ){
     sqlite3SchemaClear(db->aDb[iDb].pSchema);
     db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
-    rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable);
+    rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
     db->mDbFlags |= DBFLAG_SchemaChange;
     p->expired = 0;
   }else
 #endif
   {
-    zSchema = DFLT_SCHEMA_TABLE;
+    zSchema = LEGACY_SCHEMA_TABLE;
     initData.db = db;
     initData.iDb = iDb;
     initData.pzErrMsg = &p->zErrMsg;
@@ -92762,6 +94091,7 @@ case OP_JournalMode: {    /* out2 */
   pPager = sqlite3BtreePager(pBt);
   eOld = sqlite3PagerGetJournalMode(pPager);
   if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
+  assert( sqlite3BtreeHoldsMutex(pBt) );
   if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
 
 #ifndef SQLITE_OMIT_WAL
@@ -93111,6 +94441,7 @@ case OP_VFilter: {   /* jump */
   pCur = p->apCsr[pOp->p1];
   assert( memIsValid(pQuery) );
   REGISTER_TRACE(pOp->p3, pQuery);
+  assert( pCur!=0 );
   assert( pCur->eCurType==CURTYPE_VTAB );
   pVCur = pCur->uc.pVCur;
   pVtab = pVCur->pVtab;
@@ -93122,7 +94453,6 @@ case OP_VFilter: {   /* jump */
   iQuery = (int)pQuery->u.i;
 
   /* Invoke the xFilter method */
-  res = 0;
   apArg = p->apArg;
   for(i = 0; i<nArg; i++){
     apArg[i] = &pArgc[i+1];
@@ -93160,6 +94490,7 @@ case OP_VColumn: {
   sqlite3_context sContext;
 
   VdbeCursor *pCur = p->apCsr[pOp->p1];
+  assert( pCur!=0 );
   assert( pCur->eCurType==CURTYPE_VTAB );
   assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
   pDest = &aMem[pOp->p3];
@@ -93212,8 +94543,8 @@ case OP_VNext: {   /* jump */
   int res;
   VdbeCursor *pCur;
 
-  res = 0;
   pCur = p->apCsr[pOp->p1];
+  assert( pCur!=0 );
   assert( pCur->eCurType==CURTYPE_VTAB );
   if( pCur->nullRow ){
     break;
@@ -93309,7 +94640,7 @@ case OP_VUpdate: {
   const sqlite3_module *pModule;
   int nArg;
   int i;
-  sqlite_int64 rowid;
+  sqlite_int64 rowid = 0;
   Mem **apArg;
   Mem *pX;
 
@@ -93754,6 +95085,18 @@ default: {          /* This is really OP_Noop, OP_Explain */
     rc = SQLITE_CORRUPT_BKPT;
   }
   assert( rc );
+#ifdef SQLITE_DEBUG
+  if( db->flags & SQLITE_VdbeTrace ){
+    const char *zTrace = p->zSql;
+    if( zTrace==0 ){
+      if( aOp[0].opcode==OP_Trace ){
+        zTrace = aOp[0].p4.z;
+      }
+      if( zTrace==0 ) zTrace = "???";
+    }
+    printf("ABORT-due-to-error (rc=%d): %s\n", rc, zTrace);
+  }
+#endif
   if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
     sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
   }
@@ -93764,6 +95107,9 @@ default: {          /* This is really OP_Noop, OP_Explain */
                    (int)(pOp - aOp), p->zSql, p->zErrMsg);
   sqlite3VdbeHalt(p);
   if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
+  if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){
+    db->flags |= SQLITE_CorruptRdOnly;
+  }
   rc = SQLITE_ERROR;
   if( resetSchemaOnFault>0 ){
     sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
@@ -93895,7 +95241,10 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){
   }
   if( rc==SQLITE_ROW ){
     VdbeCursor *pC = v->apCsr[0];
-    u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
+    u32 type;
+    assert( pC!=0 );
+    assert( pC->eCurType==CURTYPE_BTREE );
+    type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
     testcase( pC->nHdrParsed==p->iCol );
     testcase( pC->nHdrParsed==p->iCol+1 );
     if( type<12 ){
@@ -93987,7 +95336,7 @@ SQLITE_API int sqlite3_blob_open(
       sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable);
     }
 #ifndef SQLITE_OMIT_VIEW
-    if( pTab && pTab->pSelect ){
+    if( pTab && IsView(pTab) ){
       pTab = 0;
       sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
     }
@@ -94007,7 +95356,7 @@ SQLITE_API int sqlite3_blob_open(
 
     /* Now search pTab for the exact column. */
     for(iCol=0; iCol<pTab->nCol; iCol++) {
-      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
+      if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
         break;
       }
     }
@@ -94032,7 +95381,8 @@ SQLITE_API int sqlite3_blob_open(
         ** key columns must be indexed. The check below will pick up this
         ** case.  */
         FKey *pFKey;
-        for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
+        assert( IsOrdinaryTable(pTab) );
+        for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
           int j;
           for(j=0; j<pFKey->nCol; j++){
             if( pFKey->aCol[j].iFrom==iCol ){
@@ -94239,8 +95589,10 @@ static int blobReadWrite(
       */
       sqlite3_int64 iKey;
       iKey = sqlite3BtreeIntegerKey(p->pCsr);
+      assert( v->apCsr[0]!=0 );
+      assert( v->apCsr[0]->eCurType==CURTYPE_BTREE );
       sqlite3VdbePreUpdateHook(
-          v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1
+          v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
       );
     }
 #endif
@@ -94311,6 +95663,7 @@ SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
     rc = SQLITE_ABORT;
   }else{
     char *zErr;
+    ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
     rc = blobSeekToRow(p, iRow, &zErr);
     if( rc!=SQLITE_OK ){
       sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
@@ -95404,8 +96757,9 @@ static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){
   fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent);
 }
 static void vdbeSorterRewindDebug(const char *zEvent){
-  i64 t;
-  sqlite3OsCurrentTimeInt64(sqlite3_vfs_find(0), &t);
+  i64 t = 0;
+  sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
+  if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t);
   fprintf(stderr, "%lld:X %s\n", t, zEvent);
 }
 static void vdbeSorterPopulateDebug(
@@ -95619,7 +96973,7 @@ static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){
     sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize);
     sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte);
     sqlite3OsFetch(pFd, 0, (int)nByte, &p);
-    sqlite3OsUnfetch(pFd, 0, p);
+    if( p ) sqlite3OsUnfetch(pFd, 0, p);
   }
 }
 #else
@@ -96337,6 +97691,7 @@ static int vdbeIncrMergerNew(
     vdbeMergeEngineFree(pMerger);
     rc = SQLITE_NOMEM_BKPT;
   }
+  assert( *ppOut!=0 || rc!=SQLITE_OK );
   return rc;
 }
 
@@ -97594,7 +98949,6 @@ struct MemJournal {
   int nChunkSize;                 /* In-memory chunk-size */
 
   int nSpill;                     /* Bytes of data before flushing */
-  int nSize;                      /* Bytes of data currently in memory */
   FileChunk *pFirst;              /* Head of in-memory chunk-list */
   FilePoint endpoint;             /* Pointer to the end of the file */
   FilePoint readpoint;            /* Pointer to the end of the last xRead() */
@@ -97655,14 +99009,13 @@ static int memjrnlRead(
 /*
 ** Free the list of FileChunk structures headed at MemJournal.pFirst.
 */
-static void memjrnlFreeChunks(MemJournal *p){
+static void memjrnlFreeChunks(FileChunk *pFirst){
   FileChunk *pIter;
   FileChunk *pNext;
-  for(pIter=p->pFirst; pIter; pIter=pNext){
+  for(pIter=pFirst; pIter; pIter=pNext){
     pNext = pIter->pNext;
     sqlite3_free(pIter);
   }
-  p->pFirst = 0;
 }
 
 /*
@@ -97689,7 +99042,7 @@ static int memjrnlCreateFile(MemJournal *p){
     }
     if( rc==SQLITE_OK ){
       /* No error has occurred. Free the in-memory buffers. */
-      memjrnlFreeChunks(&copy);
+      memjrnlFreeChunks(copy.pFirst);
     }
   }
   if( rc!=SQLITE_OK ){
@@ -97772,7 +99125,6 @@ static int memjrnlWrite(
         nWrite -= iSpace;
         p->endpoint.iOffset += iSpace;
       }
-      p->nSize = iAmt + iOfst;
     }
   }
 
@@ -97780,19 +99132,29 @@ static int memjrnlWrite(
 }
 
 /*
-** Truncate the file.
-**
-** If the journal file is already on disk, truncate it there. Or, if it
-** is still in main memory but is being truncated to zero bytes in size,
-** ignore
+** Truncate the in-memory file.
 */
 static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
   MemJournal *p = (MemJournal *)pJfd;
-  if( ALWAYS(size==0) ){
-    memjrnlFreeChunks(p);
-    p->nSize = 0;
-    p->endpoint.pChunk = 0;
-    p->endpoint.iOffset = 0;
+  assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 );
+  if( size<p->endpoint.iOffset ){
+    FileChunk *pIter = 0;
+    if( size==0 ){
+      memjrnlFreeChunks(p->pFirst);
+      p->pFirst = 0;
+    }else{
+      i64 iOff = p->nChunkSize;
+      for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
+        iOff += p->nChunkSize;
+      }
+      if( ALWAYS(pIter) ){
+        memjrnlFreeChunks(pIter->pNext);
+        pIter->pNext = 0;
+      }
+    }
+
+    p->endpoint.pChunk = pIter;
+    p->endpoint.iOffset = size;
     p->readpoint.pChunk = 0;
     p->readpoint.iOffset = 0;
   }
@@ -97804,7 +99166,7 @@ static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
 */
 static int memjrnlClose(sqlite3_file *pJfd){
   MemJournal *p = (MemJournal *)pJfd;
-  memjrnlFreeChunks(p);
+  memjrnlFreeChunks(p->pFirst);
   return SQLITE_OK;
 }
 
@@ -97978,7 +99340,7 @@ SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){
 ** Walk all expressions linked into the list of Window objects passed
 ** as the second argument.
 */
-static int walkWindowList(Walker *pWalker, Window *pList){
+static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){
   Window *pWin;
   for(pWin=pList; pWin; pWin=pWin->pNextWin){
     int rc;
@@ -97988,15 +99350,11 @@ static int walkWindowList(Walker *pWalker, Window *pList){
     if( rc ) return WRC_Abort;
     rc = sqlite3WalkExpr(pWalker, pWin->pFilter);
     if( rc ) return WRC_Abort;
-
-    /* The next two are purely for calls to sqlite3RenameExprUnmap()
-    ** within sqlite3WindowOffsetExpr().  Because of constraints imposed
-    ** by sqlite3WindowOffsetExpr(), they can never fail.  The results do
-    ** not matter anyhow. */
     rc = sqlite3WalkExpr(pWalker, pWin->pStart);
-    if( NEVER(rc) ) return WRC_Abort;
+    if( rc ) return WRC_Abort;
     rc = sqlite3WalkExpr(pWalker, pWin->pEnd);
-    if( NEVER(rc) ) return WRC_Abort;
+    if( rc ) return WRC_Abort;
+    if( bOneOnly ) break;
   }
   return WRC_Continue;
 }
@@ -98035,7 +99393,7 @@ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
         assert( !ExprHasProperty(pExpr, EP_WinFunc) );
         pExpr = pExpr->pRight;
         continue;
-      }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+      }else if( ExprUseXSelect(pExpr) ){
         assert( !ExprHasProperty(pExpr, EP_WinFunc) );
         if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
       }else{
@@ -98044,7 +99402,7 @@ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
         }
 #ifndef SQLITE_OMIT_WINDOWFUNC
         if( ExprHasProperty(pExpr, EP_WinFunc) ){
-          if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort;
+          if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
         }
 #endif
       }
@@ -98072,6 +99430,16 @@ SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){
   return WRC_Continue;
 }
 
+/*
+** This is a no-op callback for Walker->xSelectCallback2.  If this
+** callback is set, then the Select->pWinDefn list is traversed.
+*/
+SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker *pWalker, Select *p){
+  UNUSED_PARAMETER(pWalker);
+  UNUSED_PARAMETER(p);
+  /* No-op */
+}
+
 /*
 ** Walk all expressions associated with SELECT statement p.  Do
 ** not invoke the SELECT callback on p, but do (of course) invoke
@@ -98085,13 +99453,18 @@ SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
   if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
   if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
   if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
-#if !defined(SQLITE_OMIT_WINDOWFUNC) && !defined(SQLITE_OMIT_ALTERTABLE)
-  {
-    Parse *pParse = pWalker->pParse;
-    if( pParse && IN_RENAME_OBJECT ){
+#if !defined(SQLITE_OMIT_WINDOWFUNC)
+  if( p->pWinDefn ){
+    Parse *pParse;
+    if( pWalker->xSelectCallback2==sqlite3WalkWinDefnDummyCallback
+     || ((pParse = pWalker->pParse)!=0 && IN_RENAME_OBJECT)
+#ifndef SQLITE_OMIT_CTE
+     || pWalker->xSelectCallback2==sqlite3SelectPopWith
+#endif
+    ){
       /* The following may return WRC_Abort if there are unresolvable
       ** symbols (e.g. a table that does not exist) in a window definition. */
-      int rc = walkWindowList(pWalker, p->pWinDefn);
+      int rc = walkWindowList(pWalker, p->pWinDefn, 0);
       return rc;
     }
   }
@@ -98109,10 +99482,10 @@ SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
 SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
   SrcList *pSrc;
   int i;
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
 
   pSrc = p->pSrc;
-  if( pSrc ){
+  if( ALWAYS(pSrc) ){
     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
       if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){
         return WRC_Abort;
@@ -98275,7 +99648,6 @@ static void resolveAlias(
   ExprList *pEList,      /* A result set */
   int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */
   Expr *pExpr,           /* Transform this into an alias to the result set */
-  const char *zType,     /* "GROUP" or "ORDER" or "" */
   int nSubquery          /* Number of subqueries that the label is moving */
 ){
   Expr *pOrig;           /* The iCol-th column of the result set */
@@ -98287,9 +99659,13 @@ static void resolveAlias(
   assert( pOrig!=0 );
   db = pParse->db;
   pDup = sqlite3ExprDup(db, pOrig, 0);
-  if( pDup!=0 ){
-    if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
+  if( db->mallocFailed ){
+    sqlite3ExprDelete(db, pDup);
+    pDup = 0;
+  }else{
+    incrAggFunctionDepth(pDup, nSubquery);
     if( pExpr->op==TK_COLLATE ){
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
     }
 
@@ -98309,15 +99685,12 @@ static void resolveAlias(
       pExpr->flags |= EP_MemToken;
     }
     if( ExprHasProperty(pExpr, EP_WinFunc) ){
-      if( pExpr->y.pWin!=0 ){
+      if( ALWAYS(pExpr->y.pWin!=0) ){
         pExpr->y.pWin->pOwner = pExpr;
-      }else{
-        assert( db->mallocFailed );
       }
     }
     sqlite3DbFree(db, pDup);
   }
-  ExprSetProperty(pExpr, EP_Alias);
 }
 
 
@@ -98396,6 +99769,7 @@ SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
   Table *pExTab;
 
   n = pExpr->iColumn;
+  assert( ExprUseYTab(pExpr) );
   pExTab = pExpr->y.pTab;
   assert( pExTab!=0 );
   if( (pExTab->tabFlags & TF_HasGenerated)!=0
@@ -98452,8 +99826,8 @@ static int lookupName(
   int cntTab = 0;                   /* Number of matching table names */
   int nSubquery = 0;                /* How many levels of subquery */
   sqlite3 *db = pParse->db;         /* The database connection */
-  struct SrcList_item *pItem;       /* Use for looping over pSrcList items */
-  struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
+  SrcItem *pItem;                   /* Use for looping over pSrcList items */
+  SrcItem *pMatch = 0;              /* The matching pSrcList item */
   NameContext *pTopNC = pNC;        /* First namecontext in the list */
   Schema *pSchema = 0;              /* Schema of the expression */
   int eNewExprOp = TK_COLUMN;       /* New value for pExpr->op on success */
@@ -98509,7 +99883,7 @@ static int lookupName(
         u8 hCol;
         pTab = pItem->pTab;
         assert( pTab!=0 && pTab->zName!=0 );
-        assert( pTab->nCol>0 );
+        assert( pTab->nCol>0 || pParse->nErr );
         if( pItem->pSelect && (pItem->pSelect->selFlags & SF_NestedFrom)!=0 ){
           int hit = 0;
           pEList = pItem->pSelect->pEList;
@@ -98533,16 +99907,16 @@ static int lookupName(
           if( sqlite3StrICmp(zTabName, zTab)!=0 ){
             continue;
           }
+          assert( ExprUseYTab(pExpr) );
           if( IN_RENAME_OBJECT && pItem->zAlias ){
             sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
           }
         }
-        if( 0==(cntTab++) ){
-          pMatch = pItem;
-        }
         hCol = sqlite3StrIHash(zCol);
         for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
-          if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
+          if( pCol->hName==hCol
+           && sqlite3StrICmp(pCol->zCnName, zCol)==0
+          ){
             /* If there has been exactly one prior match and this match
             ** is for the right-hand table of a NATURAL JOIN or is in a
             ** USING clause, then skip this match.
@@ -98558,9 +99932,14 @@ static int lookupName(
             break;
           }
         }
+        if( 0==cnt && VisibleRowid(pTab) ){
+          cntTab++;
+          pMatch = pItem;
+        }
       }
       if( pMatch ){
         pExpr->iTable = pMatch->iCursor;
+        assert( ExprUseYTab(pExpr) );
         pExpr->y.pTab = pMatch->pTab;
         /* RIGHT JOIN not (yet) supported */
         assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
@@ -98574,25 +99953,33 @@ static int lookupName(
 #if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
     /* If we have not already resolved the name, then maybe
     ** it is a new.* or old.* trigger argument reference.  Or
-    ** maybe it is an excluded.* from an upsert.
+    ** maybe it is an excluded.* from an upsert.  Or maybe it is
+    ** a reference in the RETURNING clause to a table being modified.
     */
-    if( zDb==0 && zTab!=0 && cntTab==0 ){
+    if( cnt==0 && zDb==0 ){
       pTab = 0;
 #ifndef SQLITE_OMIT_TRIGGER
       if( pParse->pTriggerTab!=0 ){
         int op = pParse->eTriggerOp;
         assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
-        if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
+        if( pParse->bReturning ){
+          if( (pNC->ncFlags & NC_UBaseReg)!=0
+           && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
+          ){
+            pExpr->iTable = op!=TK_DELETE;
+            pTab = pParse->pTriggerTab;
+          }
+        }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
           pExpr->iTable = 1;
           pTab = pParse->pTriggerTab;
-        }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
+        }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
           pExpr->iTable = 0;
           pTab = pParse->pTriggerTab;
         }
       }
 #endif /* SQLITE_OMIT_TRIGGER */
 #ifndef SQLITE_OMIT_UPSERT
-      if( (pNC->ncFlags & NC_UUpsert)!=0 ){
+      if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
         Upsert *pUpsert = pNC->uNC.pUpsert;
         if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
           pTab = pUpsert->pUpsertSrc->a[0].pTab;
@@ -98607,7 +99994,9 @@ static int lookupName(
         pSchema = pTab->pSchema;
         cntTab++;
         for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
-          if( pCol->hName==hCol && sqlite3StrICmp(pCol->zName, zCol)==0 ){
+          if( pCol->hName==hCol
+           && sqlite3StrICmp(pCol->zCnName, zCol)==0
+          ){
             if( iCol==pTab->iPKey ){
               iCol = -1;
             }
@@ -98620,9 +100009,11 @@ static int lookupName(
         }
         if( iCol<pTab->nCol ){
           cnt++;
+          pMatch = 0;
 #ifndef SQLITE_OMIT_UPSERT
           if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
             testcase( iCol==(-1) );
+            assert( ExprUseYTab(pExpr) );
             if( IN_RENAME_OBJECT ){
               pExpr->iColumn = iCol;
               pExpr->y.pTab = pTab;
@@ -98631,27 +100022,33 @@ static int lookupName(
               pExpr->iTable = pNC->uNC.pUpsert->regData +
                  sqlite3TableColumnToStorage(pTab, iCol);
               eNewExprOp = TK_REGISTER;
-              ExprSetProperty(pExpr, EP_Alias);
             }
           }else
 #endif /* SQLITE_OMIT_UPSERT */
           {
-#ifndef SQLITE_OMIT_TRIGGER
-            if( iCol<0 ){
-              pExpr->affExpr = SQLITE_AFF_INTEGER;
-            }else if( pExpr->iTable==0 ){
-              testcase( iCol==31 );
-              testcase( iCol==32 );
-              pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
-            }else{
-              testcase( iCol==31 );
-              testcase( iCol==32 );
-              pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
-            }
+            assert( ExprUseYTab(pExpr) );
             pExpr->y.pTab = pTab;
-            pExpr->iColumn = (i16)iCol;
-            eNewExprOp = TK_TRIGGER;
+            if( pParse->bReturning ){
+              eNewExprOp = TK_REGISTER;
+              pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
+                 sqlite3TableColumnToStorage(pTab, iCol) + 1;
+            }else{
+              pExpr->iColumn = (i16)iCol;
+              eNewExprOp = TK_TRIGGER;
+#ifndef SQLITE_OMIT_TRIGGER
+              if( iCol<0 ){
+                pExpr->affExpr = SQLITE_AFF_INTEGER;
+              }else if( pExpr->iTable==0 ){
+                testcase( iCol==31 );
+                testcase( iCol==32 );
+                pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
+              }else{
+                testcase( iCol==31 );
+                testcase( iCol==32 );
+                pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
+              }
 #endif /* SQLITE_OMIT_TRIGGER */
+            }
           }
         }
       }
@@ -98666,7 +100063,7 @@ static int lookupName(
      && pMatch
      && (pNC->ncFlags & (NC_IdxExpr|NC_GenCol))==0
      && sqlite3IsRowid(zCol)
-     && VisibleRowid(pMatch->pTab)
+     && ALWAYS(VisibleRowid(pMatch->pTab))
     ){
       cnt = 1;
       pExpr->iColumn = -1;
@@ -98691,8 +100088,8 @@ static int lookupName(
     ** is supported for backwards compatibility only. Hence, we issue a warning
     ** on sqlite3_log() whenever the capability is used.
     */
-    if( (pNC->ncFlags & NC_UEList)!=0
-     && cnt==0
+    if( cnt==0
+     && (pNC->ncFlags & NC_UEList)!=0
      && zTab==0
     ){
       pEList = pNC->uNC.pEList;
@@ -98704,8 +100101,8 @@ static int lookupName(
         ){
           Expr *pOrig;
           assert( pExpr->pLeft==0 && pExpr->pRight==0 );
-          assert( pExpr->x.pList==0 );
-          assert( pExpr->x.pSelect==0 );
+          assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 );
+          assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 );
           pOrig = pEList->a[j].pExpr;
           if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){
             sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
@@ -98721,7 +100118,7 @@ static int lookupName(
             sqlite3ErrorMsg(pParse, "row value misused");
             return WRC_Abort;
           }
-          resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
+          resolveAlias(pParse, pEList, j, pExpr, nSubquery);
           cnt = 1;
           pMatch = 0;
           assert( zTab==0 && zDb==0 );
@@ -98777,7 +100174,7 @@ static int lookupName(
       sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
 #endif
       pExpr->op = TK_STRING;
-      pExpr->y.pTab = 0;
+      memset(&pExpr->y, 0, sizeof(pExpr->y));
       return WRC_Prune;
     }
     if( sqlite3ExprIdToTrueFalse(pExpr) ){
@@ -98800,7 +100197,7 @@ static int lookupName(
       sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
     }
     pParse->checkSchema = 1;
-    pTopNC->nErr++;
+    pTopNC->nNcErr++;
   }
 
   /* If a column from a table in pSrcList is referenced, then record
@@ -98823,18 +100220,24 @@ static int lookupName(
 
   /* Clean up and return
   */
-  sqlite3ExprDelete(db, pExpr->pLeft);
-  pExpr->pLeft = 0;
-  sqlite3ExprDelete(db, pExpr->pRight);
-  pExpr->pRight = 0;
+  if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
+    sqlite3ExprDelete(db, pExpr->pLeft);
+    pExpr->pLeft = 0;
+    sqlite3ExprDelete(db, pExpr->pRight);
+    pExpr->pRight = 0;
+  }
   pExpr->op = eNewExprOp;
   ExprSetProperty(pExpr, EP_Leaf);
 lookupname_end:
   if( cnt==1 ){
     assert( pNC!=0 );
-    if( !ExprHasProperty(pExpr, EP_Alias) ){
+#ifndef SQLITE_OMIT_AUTHORIZATION
+    if( pParse->db->xAuth
+     && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER)
+    ){
       sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
     }
+#endif
     /* Increment the nRef value on all name contexts from TopNC up to
     ** the point where the name matched. */
     for(;;){
@@ -98856,8 +100259,10 @@ static int lookupName(
 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
   Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
   if( p ){
-    struct SrcList_item *pItem = &pSrc->a[iSrc];
-    Table *pTab = p->y.pTab = pItem->pTab;
+    SrcItem *pItem = &pSrc->a[iSrc];
+    Table *pTab;
+    assert( ExprUseYTab(p) );
+    pTab = p->y.pTab = pItem->pTab;
     p->iTable = pItem->iCursor;
     if( p->y.pTab->iPKey==iCol ){
       p->iColumn = -1;
@@ -98924,6 +100329,7 @@ static void notValidImpl(
 static int exprProbability(Expr *p){
   double r = -1.0;
   if( p->op!=TK_FLOAT ) return -1;
+  assert( !ExprHasProperty(p, EP_IntValue) );
   sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
   assert( r>=0.0 );
   if( r>1.0 ) return -1;
@@ -98968,10 +100374,11 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
     */
     case TK_ROW: {
       SrcList *pSrcList = pNC->pSrcList;
-      struct SrcList_item *pItem;
+      SrcItem *pItem;
       assert( pSrcList && pSrcList->nSrc>=1 );
       pItem = pSrcList->a;
       pExpr->op = TK_COLUMN;
+      assert( ExprUseYTab(pExpr) );
       pExpr->y.pTab = pItem->pTab;
       pExpr->iTable = pItem->iCursor;
       pExpr->iColumn--;
@@ -98979,6 +100386,49 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       break;
     }
 
+    /* An optimization:  Attempt to convert
+    **
+    **      "expr IS NOT NULL"  -->  "TRUE"
+    **      "expr IS NULL"      -->  "FALSE"
+    **
+    ** if we can prove that "expr" is never NULL.  Call this the
+    ** "NOT NULL strength reduction optimization".
+    **
+    ** If this optimization occurs, also restore the NameContext ref-counts
+    ** to the state they where in before the "column" LHS expression was
+    ** resolved.  This prevents "column" from being counted as having been
+    ** referenced, which might prevent a SELECT from being erroneously
+    ** marked as correlated.
+    */
+    case TK_NOTNULL:
+    case TK_ISNULL: {
+      int anRef[8];
+      NameContext *p;
+      int i;
+      for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
+        anRef[i] = p->nRef;
+      }
+      sqlite3WalkExpr(pWalker, pExpr->pLeft);
+      if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){
+        testcase( ExprHasProperty(pExpr, EP_FromJoin) );
+        assert( !ExprHasProperty(pExpr, EP_IntValue) );
+        if( pExpr->op==TK_NOTNULL ){
+          pExpr->u.zToken = "true";
+          ExprSetProperty(pExpr, EP_IsTrue);
+        }else{
+          pExpr->u.zToken = "false";
+          ExprSetProperty(pExpr, EP_IsFalse);
+        }
+        pExpr->op = TK_TRUEFALSE;
+        for(i=0, p=pNC; p && i<ArraySize(anRef); p=p->pNext, i++){
+          p->nRef = anRef[i];
+        }
+        sqlite3ExprDelete(pParse->db, pExpr->pLeft);
+        pExpr->pLeft = 0;
+      }
+      return WRC_Prune;
+    }
+
     /* A column name:                    ID
     ** Or table name and column name:    ID.ID
     ** Or a database, table and column:  ID.ID.ID
@@ -98997,6 +100447,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       if( pExpr->op==TK_ID ){
         zDb = 0;
         zTable = 0;
+        assert( !ExprHasProperty(pExpr, EP_IntValue) );
         zColumn = pExpr->u.zToken;
       }else{
         Expr *pLeft = pExpr->pLeft;
@@ -99009,12 +100460,15 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           zDb = 0;
         }else{
           assert( pRight->op==TK_DOT );
+          assert( !ExprHasProperty(pRight, EP_IntValue) );
           zDb = pLeft->u.zToken;
           pLeft = pRight->pLeft;
           pRight = pRight->pRight;
         }
+        assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) );
         zTable = pLeft->u.zToken;
         zColumn = pRight->u.zToken;
+        assert( ExprUseYTab(pExpr) );
         if( IN_RENAME_OBJECT ){
           sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
           sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
@@ -99039,7 +100493,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #ifndef SQLITE_OMIT_WINDOWFUNC
       Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
 #endif
-      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
+      assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
       zId = pExpr->u.zToken;
       nId = sqlite3Strlen30(zId);
       pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
@@ -99060,7 +100514,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
               sqlite3ErrorMsg(pParse,
                 "second argument to likelihood() must be a "
                 "constant between 0.0 and 1.0");
-              pNC->nErr++;
+              pNC->nNcErr++;
             }
           }else{
             /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
@@ -99082,7 +100536,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
             if( auth==SQLITE_DENY ){
               sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
                                       pDef->zName);
-              pNC->nErr++;
+              pNC->nNcErr++;
             }
             pExpr->op = TK_NULL;
             return WRC_Prune;
@@ -99138,7 +100592,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           sqlite3ErrorMsg(pParse,
               "%.*s() may not be used as a window function", nId, zId
           );
-          pNC->nErr++;
+          pNC->nNcErr++;
         }else if(
               (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
            || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
@@ -99151,13 +100605,13 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
             zType = "aggregate";
           }
           sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
-          pNC->nErr++;
+          pNC->nNcErr++;
           is_agg = 0;
         }
 #else
         if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
           sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
-          pNC->nErr++;
+          pNC->nNcErr++;
           is_agg = 0;
         }
 #endif
@@ -99167,11 +100621,11 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
         ){
           sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
-          pNC->nErr++;
+          pNC->nNcErr++;
         }else if( wrong_num_args ){
           sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
                nId, zId);
-          pNC->nErr++;
+          pNC->nNcErr++;
         }
 #ifndef SQLITE_OMIT_WINDOWFUNC
         else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
@@ -99179,7 +100633,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
               "FILTER may not be used with non-aggregate %.*s()",
               nId, zId
           );
-          pNC->nErr++;
+          pNC->nNcErr++;
         }
 #endif
         if( is_agg ){
@@ -99203,9 +100657,10 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #ifndef SQLITE_OMIT_WINDOWFUNC
         if( pWin ){
           Select *pSel = pNC->pWinSelect;
-          assert( pWin==pExpr->y.pWin );
+          assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
           if( IN_RENAME_OBJECT==0 ){
             sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
+            if( pParse->db->mallocFailed ) break;
           }
           sqlite3WalkExprList(pWalker, pWin->pPartition);
           sqlite3WalkExprList(pWalker, pWin->pOrderBy);
@@ -99215,7 +100670,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         }else
 #endif /* SQLITE_OMIT_WINDOWFUNC */
         {
-          NameContext *pNC2 = pNC;
+          NameContext *pNC2;          /* For looping up thru outer contexts */
           pExpr->op = TK_AGG_FUNCTION;
           pExpr->op2 = 0;
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -99223,16 +100678,22 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
             sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
           }
 #endif
-          while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
+          pNC2 = pNC;
+          while( pNC2
+              && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
+          ){
             pExpr->op2++;
             pNC2 = pNC2->pNext;
           }
           assert( pDef!=0 || IN_RENAME_OBJECT );
           if( pNC2 && pDef ){
             assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
+            assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg );
             testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
-            pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);
-
+            testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 );
+            pNC2->ncFlags |= NC_HasAgg
+              | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER)
+                  & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER));
           }
         }
         pNC->ncFlags |= savedAllowFlags;
@@ -99248,15 +100709,17 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
     case TK_IN: {
       testcase( pExpr->op==TK_IN );
-      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+      if( ExprUseXSelect(pExpr) ){
         int nRef = pNC->nRef;
         testcase( pNC->ncFlags & NC_IsCheck );
         testcase( pNC->ncFlags & NC_PartIdx );
         testcase( pNC->ncFlags & NC_IdxExpr );
         testcase( pNC->ncFlags & NC_GenCol );
-        sqlite3ResolveNotValid(pParse, pNC, "subqueries",
-                 NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
-        sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
+        if( pNC->ncFlags & NC_SelfRef ){
+          notValidImpl(pParse, pNC, "subqueries", pExpr);
+        }else{
+          sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
+        }
         assert( pNC->nRef>=nRef );
         if( nRef!=pNC->nRef ){
           ExprSetProperty(pExpr, EP_VarSelect);
@@ -99280,7 +100743,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( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
         int rc = resolveExprStep(pWalker, pRight);
         if( rc==WRC_Abort ) return WRC_Abort;
         if( pRight->op==TK_TRUEFALSE ){
@@ -99303,6 +100766,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       assert( pExpr->pLeft!=0 );
       nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
       if( pExpr->op==TK_BETWEEN ){
+        assert( ExprUseXList(pExpr) );
         nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
         if( nRight==nLeft ){
           nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
@@ -99351,7 +100815,9 @@ static int resolveAsName(
   UNUSED_PARAMETER(pParse);
 
   if( pE->op==TK_ID ){
-    char *zCol = pE->u.zToken;
+    const char *zCol;
+    assert( !ExprHasProperty(pE, EP_IntValue) );
+    zCol = pE->u.zToken;
     for(i=0; i<pEList->nExpr; i++){
       if( pEList->a[i].eEName==ENAME_NAME
        && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
@@ -99402,11 +100868,11 @@ static int resolveOrderByTermToExprList(
   nc.pParse = pParse;
   nc.pSrcList = pSelect->pSrc;
   nc.uNC.pEList = pEList;
-  nc.ncFlags = NC_AllowAgg|NC_UEList;
-  nc.nErr = 0;
+  nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect;
+  nc.nNcErr = 0;
   db = pParse->db;
   savedSuppErr = db->suppressErr;
-  if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
+  db->suppressErr = 1;
   rc = sqlite3ResolveExprNames(&nc, pE);
   db->suppressErr = savedSuppErr;
   if( rc ) return 0;
@@ -99505,29 +100971,24 @@ static int resolveCompoundOrderBy(
           ** Once the comparisons are finished, the duplicate expression
           ** is deleted.
           **
-          ** Or, if this is running as part of an ALTER TABLE operation,
-          ** resolve the symbols in the actual expression, not a duplicate.
-          ** And, if one of the comparisons is successful, leave the expression
-          ** as is instead of transforming it to an integer as in the usual
-          ** case. This allows the code in alter.c to modify column
-          ** refererences within the ORDER BY expression as required.  */
-          if( IN_RENAME_OBJECT ){
-            pDup = pE;
-          }else{
-            pDup = sqlite3ExprDup(db, pE, 0);
-          }
+          ** If this is running as part of an ALTER TABLE operation and
+          ** the symbols resolve successfully, also resolve the symbols in the
+          ** actual expression. This allows the code in alter.c to modify
+          ** column references within the ORDER BY expression as required.  */
+          pDup = sqlite3ExprDup(db, pE, 0);
           if( !db->mallocFailed ){
             assert(pDup);
             iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
+            if( IN_RENAME_OBJECT && iCol>0 ){
+              resolveOrderByTermToExprList(pParse, pSelect, pE);
+            }
           }
-          if( !IN_RENAME_OBJECT ){
-            sqlite3ExprDelete(db, pDup);
-          }
+          sqlite3ExprDelete(db, pDup);
         }
       }
       if( iCol>0 ){
         /* Convert the ORDER BY term into an integer column number iCol,
-        ** taking care to preserve the COLLATE clause if it exists */
+        ** taking care to preserve the COLLATE clause if it exists. */
         if( !IN_RENAME_OBJECT ){
           Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
           if( pNew==0 ) return 1;
@@ -99596,8 +101057,7 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(
         resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
         return 1;
       }
-      resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
-                   zType,0);
+      resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
     }
   }
   return 0;
@@ -99663,7 +101123,7 @@ static int resolveOrderGroupBy(
   Parse *pParse;                 /* Parsing context */
   int nResult;                   /* Number of terms in the result set */
 
-  if( pOrderBy==0 ) return 0;
+  assert( pOrderBy!=0 );
   nResult = pSelect->pEList->nExpr;
   pParse = pNC->pParse;
   for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
@@ -99753,8 +101213,10 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
   while( p ){
     assert( (p->selFlags & SF_Expanded)!=0 );
     assert( (p->selFlags & SF_Resolved)==0 );
+    assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */
     p->selFlags |= SF_Resolved;
 
+
     /* Resolve the expressions in the LIMIT and OFFSET clauses. These
     ** are not allowed to refer to any names, so pass an empty NameContext.
     */
@@ -99779,30 +101241,29 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
       p->pOrderBy = 0;
     }
 
-    /* Recursively resolve names in all subqueries
+    /* Recursively resolve names in all subqueries in the FROM clause
     */
     for(i=0; i<p->pSrc->nSrc; i++){
-      struct SrcList_item *pItem = &p->pSrc->a[i];
+      SrcItem *pItem = &p->pSrc->a[i];
       if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
-        NameContext *pNC;         /* Used to iterate name contexts */
-        int nRef = 0;             /* Refcount for pOuterNC and outer contexts */
+        int nRef = pOuterNC ? pOuterNC->nRef : 0;
         const char *zSavedContext = pParse->zAuthContext;
 
-        /* Count the total number of references to pOuterNC and all of its
-        ** parent contexts. After resolving references to expressions in
-        ** pItem->pSelect, check if this value has changed. If so, then
-        ** SELECT statement pItem->pSelect must be correlated. Set the
-        ** pItem->fg.isCorrelated flag if this is the case. */
-        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
-
         if( pItem->zName ) pParse->zAuthContext = pItem->zName;
         sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
         pParse->zAuthContext = zSavedContext;
         if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
 
-        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
-        assert( pItem->fg.isCorrelated==0 && nRef<=0 );
-        pItem->fg.isCorrelated = (nRef!=0);
+        /* If the number of references to the outer context changed when
+        ** expressions in the sub-select were resolved, the sub-select
+        ** is correlated. It is not required to check the refcount on any
+        ** but the innermost outer context object, as lookupName() increments
+        ** the refcount on all contexts between the current one and the
+        ** context containing the column when it resolves a name. */
+        if( pOuterNC ){
+          assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef );
+          pItem->fg.isCorrelated = (pOuterNC->nRef>nRef);
+        }
       }
     }
 
@@ -99824,18 +101285,12 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     pGroupBy = p->pGroupBy;
     if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
       assert( NC_MinMaxAgg==SF_MinMaxAgg );
-      p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
+      assert( NC_OrderAgg==SF_OrderByReqd );
+      p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg));
     }else{
       sNC.ncFlags &= ~NC_AllowAgg;
     }
 
-    /* If a HAVING clause is present, then there must be a GROUP BY clause.
-    */
-    if( p->pHaving && !pGroupBy ){
-      sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
-      return WRC_Abort;
-    }
-
     /* Add the output column list to the name-context before parsing the
     ** other expressions in the SELECT statement. This is so that
     ** expressions in the WHERE clause (etc.) can refer to expressions by
@@ -99844,15 +101299,21 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** Minor point: If this is the case, then the expression will be
     ** re-evaluated for each reference to it.
     */
-    assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 );
+    assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
     sNC.uNC.pEList = p->pEList;
     sNC.ncFlags |= NC_UEList;
-    if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
+    if( p->pHaving ){
+      if( !pGroupBy ){
+        sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
+        return WRC_Abort;
+      }
+      if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
+    }
     if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
 
     /* Resolve names in table-valued-function arguments */
     for(i=0; i<p->pSrc->nSrc; i++){
-      struct SrcList_item *pItem = &p->pSrc->a[i];
+      SrcItem *pItem = &p->pSrc->a[i];
       if( pItem->fg.isTabFunc
        && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
       ){
@@ -99860,6 +101321,19 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
       }
     }
 
+#ifndef SQLITE_OMIT_WINDOWFUNC
+    if( IN_RENAME_OBJECT ){
+      Window *pWin;
+      for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
+        if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
+         || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
+        ){
+          return WRC_Abort;
+        }
+      }
+    }
+#endif
+
     /* The ORDER BY and GROUP BY clauses may not refer to terms in
     ** outer queries
     */
@@ -99887,7 +101361,8 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** is not detected until much later, and so we need to go ahead and
     ** resolve those symbols on the incorrect ORDER BY for consistency.
     */
-    if( isCompound<=nCompound  /* Defer right-most ORDER BY of a compound */
+    if( p->pOrderBy!=0
+     && isCompound<=nCompound  /* Defer right-most ORDER BY of a compound */
      && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
     ){
       return WRC_Abort;
@@ -99915,19 +101390,6 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
       }
     }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( IN_RENAME_OBJECT ){
-      Window *pWin;
-      for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
-        if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
-         || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
-        ){
-          return WRC_Abort;
-        }
-      }
-    }
-#endif
-
     /* If this is part of a compound SELECT, check that it has the right
     ** number of expressions in the select list. */
     if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
@@ -100007,11 +101469,11 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
   Walker w;
 
   if( pExpr==0 ) return SQLITE_OK;
-  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
-  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
+  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
+  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
   w.pParse = pNC->pParse;
   w.xExprCallback = resolveExprStep;
-  w.xSelectCallback = resolveSelectStep;
+  w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep;
   w.xSelectCallback2 = 0;
   w.u.pNC = pNC;
 #if SQLITE_MAX_EXPR_DEPTH>0
@@ -100030,7 +101492,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
   testcase( pNC->ncFlags & NC_HasWin );
   ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
   pNC->ncFlags |= savedHasAgg;
-  return pNC->nErr>0 || w.pParse->nErr>0;
+  return pNC->nNcErr>0 || w.pParse->nErr>0;
 }
 
 /*
@@ -100051,8 +101513,8 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames(
   w.xSelectCallback = resolveSelectStep;
   w.xSelectCallback2 = 0;
   w.u.pNC = pNC;
-  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
-  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
+  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
+  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
   for(i=0; i<pList->nExpr; i++){
     Expr *pExpr = pList->a[i].pExpr;
     if( pExpr==0 ) continue;
@@ -100070,12 +101532,13 @@ SQLITE_PRIVATE int sqlite3ResolveExprListNames(
     assert( EP_Win==NC_HasWin );
     testcase( pNC->ncFlags & NC_HasAgg );
     testcase( pNC->ncFlags & NC_HasWin );
-    if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
+    if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){
       ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
-      savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
-      pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
+      savedHasAgg |= pNC->ncFlags &
+                          (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
+      pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg);
     }
-    if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort;
+    if( w.pParse->nErr>0 ) return WRC_Abort;
   }
   pNC->ncFlags |= savedHasAgg;
   return WRC_Continue;
@@ -100187,9 +101650,9 @@ static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree);
 /*
 ** Return the affinity character for a single column of a table.
 */
-SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table *pTab, int iCol){
-  assert( iCol<pTab->nCol );
-  return iCol>=0 ? pTab->aCol[iCol].affinity : SQLITE_AFF_INTEGER;
+SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
+  if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
+  return pTab->aCol[iCol].affinity;
 }
 
 /*
@@ -100218,30 +101681,36 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
     assert( pExpr!=0 );
   }
   op = pExpr->op;
+  if( op==TK_REGISTER ) op = pExpr->op2;
+  if( op==TK_COLUMN || op==TK_AGG_COLUMN ){
+    assert( ExprUseYTab(pExpr) );
+    if( pExpr->y.pTab ){
+      return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
+    }
+  }
   if( op==TK_SELECT ){
-    assert( pExpr->flags&EP_xIsSelect );
+    assert( ExprUseXSelect(pExpr) );
     assert( pExpr->x.pSelect!=0 );
     assert( pExpr->x.pSelect->pEList!=0 );
     assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
     return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
   }
-  if( op==TK_REGISTER ) op = pExpr->op2;
 #ifndef SQLITE_OMIT_CAST
   if( op==TK_CAST ){
     assert( !ExprHasProperty(pExpr, EP_IntValue) );
     return sqlite3AffinityType(pExpr->u.zToken, 0);
   }
 #endif
-  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
-    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
-  }
   if( op==TK_SELECT_COLUMN ){
-    assert( pExpr->pLeft->flags&EP_xIsSelect );
+    assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );
+    assert( pExpr->iColumn < pExpr->iTable );
+    assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );
     return sqlite3ExprAffinity(
         pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
     );
   }
   if( op==TK_VECTOR ){
+    assert( ExprUseXList(pExpr) );
     return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
   }
   return pExpr->affExpr;
@@ -100256,7 +101725,7 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
 ** and the pExpr parameter is returned unchanged.
 */
 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(
-  Parse *pParse,           /* Parsing context */
+  const Parse *pParse,     /* Parsing context */
   Expr *pExpr,             /* Add the "COLLATE" clause to this expression */
   const Token *pCollName,  /* Name of collating sequence */
   int dequote              /* True to dequote pCollName */
@@ -100271,7 +101740,11 @@ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(
   }
   return pExpr;
 }
-SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
+SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(
+  const Parse *pParse,  /* Parsing context */
+  Expr *pExpr,          /* Add the "COLLATE" clause to this expression */
+  const char *zC        /* The collating sequence name */
+){
   Token s;
   assert( zC!=0 );
   sqlite3TokenInit(&s, (char*)zC);
@@ -100297,7 +101770,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
   while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
     if( ExprHasProperty(pExpr, EP_Unlikely) ){
-      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
+      assert( ExprUseXList(pExpr) );
       assert( pExpr->x.pList->nExpr>0 );
       assert( pExpr->op==TK_FUNCTION );
       pExpr = pExpr->x.pList->a[0].pExpr;
@@ -100330,27 +101803,30 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
   while( p ){
     int op = p->op;
     if( op==TK_REGISTER ) op = p->op2;
-    if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER)
-     && p->y.pTab!=0
-    ){
-      /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
-      ** a TK_COLUMN but was previously evaluated and cached in a register */
-      int j = p->iColumn;
-      if( j>=0 ){
-        const char *zColl = p->y.pTab->aCol[j].zColl;
-        pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
+    if( op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER ){
+      assert( ExprUseYTab(p) );
+      if( p->y.pTab!=0 ){
+        /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
+        ** a TK_COLUMN but was previously evaluated and cached in a register */
+        int j = p->iColumn;
+        if( j>=0 ){
+          const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]);
+          pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
+        }
+        break;
       }
-      break;
     }
     if( op==TK_CAST || op==TK_UPLUS ){
       p = p->pLeft;
       continue;
     }
     if( op==TK_VECTOR ){
+      assert( ExprUseXList(p) );
       p = p->x.pList->a[0].pExpr;
       continue;
     }
     if( op==TK_COLLATE ){
+      assert( !ExprHasProperty(p, EP_IntValue) );
       pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
       break;
     }
@@ -100360,11 +101836,9 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
       }else{
         Expr *pNext  = p->pRight;
         /* The Expr.x union is never used at the same time as Expr.pRight */
+        assert( ExprUseXList(p) );
         assert( p->x.pList==0 || p->pRight==0 );
-        if( p->x.pList!=0
-         && !db->mallocFailed
-         && ALWAYS(!ExprHasProperty(p, EP_xIsSelect))
-        ){
+        if( p->x.pList!=0 && !db->mallocFailed ){
           int i;
           for(i=0; ALWAYS(i<p->x.pList->nExpr); i++){
             if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
@@ -100447,7 +101921,7 @@ static char comparisonAffinity(const Expr *pExpr){
   aff = sqlite3ExprAffinity(pExpr->pLeft);
   if( pExpr->pRight ){
     aff = sqlite3CompareAffinity(pExpr->pRight, aff);
-  }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+  }else if( ExprUseXSelect(pExpr) ){
     aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
   }else if( aff==0 ){
     aff = SQLITE_AFF_BLOB;
@@ -100573,7 +102047,7 @@ static int codeCompare(
 ** But a TK_SELECT might be either a vector or a scalar. It is only
 ** considered a vector if it has two or more result columns.
 */
-SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){
+SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){
   return sqlite3ExprVectorSize(pExpr)>1;
 }
 
@@ -100583,12 +102057,14 @@ SQLITE_PRIVATE int sqlite3ExprIsVector(Expr *pExpr){
 ** is a sub-select, return the number of columns in the sub-select. For
 ** any other type of expression, return 1.
 */
-SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){
+SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){
   u8 op = pExpr->op;
   if( op==TK_REGISTER ) op = pExpr->op2;
   if( op==TK_VECTOR ){
+    assert( ExprUseXList(pExpr) );
     return pExpr->x.pList->nExpr;
   }else if( op==TK_SELECT ){
+    assert( ExprUseXSelect(pExpr) );
     return pExpr->x.pSelect->pEList->nExpr;
   }else{
     return 1;
@@ -100611,12 +102087,14 @@ SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){
 ** been positioned.
 */
 SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){
-  assert( i<sqlite3ExprVectorSize(pVector) );
+  assert( i<sqlite3ExprVectorSize(pVector) || pVector->op==TK_ERROR );
   if( sqlite3ExprIsVector(pVector) ){
     assert( pVector->op2==0 || pVector->op==TK_REGISTER );
     if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){
+      assert( ExprUseXSelect(pVector) );
       return pVector->x.pSelect->pEList->a[i].pExpr;
     }else{
+      assert( ExprUseXList(pVector) );
       return pVector->x.pList->a[i].pExpr;
     }
   }
@@ -100647,11 +102125,12 @@ SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){
 SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(
   Parse *pParse,       /* Parsing context */
   Expr *pVector,       /* The vector.  List of expressions or a sub-SELECT */
-  int iField           /* Which column of the vector to return */
+  int iField,          /* Which column of the vector to return */
+  int nField           /* Total number of columns in the vector */
 ){
   Expr *pRet;
   if( pVector->op==TK_SELECT ){
-    assert( pVector->flags & EP_xIsSelect );
+    assert( ExprUseXSelect(pVector) );
     /* The TK_SELECT_COLUMN Expr node:
     **
     ** pLeft:           pVector containing TK_SELECT.  Not deleted.
@@ -100670,14 +102149,23 @@ SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(
     */
     pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0);
     if( pRet ){
+      pRet->iTable = nField;
       pRet->iColumn = iField;
       pRet->pLeft = pVector;
     }
-    assert( pRet==0 || pRet->iTable==0 );
   }else{
-    if( pVector->op==TK_VECTOR ) pVector = pVector->x.pList->a[iField].pExpr;
+    if( pVector->op==TK_VECTOR ){
+      Expr **ppVector;
+      assert( ExprUseXList(pVector) );
+      ppVector = &pVector->x.pList->a[iField].pExpr;
+      pVector = *ppVector;
+      if( IN_RENAME_OBJECT ){
+        /* This must be a vector UPDATE inside a trigger */
+        *ppVector = 0;
+        return pVector;
+      }
+    }
     pRet = sqlite3ExprDup(pParse->db, pVector, 0);
-    sqlite3RenameTokenRemap(pParse, pRet, pVector);
   }
   return pRet;
 }
@@ -100727,17 +102215,22 @@ static int exprVectorRegister(
   int *pRegFree                   /* OUT: Temp register to free */
 ){
   u8 op = pVector->op;
-  assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT );
+  assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT || op==TK_ERROR );
   if( op==TK_REGISTER ){
     *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
     return pVector->iTable+iField;
   }
   if( op==TK_SELECT ){
+    assert( ExprUseXSelect(pVector) );
     *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
      return regSelect+iField;
   }
-  *ppExpr = pVector->x.pList->a[iField].pExpr;
-  return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
+  if( op==TK_VECTOR ){
+    assert( ExprUseXList(pVector) );
+    *ppExpr = pVector->x.pList->a[iField].pExpr;
+    return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
+  }
+  return 0;
 }
 
 /*
@@ -100766,6 +102259,7 @@ static void codeVectorCompare(
   int regLeft = 0;
   int regRight = 0;
   u8 opx = op;
+  int addrCmp = 0;
   int addrDone = sqlite3VdbeMakeLabel(pParse);
   int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
 
@@ -100785,21 +102279,24 @@ static void codeVectorCompare(
   assert( p5==0 || pExpr->op!=op );
   assert( p5==SQLITE_NULLEQ || pExpr->op==op );
 
-  p5 |= SQLITE_STOREP2;
-  if( opx==TK_LE ) opx = TK_LT;
-  if( opx==TK_GE ) opx = TK_GT;
+  if( op==TK_LE ) opx = TK_LT;
+  if( op==TK_GE ) opx = TK_GT;
+  if( op==TK_NE ) opx = TK_EQ;
 
   regLeft = exprCodeSubselect(pParse, pLeft);
   regRight = exprCodeSubselect(pParse, pRight);
 
+  sqlite3VdbeAddOp2(v, OP_Integer, 1, dest);
   for(i=0; 1 /*Loop exits by "break"*/; i++){
     int regFree1 = 0, regFree2 = 0;
-    Expr *pL, *pR;
+    Expr *pL = 0, *pR = 0;
     int r1, r2;
     assert( i>=0 && i<nLeft );
+    if( addrCmp ) sqlite3VdbeJumpHere(v, addrCmp);
     r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, &regFree1);
     r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, &regFree2);
-    codeCompare(pParse, pL, pR, opx, r1, r2, dest, p5, isCommuted);
+    addrCmp = sqlite3VdbeCurrentAddr(v);
+    codeCompare(pParse, pL, pR, opx, r1, r2, addrDone, p5, isCommuted);
     testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
     testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
     testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
@@ -100808,26 +102305,32 @@ static void codeVectorCompare(
     testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
     sqlite3ReleaseTempReg(pParse, regFree1);
     sqlite3ReleaseTempReg(pParse, regFree2);
+    if( (opx==TK_LT || opx==TK_GT) && i<nLeft-1 ){
+      addrCmp = sqlite3VdbeAddOp0(v, OP_ElseEq);
+      testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT);
+      testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT);
+    }
+    if( p5==SQLITE_NULLEQ ){
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, dest);
+    }else{
+      sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, dest, r2);
+    }
     if( i==nLeft-1 ){
       break;
     }
     if( opx==TK_EQ ){
-      sqlite3VdbeAddOp2(v, OP_IfNot, dest, addrDone); VdbeCoverage(v);
-      p5 |= SQLITE_KEEPNULL;
-    }else if( opx==TK_NE ){
-      sqlite3VdbeAddOp2(v, OP_If, dest, addrDone); VdbeCoverage(v);
-      p5 |= SQLITE_KEEPNULL;
+      sqlite3VdbeAddOp2(v, OP_NotNull, dest, addrDone); VdbeCoverage(v);
     }else{
       assert( op==TK_LT || op==TK_GT || op==TK_LE || op==TK_GE );
-      sqlite3VdbeAddOp2(v, OP_ElseNotEq, 0, addrDone);
-      VdbeCoverageIf(v, op==TK_LT);
-      VdbeCoverageIf(v, op==TK_GT);
-      VdbeCoverageIf(v, op==TK_LE);
-      VdbeCoverageIf(v, op==TK_GE);
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
       if( i==nLeft-2 ) opx = op;
     }
   }
+  sqlite3VdbeJumpHere(v, addrCmp);
   sqlite3VdbeResolveLabel(v, addrDone);
+  if( op==TK_NE ){
+    sqlite3VdbeAddOp2(v, OP_Not, dest, dest);
+  }
 }
 
 #if SQLITE_MAX_EXPR_DEPTH>0
@@ -100857,14 +102360,14 @@ SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
 ** to by pnHeight, the second parameter, then set *pnHeight to that
 ** value.
 */
-static void heightOfExpr(Expr *p, int *pnHeight){
+static void heightOfExpr(const Expr *p, int *pnHeight){
   if( p ){
     if( p->nHeight>*pnHeight ){
       *pnHeight = p->nHeight;
     }
   }
 }
-static void heightOfExprList(ExprList *p, int *pnHeight){
+static void heightOfExprList(const ExprList *p, int *pnHeight){
   if( p ){
     int i;
     for(i=0; i<p->nExpr; i++){
@@ -100872,8 +102375,8 @@ static void heightOfExprList(ExprList *p, int *pnHeight){
     }
   }
 }
-static void heightOfSelect(Select *pSelect, int *pnHeight){
-  Select *p;
+static void heightOfSelect(const Select *pSelect, int *pnHeight){
+  const Select *p;
   for(p=pSelect; p; p=p->pPrior){
     heightOfExpr(p->pWhere, pnHeight);
     heightOfExpr(p->pHaving, pnHeight);
@@ -100898,7 +102401,7 @@ static void exprSetHeight(Expr *p){
   int nHeight = 0;
   heightOfExpr(p->pLeft, &nHeight);
   heightOfExpr(p->pRight, &nHeight);
-  if( ExprHasProperty(p, EP_xIsSelect) ){
+  if( ExprUseXSelect(p) ){
     heightOfSelect(p->x.pSelect, &nHeight);
   }else if( p->x.pList ){
     heightOfExprList(p->x.pList, &nHeight);
@@ -100925,7 +102428,7 @@ SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
 ** Return the maximum height of any expression tree referenced
 ** by the select statement passed as an argument.
 */
-SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){
+SQLITE_PRIVATE int sqlite3SelectExprHeight(const Select *p){
   int nHeight = 0;
   heightOfSelect(p, &nHeight);
   return nHeight;
@@ -100937,7 +102440,7 @@ SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){
 */
 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
   if( pParse->nErr ) return;
-  if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){
+  if( p && ExprUseXList(p) && p->x.pList ){
     p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
   }
 }
@@ -101095,6 +102598,63 @@ SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pS
   }
 }
 
+/*
+** Expression list pEList is a list of vector values. This function
+** converts the contents of pEList to a VALUES(...) Select statement
+** returning 1 row for each element of the list. For example, the
+** expression list:
+**
+**   ( (1,2), (3,4) (5,6) )
+**
+** is translated to the equivalent of:
+**
+**   VALUES(1,2), (3,4), (5,6)
+**
+** Each of the vector values in pEList must contain exactly nElem terms.
+** If a list element that is not a vector or does not contain nElem terms,
+** an error message is left in pParse.
+**
+** This is used as part of processing IN(...) expressions with a list
+** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
+*/
+SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprList *pEList){
+  int ii;
+  Select *pRet = 0;
+  assert( nElem>1 );
+  for(ii=0; ii<pEList->nExpr; ii++){
+    Select *pSel;
+    Expr *pExpr = pEList->a[ii].pExpr;
+    int nExprElem;
+    if( pExpr->op==TK_VECTOR ){
+      assert( ExprUseXList(pExpr) );
+      nExprElem = pExpr->x.pList->nExpr;
+    }else{
+      nExprElem = 1;
+    }
+    if( nExprElem!=nElem ){
+      sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d",
+          nExprElem, nExprElem>1?"s":"", nElem
+      );
+      break;
+    }
+    assert( ExprUseXList(pExpr) );
+    pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
+    pExpr->x.pList = 0;
+    if( pSel ){
+      if( pRet ){
+        pSel->op = TK_ALL;
+        pSel->pPrior = pRet;
+      }
+      pRet = pSel;
+    }
+  }
+
+  if( pRet && pRet->pPrior ){
+    pRet->selFlags |= SF_MultiValue;
+  }
+  sqlite3ExprListDelete(pParse->db, pEList);
+  return pRet;
+}
 
 /*
 ** Join two expressions using an AND operator.  If either expression is
@@ -101113,8 +102673,8 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
   }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight))
          && !IN_RENAME_OBJECT
   ){
-    sqlite3ExprDelete(db, pLeft);
-    sqlite3ExprDelete(db, pRight);
+    sqlite3ExprDeferredDelete(pParse, pLeft);
+    sqlite3ExprDeferredDelete(pParse, pRight);
     return sqlite3Expr(db, TK_INTEGER, "0");
   }else{
     return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
@@ -101128,7 +102688,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
 SQLITE_PRIVATE Expr *sqlite3ExprFunction(
   Parse *pParse,        /* Parsing context */
   ExprList *pList,      /* Argument list */
-  Token *pToken,        /* Name of the function */
+  const Token *pToken,  /* Name of the function */
   int eDistinct         /* SF_Distinct or SF_ALL or 0 */
 ){
   Expr *pNew;
@@ -101139,12 +102699,15 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction(
     sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
     return 0;
   }
-  if( pList && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
+  if( pList
+   && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
+   && !pParse->nested
+  ){
     sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken);
   }
   pNew->x.pList = pList;
   ExprSetProperty(pNew, EP_HasFunc);
-  assert( !ExprHasProperty(pNew, EP_xIsSelect) );
+  assert( ExprUseXList(pNew) );
   sqlite3ExprSetHeightAndFlags(pParse, pNew);
   if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct);
   return pNew;
@@ -101163,8 +102726,8 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction(
 */
 SQLITE_PRIVATE void sqlite3ExprFunctionUsable(
   Parse *pParse,         /* Parsing and code generating context */
-  Expr *pExpr,           /* The function invocation */
-  FuncDef *pDef          /* The function being invoked */
+  const Expr *pExpr,     /* The function invocation */
+  const FuncDef *pDef    /* The function being invoked */
 ){
   assert( !IN_RENAME_OBJECT );
   assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 );
@@ -101270,27 +102833,26 @@ SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n
 */
 static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
   assert( p!=0 );
-  /* Sanity check: Assert that the IntValue is non-negative if it exists */
-  assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
-
-  assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed );
-  assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced)
-          || p->y.pWin==0 || ExprHasProperty(p, EP_WinFunc) );
+  assert( !ExprUseUValue(p) || p->u.iValue>=0 );
+  assert( !ExprUseYWin(p) || !ExprUseYSub(p) );
+  assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed );
+  assert( p->op!=TK_FUNCTION || !ExprUseYSub(p) );
 #ifdef SQLITE_DEBUG
   if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){
     assert( p->pLeft==0 );
     assert( p->pRight==0 );
-    assert( p->x.pSelect==0 );
+    assert( !ExprUseXSelect(p) || p->x.pSelect==0 );
+    assert( !ExprUseXList(p) || p->x.pList==0 );
   }
 #endif
   if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
     /* The Expr.x union is never used at the same time as Expr.pRight */
-    assert( p->x.pList==0 || p->pRight==0 );
+    assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 );
     if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft);
     if( p->pRight ){
       assert( !ExprHasProperty(p, EP_WinFunc) );
       sqlite3ExprDeleteNN(db, p->pRight);
-    }else if( ExprHasProperty(p, EP_xIsSelect) ){
+    }else if( ExprUseXSelect(p) ){
       assert( !ExprHasProperty(p, EP_WinFunc) );
       sqlite3SelectDelete(db, p->x.pSelect);
     }else{
@@ -101302,7 +102864,10 @@ static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
 #endif
     }
   }
-  if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
+  if( ExprHasProperty(p, EP_MemToken) ){
+    assert( !ExprHasProperty(p, EP_IntValue) );
+    sqlite3DbFree(db, p->u.zToken);
+  }
   if( !ExprHasProperty(p, EP_Static) ){
     sqlite3DbFreeNN(db, p);
   }
@@ -101311,6 +102876,22 @@ SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
   if( p ) sqlite3ExprDeleteNN(db, p);
 }
 
+
+/*
+** Arrange to cause pExpr to be deleted when the pParse is deleted.
+** This is similar to sqlite3ExprDelete() except that the delete is
+** deferred untilthe pParse is deleted.
+**
+** The pExpr might be deleted immediately on an OOM error.
+**
+** The deferred delete is (currently) implemented by adding the
+** pExpr to the pParse->pConstExpr list with a register number of 0.
+*/
+SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
+  pParse->pConstExpr =
+      sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
+}
+
 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
 ** expression.
 */
@@ -101328,7 +102909,7 @@ SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){
 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
 */
-static int exprStructSize(Expr *p){
+static int exprStructSize(const Expr *p){
   if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
   if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
   return EXPR_FULLSIZE;
@@ -101368,7 +102949,7 @@ static int exprStructSize(Expr *p){
 ** of dupedExprStructSize() contain multiple assert() statements that attempt
 ** to enforce this constraint.
 */
-static int dupedExprStructSize(Expr *p, int flags){
+static int dupedExprStructSize(const Expr *p, int flags){
   int nSize;
   assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
   assert( EXPR_FULLSIZE<=0xfff );
@@ -101399,7 +102980,7 @@ static int dupedExprStructSize(Expr *p, int flags){
 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
 ** string is defined.)
 */
-static int dupedExprNodeSize(Expr *p, int flags){
+static int dupedExprNodeSize(const Expr *p, int flags){
   int nByte = dupedExprStructSize(p, flags) & 0xfff;
   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
     nByte += sqlite3Strlen30NN(p->u.zToken)+1;
@@ -101420,7 +103001,7 @@ static int dupedExprNodeSize(Expr *p, int flags){
 ** and Expr.pRight variables (but not for any structures pointed to or
 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
 */
-static int dupedExprSize(Expr *p, int flags){
+static int dupedExprSize(const Expr *p, int flags){
   int nByte = 0;
   if( p ){
     nByte = dupedExprNodeSize(p, flags);
@@ -101439,7 +103020,7 @@ static int dupedExprSize(Expr *p, int flags){
 ** if any. Before returning, *pzBuffer is set to the first byte past the
 ** portion of the buffer copied into by this function.
 */
-static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){
+static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){
   Expr *pNew;           /* Value to return */
   u8 *zAlloc;           /* Memory space from which to build Expr object */
   u32 staticFlag;       /* EP_Static if space not obtained from malloc */
@@ -101453,6 +103034,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){
   if( pzBuffer ){
     zAlloc = *pzBuffer;
     staticFlag = EP_Static;
+    assert( zAlloc!=0 );
   }else{
     zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags));
     staticFlag = 0;
@@ -101501,7 +103083,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){
 
     if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){
       /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
-      if( ExprHasProperty(p, EP_xIsSelect) ){
+      if( ExprUseXSelect(p) ){
         pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags);
       }else{
         pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags);
@@ -101530,8 +103112,8 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){
       if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
         if( pNew->op==TK_SELECT_COLUMN ){
           pNew->pLeft = p->pLeft;
-          assert( p->iColumn==0 || p->pRight==0 );
-          assert( p->pRight==0  || p->pRight==p->pLeft );
+          assert( p->pRight==0  || p->pRight==p->pLeft
+                                || ExprHasProperty(p->pLeft, EP_Subquery) );
         }else{
           pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
         }
@@ -101548,7 +103130,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int dupFlags, u8 **pzBuffer){
 ** and the db->mallocFailed flag set.
 */
 #ifndef SQLITE_OMIT_CTE
-static With *withDup(sqlite3 *db, With *p){
+SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p){
   With *pRet = 0;
   if( p ){
     sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
@@ -101566,7 +103148,7 @@ static With *withDup(sqlite3 *db, With *p){
   return pRet;
 }
 #else
-# define withDup(x,y) 0
+# define sqlite3WithDup(x,y) 0
 #endif
 
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -101619,20 +103201,23 @@ static void gatherSelectWindows(Select *p){
 ** truncated version of the usual Expr structure that will be stored as
 ** part of the in-memory representation of the database schema.
 */
-SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
+SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, const Expr *p, int flags){
   assert( flags==0 || flags==EXPRDUP_REDUCE );
   return p ? exprDup(db, p, flags, 0) : 0;
 }
-SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
+SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int flags){
   ExprList *pNew;
-  struct ExprList_item *pItem, *pOldItem;
+  struct ExprList_item *pItem;
+  const struct ExprList_item *pOldItem;
   int i;
-  Expr *pPriorSelectCol = 0;
+  Expr *pPriorSelectColOld = 0;
+  Expr *pPriorSelectColNew = 0;
   assert( db!=0 );
   if( p==0 ) return 0;
   pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p));
   if( pNew==0 ) return 0;
   pNew->nExpr = p->nExpr;
+  pNew->nAlloc = p->nAlloc;
   pItem = pNew->a;
   pOldItem = p->a;
   for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
@@ -101643,16 +103228,17 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags)
      && pOldExpr->op==TK_SELECT_COLUMN
      && (pNewExpr = pItem->pExpr)!=0
     ){
-      assert( pNewExpr->iColumn==0 || i>0 );
-      if( pNewExpr->iColumn==0 ){
-        assert( pOldExpr->pLeft==pOldExpr->pRight );
-        pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
+      if( pNewExpr->pRight ){
+        pPriorSelectColOld = pOldExpr->pRight;
+        pPriorSelectColNew = pNewExpr->pRight;
+        pNewExpr->pLeft = pNewExpr->pRight;
       }else{
-        assert( i>0 );
-        assert( pItem[-1].pExpr!=0 );
-        assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
-        assert( pPriorSelectCol==pItem[-1].pExpr->pLeft );
-        pNewExpr->pLeft = pPriorSelectCol;
+        if( pOldExpr->pLeft!=pPriorSelectColOld ){
+          pPriorSelectColOld = pOldExpr->pLeft;
+          pPriorSelectColNew = sqlite3ExprDup(db, pPriorSelectColOld, flags);
+          pNewExpr->pRight = pPriorSelectColNew;
+        }
+        pNewExpr->pLeft = pPriorSelectColNew;
       }
     }
     pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName);
@@ -101674,7 +103260,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags)
 */
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
  || !defined(SQLITE_OMIT_SUBQUERY)
-SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
+SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int flags){
   SrcList *pNew;
   int i;
   int nByte;
@@ -101685,8 +103271,8 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
   if( pNew==0 ) return 0;
   pNew->nSrc = pNew->nAlloc = p->nSrc;
   for(i=0; i<p->nSrc; i++){
-    struct SrcList_item *pNewItem = &pNew->a[i];
-    struct SrcList_item *pOldItem = &p->a[i];
+    SrcItem *pNewItem = &pNew->a[i];
+    const SrcItem *pOldItem = &p->a[i];
     Table *pTab;
     pNewItem->pSchema = pOldItem->pSchema;
     pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
@@ -101699,7 +103285,10 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
     if( pNewItem->fg.isIndexedBy ){
       pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy);
     }
-    pNewItem->pIBIndex = pOldItem->pIBIndex;
+    pNewItem->u2 = pOldItem->u2;
+    if( pNewItem->fg.isCte ){
+      pNewItem->u2.pCteUse->nUse++;
+    }
     if( pNewItem->fg.isTabFunc ){
       pNewItem->u1.pFuncArg =
           sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags);
@@ -101715,7 +103304,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
   }
   return pNew;
 }
-SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
+SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, const IdList *p){
   IdList *pNew;
   int i;
   assert( db!=0 );
@@ -101739,11 +103328,11 @@ SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
   }
   return pNew;
 }
-SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){
+SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int flags){
   Select *pRet = 0;
   Select *pNext = 0;
   Select **pp = &pRet;
-  Select *p;
+  const Select *p;
 
   assert( db!=0 );
   for(p=pDup; p; p=p->pPrior){
@@ -101765,13 +103354,21 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){
     pNew->addrOpenEphm[0] = -1;
     pNew->addrOpenEphm[1] = -1;
     pNew->nSelectRow = p->nSelectRow;
-    pNew->pWith = withDup(db, p->pWith);
+    pNew->pWith = sqlite3WithDup(db, p->pWith);
 #ifndef SQLITE_OMIT_WINDOWFUNC
     pNew->pWin = 0;
     pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
     if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
 #endif
     pNew->selId = p->selId;
+    if( db->mallocFailed ){
+      /* Any prior OOM might have left the Select object incomplete.
+      ** Delete the whole thing rather than allow an incomplete Select
+      ** to be used by the code generator. */
+      pNew->pNext = 0;
+      sqlite3SelectDelete(db, pNew);
+      break;
+    }
     *pp = pNew;
     pp = &pNew->pPrior;
     pNext = pNew;
@@ -101780,7 +103377,7 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *pDup, int flags){
   return pRet;
 }
 #else
-SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
+SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *p, int flags){
   assert( p==0 );
   return 0;
 }
@@ -101802,41 +103399,64 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
 ** NULL is returned.  If non-NULL is returned, then it is guaranteed
 ** that the new entry was successfully appended.
 */
+static const struct ExprList_item zeroItem = {0};
+SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendNew(
+  sqlite3 *db,            /* Database handle.  Used for memory allocation */
+  Expr *pExpr             /* Expression to be appended. Might be NULL */
+){
+  struct ExprList_item *pItem;
+  ExprList *pList;
+
+  pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 );
+  if( pList==0 ){
+    sqlite3ExprDelete(db, pExpr);
+    return 0;
+  }
+  pList->nAlloc = 4;
+  pList->nExpr = 1;
+  pItem = &pList->a[0];
+  *pItem = zeroItem;
+  pItem->pExpr = pExpr;
+  return pList;
+}
+SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendGrow(
+  sqlite3 *db,            /* Database handle.  Used for memory allocation */
+  ExprList *pList,        /* List to which to append. Might be NULL */
+  Expr *pExpr             /* Expression to be appended. Might be NULL */
+){
+  struct ExprList_item *pItem;
+  ExprList *pNew;
+  pList->nAlloc *= 2;
+  pNew = sqlite3DbRealloc(db, pList,
+       sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0]));
+  if( pNew==0 ){
+    sqlite3ExprListDelete(db, pList);
+    sqlite3ExprDelete(db, pExpr);
+    return 0;
+  }else{
+    pList = pNew;
+  }
+  pItem = &pList->a[pList->nExpr++];
+  *pItem = zeroItem;
+  pItem->pExpr = pExpr;
+  return pList;
+}
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(
   Parse *pParse,          /* Parsing context */
   ExprList *pList,        /* List to which to append. Might be NULL */
   Expr *pExpr             /* Expression to be appended. Might be NULL */
 ){
   struct ExprList_item *pItem;
-  sqlite3 *db = pParse->db;
-  assert( db!=0 );
   if( pList==0 ){
-    pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) );
-    if( pList==0 ){
-      goto no_mem;
-    }
-    pList->nExpr = 0;
-  }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
-    ExprList *pNew;
-    pNew = sqlite3DbRealloc(db, pList,
-         sizeof(*pList)+(2*(sqlite3_int64)pList->nExpr-1)*sizeof(pList->a[0]));
-    if( pNew==0 ){
-      goto no_mem;
-    }
-    pList = pNew;
+    return sqlite3ExprListAppendNew(pParse->db,pExpr);
+  }
+  if( pList->nAlloc<pList->nExpr+1 ){
+    return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
   }
   pItem = &pList->a[pList->nExpr++];
-  assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) );
-  assert( offsetof(struct ExprList_item,pExpr)==0 );
-  memset(&pItem->zEName,0,sizeof(*pItem)-offsetof(struct ExprList_item,zEName));
+  *pItem = zeroItem;
   pItem->pExpr = pExpr;
   return pList;
-
-no_mem:
-  /* Avoid leaking memory if malloc has failed. */
-  sqlite3ExprDelete(db, pExpr);
-  sqlite3ExprListDelete(db, pList);
-  return 0;
 }
 
 /*
@@ -101877,11 +103497,9 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(
   }
 
   for(i=0; i<pColumns->nId; i++){
-    Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i);
+    Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
     assert( pSubExpr!=0 || db->mallocFailed );
-    assert( pSubExpr==0 || pSubExpr->iTable==0 );
     if( pSubExpr==0 ) continue;
-    pSubExpr->iTable = pColumns->nId;
     pList = sqlite3ExprListAppend(pParse, pList, pSubExpr);
     if( pList ){
       assert( pList->nExpr==iFirst+i+1 );
@@ -101955,7 +103573,7 @@ SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int
 SQLITE_PRIVATE void sqlite3ExprListSetName(
   Parse *pParse,          /* Parsing context */
   ExprList *pList,        /* List to which to add the span. */
-  Token *pName,           /* Name to be added */
+  const Token *pName,     /* Name to be added */
   int dequote             /* True to cause the name to be dequoted */
 ){
   assert( pList!=0 || pParse->db->mallocFailed!=0 );
@@ -101973,7 +103591,7 @@ SQLITE_PRIVATE void sqlite3ExprListSetName(
       ** to the token-map.  */
       sqlite3Dequote(pItem->zEName);
       if( IN_RENAME_OBJECT ){
-        sqlite3RenameTokenMap(pParse, (void*)pItem->zEName, pName);
+        sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName);
       }
     }
   }
@@ -102092,7 +103710,7 @@ SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char *zIn){
 SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
   u32 v;
   assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
-  if( !ExprHasProperty(pExpr, EP_Quoted)
+  if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
    && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
   ){
     pExpr->op = TK_TRUEFALSE;
@@ -102109,6 +103727,7 @@ SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
 SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
   pExpr = sqlite3ExprSkipCollate((Expr*)pExpr);
   assert( pExpr->op==TK_TRUEFALSE );
+  assert( !ExprHasProperty(pExpr, EP_IntValue) );
   assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
        || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
   return pExpr->u.zToken[4]==0;
@@ -102313,7 +103932,7 @@ static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
   }
 
   /* Check if pExpr is a sub-select. If so, consider it variable. */
-  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+  if( ExprUseXSelect(pExpr) ){
     pWalker->eCode = 0;
     return WRC_Abort;
   }
@@ -102401,7 +104020,7 @@ SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){
 ** in *pValue.  If the expression is not an integer or if it is too big
 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
 */
-SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){
+SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){
   int rc = 0;
   if( NEVER(p==0) ) return 0;  /* Used to only happen following on OOM */
 
@@ -102420,9 +104039,9 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){
       break;
     }
     case TK_UMINUS: {
-      int v;
+      int v = 0;
       if( sqlite3ExprIsInteger(p->pLeft, &v) ){
-        assert( v!=(-2147483647-1) );
+        assert( ((unsigned int)v)!=0x80000000 );
         *pValue = -v;
         rc = 1;
       }
@@ -102449,8 +104068,10 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){
 */
 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
   u8 op;
+  assert( p!=0 );
   while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
     p = p->pLeft;
+    assert( p!=0 );
   }
   op = p->op;
   if( op==TK_REGISTER ) op = p->op2;
@@ -102461,6 +104082,7 @@ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
     case TK_BLOB:
       return 0;
     case TK_COLUMN:
+      assert( ExprUseYTab(p) );
       return ExprHasProperty(p, EP_CanBeNull) ||
              p->y.pTab==0 ||  /* Reference to column of index on expression */
              (p->iColumn>=0
@@ -102532,13 +104154,13 @@ SQLITE_PRIVATE int sqlite3IsRowid(const char *z){
 ** table, then return NULL.
 */
 #ifndef SQLITE_OMIT_SUBQUERY
-static Select *isCandidateForInOpt(Expr *pX){
+static Select *isCandidateForInOpt(const Expr *pX){
   Select *p;
   SrcList *pSrc;
   ExprList *pEList;
   Table *pTab;
   int i;
-  if( !ExprHasProperty(pX, EP_xIsSelect) ) return 0;  /* Not a subquery */
+  if( !ExprUseXSelect(pX) ) return 0;                 /* Not a subquery */
   if( ExprHasProperty(pX, EP_VarSelect)  ) return 0;  /* Correlated subq */
   p = pX->x.pSelect;
   if( p->pPrior ) return 0;              /* Not a compound SELECT */
@@ -102556,7 +104178,7 @@ static Select *isCandidateForInOpt(Expr *pX){
   if( pSrc->a[0].pSelect ) return 0;     /* FROM is not a subquery or view */
   pTab = pSrc->a[0].pTab;
   assert( pTab!=0 );
-  assert( pTab->pSelect==0 );            /* FROM clause is not a view */
+  assert( !IsView(pTab)  );              /* FROM clause is not a view */
   if( IsVirtual(pTab) ) return 0;        /* FROM clause not a virtual table */
   pEList = p->pEList;
   assert( pEList!=0 );
@@ -102709,7 +104331,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
   ** or not NULL is actually possible (it may not be, for example, due
   ** to NOT NULL constraints in the schema). If no NULL values are possible,
   ** set prRhsHasNull to 0 before continuing.  */
-  if( prRhsHasNull && (pX->flags & EP_xIsSelect) ){
+  if( prRhsHasNull && ExprUseXSelect(pX) ){
     int i;
     ExprList *pEList = pX->x.pSelect->pEList;
     for(i=0; i<pEList->nExpr; i++){
@@ -102737,7 +104359,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
 
     /* Code an OP_Transaction and OP_TableLock for <table>. */
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-    assert( iDb>=0 && iDb<SQLITE_MAX_ATTACHED );
+    assert( iDb>=0 && iDb<SQLITE_MAX_DB );
     sqlite3CodeVerifySchema(pParse, iDb);
     sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
 
@@ -102810,7 +104432,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
             CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
             int j;
 
-            assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr );
+            assert( pReq!=0 || pRhs->iColumn==XN_ROWID
+                   || pParse->nErr || db->mallocFailed );
             for(j=0; j<nExpr; j++){
               if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
               assert( pIdx->azColl[j] );
@@ -102865,7 +104488,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
   */
   if( eType==0
    && (inFlags & IN_INDEX_NOOP_OK)
-   && !ExprHasProperty(pX, EP_xIsSelect)
+   && ExprUseXList(pX)
    && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
   ){
     eType = IN_INDEX_NOOP;
@@ -102910,10 +104533,10 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
 ** It is the responsibility of the caller to ensure that the returned
 ** string is eventually freed using sqlite3DbFree().
 */
-static char *exprINAffinity(Parse *pParse, Expr *pExpr){
+static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
   Expr *pLeft = pExpr->pLeft;
   int nVal = sqlite3ExprVectorSize(pLeft);
-  Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
+  Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0;
   char *zRet;
 
   assert( pExpr->op==TK_IN );
@@ -102963,7 +104586,7 @@ SQLITE_PRIVATE void sqlite3SubselectError(Parse *pParse, int nActual, int nExpec
 */
 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
 #ifndef SQLITE_OMIT_SUBQUERY
-  if( pExpr->flags & EP_xIsSelect ){
+  if( ExprUseXSelect(pExpr) ){
     sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
   }else
 #endif
@@ -103027,10 +104650,11 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
     */
     if( ExprHasProperty(pExpr, EP_Subrtn) ){
       addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+      if( ExprUseXSelect(pExpr) ){
         ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d",
               pExpr->x.pSelect->selId));
       }
+      assert( ExprUseYSub(pExpr) );
       sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
                         pExpr->y.sub.iAddr);
       sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
@@ -103039,6 +104663,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
     }
 
     /* Begin coding the subroutine */
+    assert( !ExprUseYWin(pExpr) );
     ExprSetProperty(pExpr, EP_Subrtn);
     assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
     pExpr->y.sub.regReturn = ++pParse->nMem;
@@ -103059,7 +104684,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
   pExpr->iTable = iTab;
   addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
-  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+  if( ExprUseXSelect(pExpr) ){
     VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
   }else{
     VdbeComment((v, "RHS of IN operator"));
@@ -103067,7 +104692,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
 #endif
   pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
 
-  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+  if( ExprUseXSelect(pExpr) ){
     /* Case 1:     expr IN (SELECT ...)
     **
     ** Generate code to write the results of the select into the temporary
@@ -103082,19 +104707,23 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
     /* If the LHS and RHS of the IN operator do not match, that
     ** error will have been caught long before we reach this point. */
     if( ALWAYS(pEList->nExpr==nVal) ){
+      Select *pCopy;
       SelectDest dest;
       int i;
+      int rc;
       sqlite3SelectDestInit(&dest, SRT_Set, iTab);
       dest.zAffSdst = exprINAffinity(pParse, pExpr);
       pSelect->iLimit = 0;
       testcase( pSelect->selFlags & SF_Distinct );
       testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
-      if( sqlite3Select(pParse, pSelect, &dest) ){
-        sqlite3DbFree(pParse->db, dest.zAffSdst);
+      pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
+      rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
+      sqlite3SelectDelete(pParse->db, pCopy);
+      sqlite3DbFree(pParse->db, dest.zAffSdst);
+      if( rc ){
         sqlite3KeyInfoUnref(pKeyInfo);
         return;
       }
-      sqlite3DbFree(pParse->db, dest.zAffSdst);
       assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
       assert( pEList!=0 );
       assert( pEList->nExpr>0 );
@@ -103161,6 +104790,7 @@ SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
   if( addrOnce ){
     sqlite3VdbeJumpHere(v, addrOnce);
     /* Subroutine return */
+    assert( ExprUseYSub(pExpr) );
     sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
     sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
     sqlite3ClearTempRegCache(pParse);
@@ -103193,12 +104823,33 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
 
   Vdbe *v = pParse->pVdbe;
   assert( v!=0 );
+  if( pParse->nErr ) return 0;
   testcase( pExpr->op==TK_EXISTS );
   testcase( pExpr->op==TK_SELECT );
   assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
-  assert( ExprHasProperty(pExpr, EP_xIsSelect) );
+  assert( ExprUseXSelect(pExpr) );
   pSel = pExpr->x.pSelect;
 
+  /* If this routine has already been coded, then invoke it as a
+  ** subroutine. */
+  if( ExprHasProperty(pExpr, EP_Subrtn) ){
+    ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
+    assert( ExprUseYSub(pExpr) );
+    sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
+                      pExpr->y.sub.iAddr);
+    return pExpr->iTable;
+  }
+
+  /* Begin coding the subroutine */
+  assert( !ExprUseYWin(pExpr) );
+  assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) );
+  ExprSetProperty(pExpr, EP_Subrtn);
+  pExpr->y.sub.regReturn = ++pParse->nMem;
+  pExpr->y.sub.iAddr =
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
+  VdbeComment((v, "return address"));
+
+
   /* The evaluation of the EXISTS/SELECT must be repeated every time it
   ** is encountered if any of the following is true:
   **
@@ -103210,22 +104861,6 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   ** save the results, and reuse the same result on subsequent invocations.
   */
   if( !ExprHasProperty(pExpr, EP_VarSelect) ){
-    /* If this routine has already been coded, then invoke it as a
-    ** subroutine. */
-    if( ExprHasProperty(pExpr, EP_Subrtn) ){
-      ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
-      sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
-                        pExpr->y.sub.iAddr);
-      return pExpr->iTable;
-    }
-
-    /* Begin coding the subroutine */
-    ExprSetProperty(pExpr, EP_Subrtn);
-    pExpr->y.sub.regReturn = ++pParse->nMem;
-    pExpr->y.sub.iAddr =
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
-    VdbeComment((v, "return address"));
-
     addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
   }
 
@@ -103274,19 +104909,23 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   }
   pSel->iLimit = 0;
   if( sqlite3Select(pParse, pSel, &dest) ){
+    if( pParse->nErr ){
+      pExpr->op2 = pExpr->op;
+      pExpr->op = TK_ERROR;
+    }
     return 0;
   }
   pExpr->iTable = rReg = dest.iSDParm;
   ExprSetVVAProperty(pExpr, EP_NoReduce);
   if( addrOnce ){
     sqlite3VdbeJumpHere(v, addrOnce);
-
-    /* Subroutine return */
-    sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
-    sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
-    sqlite3ClearTempRegCache(pParse);
   }
 
+  /* Subroutine return */
+  assert( ExprUseYSub(pExpr) );
+  sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
+  sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
+  sqlite3ClearTempRegCache(pParse);
   return rReg;
 }
 #endif /* SQLITE_OMIT_SUBQUERY */
@@ -103300,7 +104939,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
 */
 SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){
   int nVector = sqlite3ExprVectorSize(pIn->pLeft);
-  if( (pIn->flags & EP_xIsSelect) ){
+  if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){
     if( nVector!=pIn->x.pSelect->pEList->nExpr ){
       sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector);
       return 1;
@@ -103434,13 +105073,15 @@ static void sqlite3ExprCodeIN(
   ** This is step (1) in the in-operator.md optimized algorithm.
   */
   if( eType==IN_INDEX_NOOP ){
-    ExprList *pList = pExpr->x.pList;
-    CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
+    ExprList *pList;
+    CollSeq *pColl;
     int labelOk = sqlite3VdbeMakeLabel(pParse);
     int r2, regToFree;
     int regCkNull = 0;
     int ii;
-    assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
+    assert( ExprUseXList(pExpr) );
+    pList = pExpr->x.pList;
+    pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
     if( destIfNull!=destIfFalse ){
       regCkNull = sqlite3GetTempReg(pParse);
       sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull);
@@ -103491,6 +105132,7 @@ static void sqlite3ExprCodeIN(
   if( pParse->nErr ) goto sqlite3ExprCodeIN_finished;
   for(i=0; i<nVector; i++){
     Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
+    if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
     if( sqlite3ExprCanBeNull(p) ){
       sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2);
       VdbeCoverage(v);
@@ -103676,9 +105318,10 @@ SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn(
 ** and store the result in register regOut
 */
 SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(
-  Parse *pParse,
-  Column *pCol,
-  int regOut
+  Parse *pParse,     /* Parsing context */
+  Table *pTab,       /* Table containing the generated column */
+  Column *pCol,      /* The generated column */
+  int regOut         /* Put the result in this register */
 ){
   int iAddr;
   Vdbe *v = pParse->pVdbe;
@@ -103689,7 +105332,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(
   }else{
     iAddr = 0;
   }
-  sqlite3ExprCodeCopy(pParse, pCol->pDflt, regOut);
+  sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut);
   if( pCol->affinity>=SQLITE_AFF_TEXT ){
     sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
   }
@@ -103725,12 +105368,13 @@ SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(
     }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
       Parse *pParse = sqlite3VdbeParser(v);
       if( pCol->colFlags & COLFLAG_BUSY ){
-        sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pCol->zName);
+        sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
+                        pCol->zCnName);
       }else{
         int savedSelfTab = pParse->iSelfTab;
         pCol->colFlags |= COLFLAG_BUSY;
         pParse->iSelfTab = iTabCur+1;
-        sqlite3ExprCodeGeneratedColumn(pParse, pCol, regOut);
+        sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut);
         pParse->iSelfTab = savedSelfTab;
         pCol->colFlags &= ~COLFLAG_BUSY;
       }
@@ -103823,6 +105467,7 @@ static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){
       int i;
       iResult = pParse->nMem+1;
       pParse->nMem += nResult;
+      assert( ExprUseXList(p) );
       for(i=0; i<nResult; i++){
         sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
       }
@@ -103897,6 +105542,7 @@ static int exprCodeInlineFunction(
   ** Test-only SQL functions that are only usable if enabled
   ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
   */
+#if !defined(SQLITE_UNTESTABLE)
     case INLINEFUNC_expr_compare: {
       /* Compare two expressions using sqlite3ExprCompare() */
       assert( nFarg==2 );
@@ -103930,7 +105576,6 @@ static int exprCodeInlineFunction(
       break;
     }
 
-#ifdef SQLITE_DEBUG
     case INLINEFUNC_affinity: {
       /* The AFFINITY() function evaluates to a string that describes
       ** the type affinity of the argument.  This is used for testing of
@@ -103944,7 +105589,7 @@ static int exprCodeInlineFunction(
               (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]);
       break;
     }
-#endif
+#endif /* !defined(SQLITE_UNTESTABLE) */
   }
   return target;
 }
@@ -103998,7 +105643,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         if( pCol->iColumn<0 ){
           VdbeComment((v,"%s.rowid",pTab->zName));
         }else{
-          VdbeComment((v,"%s.%s",pTab->zName,pTab->aCol[pCol->iColumn].zName));
+          VdbeComment((v,"%s.%s",
+              pTab->zName, pTab->aCol[pCol->iColumn].zCnName));
           if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){
             sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
           }
@@ -104020,6 +105666,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         */
         int aff;
         iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
+        assert( ExprUseYTab(pExpr) );
         if( pExpr->y.pTab ){
           aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
         }else{
@@ -104043,9 +105690,11 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
           ** immediately prior to the first column.
           */
           Column *pCol;
-          Table *pTab = pExpr->y.pTab;
+          Table *pTab;
           int iSrc;
           int iCol = pExpr->iColumn;
+          assert( ExprUseYTab(pExpr) );
+          pTab = pExpr->y.pTab;
           assert( pTab!=0 );
           assert( iCol>=XN_ROWID );
           assert( iCol<pTab->nCol );
@@ -104059,12 +105708,12 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
           if( pCol->colFlags & COLFLAG_GENERATED ){
             if( pCol->colFlags & COLFLAG_BUSY ){
               sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
-                              pCol->zName);
+                              pCol->zCnName);
               return 0;
             }
             pCol->colFlags |= COLFLAG_BUSY;
             if( pCol->colFlags & COLFLAG_NOTAVAIL ){
-              sqlite3ExprCodeGeneratedColumn(pParse, pCol, iSrc);
+              sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc);
             }
             pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL);
             return iSrc;
@@ -104083,6 +105732,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
           iTab = pParse->iSelfTab - 1;
         }
       }
+      assert( ExprUseYTab(pExpr) );
       iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
                                pExpr->iColumn, iTab, target,
                                pExpr->op2);
@@ -104116,7 +105766,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       ** Expr node to be passed into this function, it will be handled
       ** sanely and not crash.  But keep the assert() to bring the problem
       ** to the attention of the developers. */
-      assert( op==TK_NULL );
+      assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed );
       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
       return target;
     }
@@ -104160,6 +105810,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
         inReg = target;
       }
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3VdbeAddOp2(v, OP_Cast, target,
                         sqlite3AffinityType(pExpr->u.zToken, 0));
       return inReg;
@@ -104182,8 +105833,9 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pLeft, &regFree1);
         r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
-        codeCompare(pParse, pLeft, pExpr->pRight, op,
-            r1, r2, inReg, SQLITE_STOREP2 | p5,
+        sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg);
+        codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
+            sqlite3VdbeCurrentAddr(v)+2, p5,
             ExprHasProperty(pExpr,EP_Commuted));
         assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
         assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
@@ -104191,6 +105843,11 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
         assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
         assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
+        if( p5==SQLITE_NULLEQ ){
+          sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg);
+        }else{
+          sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2);
+        }
         testcase( regFree1==0 );
         testcase( regFree2==0 );
       }
@@ -104321,8 +105978,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         ** multiple times if we know they always give the same result */
         return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
       }
-      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
       assert( !ExprHasProperty(pExpr, EP_TokenOnly) );
+      assert( ExprUseXList(pExpr) );
       pFarg = pExpr->x.pList;
       nFarg = pFarg ? pFarg->nExpr : 0;
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
@@ -104411,7 +106068,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
         sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
       }
 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
-      if( pDef->funcFlags & SQLITE_FUNC_OFFSET ){
+      if( (pDef->funcFlags & SQLITE_FUNC_OFFSET)!=0 && ALWAYS(pFarg!=0) ){
         Expr *pArg = pFarg->a[0].pExpr;
         if( pArg->op==TK_COLUMN ){
           sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
@@ -104441,7 +106098,10 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       testcase( op==TK_SELECT );
       if( pParse->db->mallocFailed ){
         return 0;
-      }else if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){
+      }else if( op==TK_SELECT
+             && ALWAYS( ExprUseXSelect(pExpr) )
+             && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
+      ){
         sqlite3SubselectError(pParse, nCol, 1);
       }else{
         return sqlite3CodeSubselect(pParse, pExpr);
@@ -104453,10 +106113,9 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       if( pExpr->pLeft->iTable==0 ){
         pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
       }
-      assert( pExpr->iTable==0 || pExpr->pLeft->op==TK_SELECT );
-      if( pExpr->iTable!=0
-       && pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
-      ){
+      assert( pExpr->pLeft->op==TK_SELECT || pExpr->pLeft->op==TK_ERROR );
+      n = sqlite3ExprVectorSize(pExpr->pLeft);
+      if( pExpr->iTable!=n ){
         sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
                                 pExpr->iTable, n);
       }
@@ -104524,9 +106183,14 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       **   p1==1   ->    old.a         p1==4   ->    new.a
       **   p1==2   ->    old.b         p1==5   ->    new.b
       */
-      Table *pTab = pExpr->y.pTab;
-      int iCol = pExpr->iColumn;
-      int p1 = pExpr->iTable * (pTab->nCol+1) + 1
+      Table *pTab;
+      int iCol;
+      int p1;
+
+      assert( ExprUseYTab(pExpr) );
+      pTab = pExpr->y.pTab;
+      iCol = pExpr->iColumn;
+      p1 = pExpr->iTable * (pTab->nCol+1) + 1
                      + sqlite3TableColumnToStorage(pTab, iCol);
 
       assert( pExpr->iTable==0 || pExpr->iTable==1 );
@@ -104537,7 +106201,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       sqlite3VdbeAddOp2(v, OP_Param, p1, target);
       VdbeComment((v, "r[%d]=%s.%s", target,
         (pExpr->iTable ? "new" : "old"),
-        (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
+        (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
       ));
 
 #ifndef SQLITE_OMIT_FLOATING_POINT
@@ -104614,7 +106278,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       Expr *pDel = 0;
       sqlite3 *db = pParse->db;
 
-      assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
+      assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 );
       assert(pExpr->x.pList->nExpr > 0);
       pEList = pExpr->x.pList;
       aListelem = pEList->a;
@@ -104811,7 +106475,7 @@ SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
   inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
   if( inReg!=target ){
     u8 op;
-    if( ExprHasProperty(pExpr,EP_Subquery) ){
+    if( ALWAYS(pExpr) && ExprHasProperty(pExpr,EP_Subquery) ){
       op = OP_Copy;
     }else{
       op = OP_SCopy;
@@ -104959,7 +106623,7 @@ static void exprCodeBetween(
   memset(&compRight, 0, sizeof(Expr));
   memset(&exprAnd, 0, sizeof(Expr));
 
-  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
+  assert( ExprUseXList(pExpr) );
   pDel = sqlite3ExprDup(db, pExpr->pLeft, 0);
   if( db->mallocFailed==0 ){
     exprAnd.op = TK_AND;
@@ -105349,7 +107013,11 @@ SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,i
 ** Otherwise, if the values are not the same or if pExpr is not a simple
 ** SQL value, zero is returned.
 */
-static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){
+static int exprCompareVariable(
+  const Parse *pParse,
+  const Expr *pVar,
+  const Expr *pExpr
+){
   int res = 0;
   int iVar;
   sqlite3_value *pL, *pR = 0;
@@ -105401,7 +107069,12 @@ static int exprCompareVariable(Parse *pParse, Expr *pVar, Expr *pExpr){
 ** Argument pParse should normally be NULL. If it is not NULL and pA or
 ** pB causes a return value of 2.
 */
-SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTab){
+SQLITE_PRIVATE int sqlite3ExprCompare(
+  const Parse *pParse,
+  const Expr *pA,
+  const Expr *pB,
+  int iTab
+){
   u32 combinedFlags;
   if( pA==0 || pB==0 ){
     return pB==pA ? 0 : 2;
@@ -105425,7 +107098,9 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa
     }
     return 2;
   }
-  if( pA->op!=TK_COLUMN && pA->op!=TK_AGG_COLUMN && pA->u.zToken ){
+  assert( !ExprHasProperty(pA, EP_IntValue) );
+  assert( !ExprHasProperty(pB, EP_IntValue) );
+  if( pA->u.zToken ){
     if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){
       if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -105443,7 +107118,12 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa
       return 0;
     }else if( pA->op==TK_COLLATE ){
       if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
-    }else if( ALWAYS(pB->u.zToken!=0) && strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
+    }else
+    if( pB->u.zToken!=0
+     && pA->op!=TK_COLUMN
+     && pA->op!=TK_AGG_COLUMN
+     && strcmp(pA->u.zToken,pB->u.zToken)!=0
+    ){
       return 2;
     }
   }
@@ -105485,7 +107165,7 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Parse *pParse, Expr *pA, Expr *pB, int iTa
 ** Two NULL pointers are considered to be the same.  But a NULL pointer
 ** always differs from a non-NULL pointer.
 */
-SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
+SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList *pA, const ExprList *pB, int iTab){
   int i;
   if( pA==0 && pB==0 ) return 0;
   if( pA==0 || pB==0 ) return 1;
@@ -105504,7 +107184,7 @@ SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
 ** are ignored.
 */
-SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){
+SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA,Expr *pB, int iTab){
   return sqlite3ExprCompare(0,
              sqlite3ExprSkipCollateAndLikely(pA),
              sqlite3ExprSkipCollateAndLikely(pB),
@@ -105518,9 +107198,9 @@ SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){
 ** non-NULL if pNN is not NULL
 */
 static int exprImpliesNotNull(
-  Parse *pParse,      /* Parsing context */
-  Expr *p,            /* The expression to be checked */
-  Expr *pNN,          /* The expression that is NOT NULL */
+  const Parse *pParse,/* Parsing context */
+  const Expr *p,      /* The expression to be checked */
+  const Expr *pNN,    /* The expression that is NOT NULL */
   int iTab,           /* Table being evaluated */
   int seenNot         /* Return true only if p can be any non-NULL value */
 ){
@@ -105532,12 +107212,13 @@ static int exprImpliesNotNull(
   switch( p->op ){
     case TK_IN: {
       if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0;
-      assert( ExprHasProperty(p,EP_xIsSelect)
-           || (p->x.pList!=0 && p->x.pList->nExpr>0) );
+      assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) );
       return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
     }
     case TK_BETWEEN: {
-      ExprList *pList = p->x.pList;
+      ExprList *pList;
+      assert( ExprUseXList(p) );
+      pList = p->x.pList;
       assert( pList!=0 );
       assert( pList->nExpr==2 );
       if( seenNot ) return 0;
@@ -105613,7 +107294,12 @@ static int exprImpliesNotNull(
 ** improvement.  Returning false might cause a performance reduction, but
 ** it will always give the correct answer and is hence always safe.
 */
-SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse *pParse, Expr *pE1, Expr *pE2, int iTab){
+SQLITE_PRIVATE int sqlite3ExprImpliesExpr(
+  const Parse *pParse,
+  const Expr *pE1,
+  const Expr *pE2,
+  int iTab
+){
   if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){
     return 1;
   }
@@ -105709,10 +107395,14 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
       testcase( pExpr->op==TK_GE );
       /* The y.pTab=0 assignment in wherecode.c always happens after the
       ** impliesNotNullRow() test */
-      if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0)
-                               && IsVirtual(pLeft->y.pTab))
-       || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0)
-                               && IsVirtual(pRight->y.pTab))
+      assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) );
+      assert( pRight->op!=TK_COLUMN || ExprUseYTab(pRight) );
+      if( (pLeft->op==TK_COLUMN
+           && pLeft->y.pTab!=0
+           && IsVirtual(pLeft->y.pTab))
+       || (pRight->op==TK_COLUMN
+           && pRight->y.pTab!=0
+           && IsVirtual(pRight->y.pTab))
       ){
         return WRC_Prune;
       }
@@ -105821,88 +107511,125 @@ SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(
 }
 
 
-/*
-** An instance of the following structure is used by the tree walker
-** to count references to table columns in the arguments of an
-** aggregate function, in order to implement the
-** sqlite3FunctionThisSrc() routine.
-*/
-struct SrcCount {
-  SrcList *pSrc;   /* One particular FROM clause in a nested query */
-  int iSrcInner;   /* Smallest cursor number in this context */
-  int nThis;       /* Number of references to columns in pSrcList */
-  int nOther;      /* Number of references to columns in other FROM clauses */
+/* Structure used to pass information throught the Walker in order to
+** implement sqlite3ReferencesSrcList().
+*/
+struct RefSrcList {
+  sqlite3 *db;         /* Database connection used for sqlite3DbRealloc() */
+  SrcList *pRef;       /* Looking for references to these tables */
+  i64 nExclude;        /* Number of tables to exclude from the search */
+  int *aiExclude;      /* Cursor IDs for tables to exclude from the search */
 };
 
 /*
-** xSelect callback for sqlite3FunctionUsesThisSrc(). If this is the first
-** SELECT with a FROM clause encountered during this iteration, set
-** SrcCount.iSrcInner to the cursor number of the leftmost object in
-** the FROM cause.
+** Walker SELECT callbacks for sqlite3ReferencesSrcList().
+**
+** When entering a new subquery on the pExpr argument, add all FROM clause
+** entries for that subquery to the exclude list.
+**
+** When leaving the subquery, remove those entries from the exclude list.
 */
-static int selectSrcCount(Walker *pWalker, Select *pSel){
-  struct SrcCount *p = pWalker->u.pSrcCount;
-  if( p->iSrcInner==0x7FFFFFFF && ALWAYS(pSel->pSrc) && pSel->pSrc->nSrc ){
-    pWalker->u.pSrcCount->iSrcInner = pSel->pSrc->a[0].iCursor;
+static int selectRefEnter(Walker *pWalker, Select *pSelect){
+  struct RefSrcList *p = pWalker->u.pRefSrcList;
+  SrcList *pSrc = pSelect->pSrc;
+  i64 i, j;
+  int *piNew;
+  if( pSrc->nSrc==0 ) return WRC_Continue;
+  j = p->nExclude;
+  p->nExclude += pSrc->nSrc;
+  piNew = sqlite3DbRealloc(p->db, p->aiExclude, p->nExclude*sizeof(int));
+  if( piNew==0 ){
+    p->nExclude = 0;
+    return WRC_Abort;
+  }else{
+    p->aiExclude = piNew;
+  }
+  for(i=0; i<pSrc->nSrc; i++, j++){
+     p->aiExclude[j] = pSrc->a[i].iCursor;
   }
   return WRC_Continue;
 }
+static void selectRefLeave(Walker *pWalker, Select *pSelect){
+  struct RefSrcList *p = pWalker->u.pRefSrcList;
+  SrcList *pSrc = pSelect->pSrc;
+  if( p->nExclude ){
+    assert( p->nExclude>=pSrc->nSrc );
+    p->nExclude -= pSrc->nSrc;
+  }
+}
 
-/*
-** Count the number of references to columns.
+/* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
+**
+** Set the 0x01 bit of pWalker->eCode if there is a reference to any
+** of the tables shown in RefSrcList.pRef.
+**
+** Set the 0x02 bit of pWalker->eCode if there is a reference to a
+** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
 */
-static int exprSrcCount(Walker *pWalker, Expr *pExpr){
-  /* There was once a NEVER() on the second term on the grounds that
-  ** sqlite3FunctionUsesThisSrc() was always called before
-  ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet
-  ** been converted into TK_AGG_COLUMN. But this is no longer true due
-  ** to window functions - sqlite3WindowRewrite() may now indirectly call
-  ** FunctionUsesThisSrc() when creating a new sub-select. */
-  if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){
+static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){
+  if( pExpr->op==TK_COLUMN
+   || pExpr->op==TK_AGG_COLUMN
+  ){
     int i;
-    struct SrcCount *p = pWalker->u.pSrcCount;
-    SrcList *pSrc = p->pSrc;
+    struct RefSrcList *p = pWalker->u.pRefSrcList;
+    SrcList *pSrc = p->pRef;
     int nSrc = pSrc ? pSrc->nSrc : 0;
     for(i=0; i<nSrc; i++){
-      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
+      if( pExpr->iTable==pSrc->a[i].iCursor ){
+        pWalker->eCode |= 1;
+        return WRC_Continue;
+      }
     }
-    if( i<nSrc ){
-      p->nThis++;
-    }else if( pExpr->iTable<p->iSrcInner ){
-      /* In a well-formed parse tree (no name resolution errors),
-      ** TK_COLUMN nodes with smaller Expr.iTable values are in an
-      ** outer context.  Those are the only ones to count as "other" */
-      p->nOther++;
+    for(i=0; i<p->nExclude && p->aiExclude[i]!=pExpr->iTable; i++){}
+    if( i>=p->nExclude ){
+      pWalker->eCode |= 2;
     }
   }
   return WRC_Continue;
 }
 
 /*
-** Determine if any of the arguments to the pExpr Function reference
-** pSrcList.  Return true if they do.  Also return true if the function
-** has no arguments or has only constant arguments.  Return false if pExpr
-** references columns but not columns of tables found in pSrcList.
+** Check to see if pExpr references any tables in pSrcList.
+** Possible return values:
+**
+**    1         pExpr does references a table in pSrcList.
+**
+**    0         pExpr references some table that is not defined in either
+**              pSrcList or in subqueries of pExpr itself.
+**
+**   -1         pExpr only references no tables at all, or it only
+**              references tables defined in subqueries of pExpr itself.
+**
+** As currently used, pExpr is always an aggregate function call.  That
+** fact is exploited for efficiency.
 */
-SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){
+SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
   Walker w;
-  struct SrcCount cnt;
-  assert( pExpr->op==TK_AGG_FUNCTION );
+  struct RefSrcList x;
   memset(&w, 0, sizeof(w));
-  w.xExprCallback = exprSrcCount;
-  w.xSelectCallback = selectSrcCount;
-  w.u.pSrcCount = &cnt;
-  cnt.pSrc = pSrcList;
-  cnt.iSrcInner = (pSrcList&&pSrcList->nSrc)?pSrcList->a[0].iCursor:0x7FFFFFFF;
-  cnt.nThis = 0;
-  cnt.nOther = 0;
+  memset(&x, 0, sizeof(x));
+  w.xExprCallback = exprRefToSrcList;
+  w.xSelectCallback = selectRefEnter;
+  w.xSelectCallback2 = selectRefLeave;
+  w.u.pRefSrcList = &x;
+  x.db = pParse->db;
+  x.pRef = pSrcList;
+  assert( pExpr->op==TK_AGG_FUNCTION );
+  assert( ExprUseXList(pExpr) );
   sqlite3WalkExprList(&w, pExpr->x.pList);
 #ifndef SQLITE_OMIT_WINDOWFUNC
   if( ExprHasProperty(pExpr, EP_WinFunc) ){
     sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
   }
 #endif
-  return cnt.nThis>0 || cnt.nOther==0;
+  sqlite3DbFree(pParse->db, x.aiExclude);
+  if( w.eCode & 0x01 ){
+    return 1;
+  }else if( w.eCode ){
+    return 0;
+  }else{
+    return -1;
+  }
 }
 
 /*
@@ -105933,8 +107660,7 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
         pExpr = sqlite3ExprDup(db, pExpr, 0);
         if( pExpr ){
           pAggInfo->aCol[iAgg].pCExpr = pExpr;
-          pParse->pConstExpr =
-             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
+          sqlite3ExprDeferredDelete(pParse, pExpr);
         }
       }
     }else{
@@ -105943,8 +107669,7 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
         pExpr = sqlite3ExprDup(db, pExpr, 0);
         if( pExpr ){
           pAggInfo->aFunc[iAgg].pFExpr = pExpr;
-          pParse->pConstExpr =
-             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
+          sqlite3ExprDeferredDelete(pParse, pExpr);
         }
       }
     }
@@ -106016,7 +107741,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
       /* Check to see if the column is in one of the tables in the FROM
       ** clause of the aggregate query */
       if( ALWAYS(pSrcList!=0) ){
-        struct SrcList_item *pItem = pSrcList->a;
+        SrcItem *pItem = pSrcList->a;
         for(i=0; i<pSrcList->nSrc; i++, pItem++){
           struct AggInfo_col *pCol;
           assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
@@ -106039,6 +107764,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
              && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
             ){
               pCol = &pAggInfo->aCol[k];
+              assert( ExprUseYTab(pExpr) );
               pCol->pTab = pExpr->y.pTab;
               pCol->iTable = pExpr->iTable;
               pCol->iColumn = pExpr->iColumn;
@@ -106087,6 +107813,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
         */
         struct AggInfo_func *pItem = pAggInfo->aFunc;
         for(i=0; i<pAggInfo->nFunc; i++, pItem++){
+          if( pItem->pFExpr==pExpr ) break;
           if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
             break;
           }
@@ -106101,7 +107828,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
             pItem = &pAggInfo->aFunc[i];
             pItem->pFExpr = pExpr;
             pItem->iMem = ++pParse->nMem;
-            assert( !ExprHasProperty(pExpr, EP_IntValue) );
+            assert( ExprUseUToken(pExpr) );
             pItem->pFunc = sqlite3FindFunction(pParse->db,
                    pExpr->u.zToken,
                    pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
@@ -106287,6 +108014,7 @@ SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){
 static int isAlterableTable(Parse *pParse, Table *pTab){
   if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
 #ifndef SQLITE_OMIT_VIRTUALTABLE
+   || (pTab->tabFlags & TF_Eponymous)!=0
    || ( (pTab->tabFlags & TF_Shadow)!=0
         && sqlite3ReadOnlyShadowTables(pParse->db)
    )
@@ -106305,25 +108033,56 @@ static int isAlterableTable(Parse *pParse, Table *pTab){
 ** statement to ensure that the operation has not rendered any schema
 ** objects unusable.
 */
-static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
+static void renameTestSchema(
+  Parse *pParse,                  /* Parse context */
+  const char *zDb,                /* Name of db to verify schema of */
+  int bTemp,                      /* True if this is the temp db */
+  const char *zWhen,              /* "when" part of error message */
+  int bNoDQS                      /* Do not allow DQS in the schema */
+){
+  pParse->colNamesSet = 1;
   sqlite3NestedParse(pParse,
       "SELECT 1 "
-      "FROM \"%w\"." DFLT_SCHEMA_TABLE " "
+      "FROM \"%w\"." LEGACY_SCHEMA_TABLE " "
       "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
       " AND sql NOT LIKE 'create virtual%%'"
-      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
+      " AND sqlite_rename_test(%Q, sql, type, name, %d, %Q, %d)=NULL ",
       zDb,
-      zDb, bTemp
+      zDb, bTemp, zWhen, bNoDQS
   );
 
   if( bTemp==0 ){
     sqlite3NestedParse(pParse,
         "SELECT 1 "
-        "FROM temp." DFLT_SCHEMA_TABLE " "
+        "FROM temp." LEGACY_SCHEMA_TABLE " "
         "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
         " AND sql NOT LIKE 'create virtual%%'"
-        " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
-        zDb
+        " AND sqlite_rename_test(%Q, sql, type, name, 1, %Q, %d)=NULL ",
+        zDb, zWhen, bNoDQS
+    );
+  }
+}
+
+/*
+** Generate VM code to replace any double-quoted strings (but not double-quoted
+** identifiers) within the "sql" column of the sqlite_schema table in
+** database zDb with their single-quoted equivalents. If argument bTemp is
+** not true, similarly update all SQL statements in the sqlite_schema table
+** of the temp db.
+*/
+static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){
+  sqlite3NestedParse(pParse,
+      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE
+      " SET sql = sqlite_rename_quotefix(%Q, sql)"
+      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
+      " AND sql NOT LIKE 'create virtual%%'" , zDb, zDb
+  );
+  if( bTemp==0 ){
+    sqlite3NestedParse(pParse,
+      "UPDATE temp." LEGACY_SCHEMA_TABLE
+      " SET sql = sqlite_rename_quotefix('temp', sql)"
+      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
+      " AND sql NOT LIKE 'create virtual%%'"
     );
   }
 }
@@ -106332,12 +108091,12 @@ static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
 ** Generate code to reload the schema for database iDb. And, if iDb!=1, for
 ** the temp database as well.
 */
-static void renameReloadSchema(Parse *pParse, int iDb){
+static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
   Vdbe *v = pParse->pVdbe;
   if( v ){
     sqlite3ChangeCookie(pParse, iDb);
-    sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0);
-    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0);
+    sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
+    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
   }
 }
 
@@ -106359,9 +108118,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   const char *zTabName;     /* Original name of the table */
   Vdbe *v;
   VTable *pVTab = 0;        /* Non-zero if this is a v-tab with an xRename() */
-  u32 savedDbFlags;         /* Saved value of db->mDbFlags */
 
-  savedDbFlags = db->mDbFlags;
   if( NEVER(db->mallocFailed) ) goto exit_rename_table;
   assert( pSrc->nSrc==1 );
   assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
@@ -106370,7 +108127,6 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   if( !pTab ) goto exit_rename_table;
   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
   zDb = db->aDb[iDb].zDbSName;
-  db->mDbFlags |= DBFLAG_PreferBuiltin;
 
   /* Get a NULL terminated version of the new table name. */
   zName = sqlite3NameFromToken(db, pName);
@@ -106399,7 +108155,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   }
 
 #ifndef SQLITE_OMIT_VIEW
-  if( pTab->pSelect ){
+  if( IsView(pTab) ){
     sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
     goto exit_rename_table;
   }
@@ -106441,7 +108197,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
   ** the schema to use the new table name.  */
   sqlite3NestedParse(pParse,
-      "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
+      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
       "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) "
       "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)"
       "AND   name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
@@ -106451,7 +108207,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   /* Update the tbl_name and name columns of the sqlite_schema table
   ** as required.  */
   sqlite3NestedParse(pParse,
-      "UPDATE %Q." DFLT_SCHEMA_TABLE " SET "
+      "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET "
           "tbl_name = %Q, "
           "name = CASE "
             "WHEN type='table' THEN %Q "
@@ -106486,7 +108242,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
             "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "
             "tbl_name = "
               "CASE WHEN tbl_name=%Q COLLATE nocase AND "
-              "          sqlite_rename_test(%Q, sql, type, name, 1) "
+              "  sqlite_rename_test(%Q, sql, type, name, 1, 'after rename', 0) "
               "THEN %Q ELSE tbl_name END "
             "WHERE type IN ('view', 'trigger')"
         , zDb, zTabName, zName, zTabName, zDb, zName);
@@ -106505,13 +108261,12 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   }
 #endif
 
-  renameReloadSchema(pParse, iDb);
-  renameTestSchema(pParse, zDb, iDb==1);
+  renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
+  renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
 
 exit_rename_table:
   sqlite3SrcListDelete(db, pSrc);
   sqlite3DbFree(db, zName);
-  db->mDbFlags = savedDbFlags;
 }
 
 /*
@@ -106561,7 +108316,7 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
   zDb = db->aDb[iDb].zDbSName;
   zTab = &pNew->zName[16];  /* Skip the "sqlite_altertab_" prefix on the name */
   pCol = &pNew->aCol[pNew->nCol-1];
-  pDflt = pCol->pDflt;
+  pDflt = sqlite3ColumnExpr(pNew, pCol);
   pTab = sqlite3FindTable(db, zTab, zDb);
   assert( pTab );
 
@@ -106595,7 +108350,8 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
     if( pDflt && pDflt->pLeft->op==TK_NULL ){
       pDflt = 0;
     }
-    if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
+    assert( IsOrdinaryTable(pNew) );
+    if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){
       sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
           "Cannot add a REFERENCES column with non-NULL default value");
     }
@@ -106632,28 +108388,30 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
   zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
   if( zCol ){
     char *zEnd = &zCol[pColDef->n-1];
-    u32 savedDbFlags = db->mDbFlags;
     while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
       *zEnd-- = '\0';
     }
-    db->mDbFlags |= DBFLAG_PreferBuiltin;
+    /* substr() operations on characters, but addColOffset is in bytes. So we
+    ** have to use printf() to translate between these units: */
+    assert( IsOrdinaryTable(pTab) );
+    assert( IsOrdinaryTable(pNew) );
     sqlite3NestedParse(pParse,
-        "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
-          "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
+        "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
+          "sql = printf('%%.%ds, ',sql) || %Q"
+          " || substr(sql,1+length(printf('%%.%ds',sql))) "
         "WHERE type = 'table' AND name = %Q",
-      zDb, pNew->addColOffset, zCol, pNew->addColOffset+1,
+      zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset,
       zTab
     );
     sqlite3DbFree(db, zCol);
-    db->mDbFlags = savedDbFlags;
   }
 
-  /* Make sure the schema version is at least 3.  But do not upgrade
-  ** from less than 3 to 4, as that will corrupt any preexisting DESC
-  ** index.
-  */
   v = sqlite3GetVdbe(pParse);
   if( v ){
+    /* Make sure the schema version is at least 3.  But do not upgrade
+    ** from less than 3 to 4, as that will corrupt any preexisting DESC
+    ** index.
+    */
     r1 = sqlite3GetTempReg(pParse);
     sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
     sqlite3VdbeUsesBtree(v, iDb);
@@ -106662,10 +108420,25 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
     VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
     sqlite3ReleaseTempReg(pParse, r1);
-  }
 
-  /* Reload the table definition */
-  renameReloadSchema(pParse, iDb);
+    /* Reload the table definition */
+    renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
+
+    /* Verify that constraints are still satisfied */
+    if( pNew->pCheck!=0
+     || (pCol->notNull && (pCol->colFlags & COLFLAG_GENERATED)!=0)
+    ){
+      sqlite3NestedParse(pParse,
+        "SELECT CASE WHEN quick_check GLOB 'CHECK*'"
+        " THEN raise(ABORT,'CHECK constraint failed')"
+        " ELSE raise(ABORT,'NOT NULL constraint failed')"
+        " END"
+        "  FROM pragma_quick_check(\"%w\",\"%w\")"
+        " WHERE quick_check GLOB 'CHECK*' OR quick_check GLOB 'NULL*'",
+        zTab, zDb
+      );
+    }
+  }
 }
 
 /*
@@ -106706,7 +108479,7 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
 #endif
 
   /* Make sure this is not an attempt to ALTER a view. */
-  if( pTab->pSelect ){
+  if( IsView(pTab) ){
     sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
     goto exit_begin_add_column;
   }
@@ -106715,7 +108488,8 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
   }
 
   sqlite3MayAbort(pParse);
-  assert( pTab->addColOffset>0 );
+  assert( IsOrdinaryTable(pTab) );
+  assert( pTab->u.tab.addColOffset>0 );
   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 
   /* Put a copy of the Table struct in Parse.pNewTable for the
@@ -106742,13 +108516,13 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
   memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
   for(i=0; i<pNew->nCol; i++){
     Column *pCol = &pNew->aCol[i];
-    pCol->zName = sqlite3DbStrDup(db, pCol->zName);
-    pCol->hName = sqlite3StrIHash(pCol->zName);
-    pCol->zColl = 0;
-    pCol->pDflt = 0;
+    pCol->zCnName = sqlite3DbStrDup(db, pCol->zCnName);
+    pCol->hName = sqlite3StrIHash(pCol->zCnName);
   }
+  assert( IsOrdinaryTable(pNew) );
+  pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0);
   pNew->pSchema = db->aDb[iDb].pSchema;
-  pNew->addColOffset = pTab->addColOffset;
+  pNew->u.tab.addColOffset = pTab->u.tab.addColOffset;
   pNew->nTabRef = 1;
 
 exit_begin_add_column:
@@ -106765,10 +108539,10 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
 ** Or, if pTab is not a view or virtual table, zero is returned.
 */
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
-static int isRealTable(Parse *pParse, Table *pTab){
+static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
   const char *zType = 0;
 #ifndef SQLITE_OMIT_VIEW
-  if( pTab->pSelect ){
+  if( IsView(pTab) ){
     zType = "view";
   }
 #endif
@@ -106778,15 +108552,16 @@ static int isRealTable(Parse *pParse, Table *pTab){
   }
 #endif
   if( zType ){
-    sqlite3ErrorMsg(
-        pParse, "cannot rename columns of %s \"%s\"", zType, pTab->zName
+    sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",
+        (bDrop ? "drop column from" : "rename columns of"),
+        zType, pTab->zName
     );
     return 1;
   }
   return 0;
 }
 #else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
-# define isRealTable(x,y) (0)
+# define isRealTable(x,y,z) (0)
 #endif
 
 /*
@@ -106815,7 +108590,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn(
 
   /* Cannot alter a system table */
   if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
-  if( SQLITE_OK!=isRealTable(pParse, pTab) ) goto exit_rename_column;
+  if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
 
   /* Which schema holds the table to be altered */
   iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
@@ -106834,13 +108609,17 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn(
   zOld = sqlite3NameFromToken(db, pOld);
   if( !zOld ) goto exit_rename_column;
   for(iCol=0; iCol<pTab->nCol; iCol++){
-    if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break;
+    if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
   }
   if( iCol==pTab->nCol ){
     sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);
     goto exit_rename_column;
   }
 
+  /* Ensure the schema contains no double-quoted strings */
+  renameTestSchema(pParse, zDb, iSchema==1, "", 0);
+  renameFixQuotes(pParse, zDb, iSchema==1);
+
   /* Do the rename operation using a recursive UPDATE statement that
   ** uses the sqlite_rename_column() SQL function to compute the new
   ** CREATE statement text for the sqlite_schema table.
@@ -106851,26 +108630,25 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn(
   assert( pNew->n>0 );
   bQuote = sqlite3Isquote(pNew->z[0]);
   sqlite3NestedParse(pParse,
-      "UPDATE \"%w\"." DFLT_SCHEMA_TABLE " SET "
+      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
       "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) "
       "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' "
-      " AND (type != 'index' OR tbl_name = %Q)"
-      " AND sql NOT LIKE 'create virtual%%'",
+      " AND (type != 'index' OR tbl_name = %Q)",
       zDb,
       zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
       pTab->zName
   );
 
   sqlite3NestedParse(pParse,
-      "UPDATE temp." DFLT_SCHEMA_TABLE " SET "
+      "UPDATE temp." LEGACY_SCHEMA_TABLE " SET "
       "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "
       "WHERE type IN ('trigger', 'view')",
       zDb, pTab->zName, iCol, zNew, bQuote
   );
 
   /* Drop and reload the database schema. */
-  renameReloadSchema(pParse, iSchema);
-  renameTestSchema(pParse, zDb, iSchema==1);
+  renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename);
+  renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1);
 
  exit_rename_column:
   sqlite3SrcListDelete(db, pSrc);
@@ -106897,7 +108675,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameColumn(
 ** the parse tree.
 */
 struct RenameToken {
-  void *p;               /* Parse tree element created by token t */
+  const void *p;         /* Parse tree element created by token t */
   Token t;               /* The token that created parse tree element p */
   RenameToken *pNext;    /* Next is a list of all RenameToken objects */
 };
@@ -106939,9 +108717,9 @@ struct RenameCtx {
 ** Technically, as x no longer points into a valid object or to the byte
 ** following a valid object, it may not be used in comparison operations.
 */
-static void renameTokenCheckAll(Parse *pParse, void *pPtr){
+static void renameTokenCheckAll(Parse *pParse, const void *pPtr){
   if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){
-    RenameToken *p;
+    const RenameToken *p;
     u8 i = 0;
     for(p=pParse->pRename; p; p=p->pNext){
       if( p->p ){
@@ -106967,7 +108745,11 @@ static void renameTokenCheckAll(Parse *pParse, void *pPtr){
 ** with tail recursion in tokenExpr() routine, for a small performance
 ** improvement.
 */
-SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){
+SQLITE_PRIVATE const void *sqlite3RenameTokenMap(
+  Parse *pParse,
+  const void *pPtr,
+  const Token *pToken
+){
   RenameToken *pNew;
   assert( pPtr || pParse->db->mallocFailed );
   renameTokenCheckAll(pParse, pPtr);
@@ -106989,7 +108771,7 @@ SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pTo
 ** with parse tree element pFrom. This function remaps the associated token
 ** to parse tree element pTo.
 */
-SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFrom){
+SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){
   RenameToken *p;
   renameTokenCheckAll(pParse, pTo);
   for(p=pParse->pRename; p; p=p->pNext){
@@ -107005,7 +108787,10 @@ SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFro
 */
 static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
   Parse *pParse = pWalker->pParse;
-  sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
+  sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
+  if( ExprUseYTab(pExpr) ){
+    sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
+  }
   return WRC_Continue;
 }
 
@@ -107016,15 +108801,31 @@ static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
 static void renameWalkWith(Walker *pWalker, Select *pSelect){
   With *pWith = pSelect->pWith;
   if( pWith ){
+    Parse *pParse = pWalker->pParse;
     int i;
+    With *pCopy = 0;
+    assert( pWith->nCte>0 );
+    if( (pWith->a[0].pSelect->selFlags & SF_Expanded)==0 ){
+      /* Push a copy of the With object onto the with-stack. We use a copy
+      ** here as the original will be expanded and resolved (flags SF_Expanded
+      ** and SF_Resolved) below. And the parser code that uses the with-stack
+      ** fails if the Select objects on it have already been expanded and
+      ** resolved.  */
+      pCopy = sqlite3WithDup(pParse->db, pWith);
+      pCopy = sqlite3WithPush(pParse, pCopy, 1);
+    }
     for(i=0; i<pWith->nCte; i++){
       Select *p = pWith->a[i].pSelect;
       NameContext sNC;
       memset(&sNC, 0, sizeof(sNC));
-      sNC.pParse = pWalker->pParse;
-      sqlite3SelectPrep(sNC.pParse, p, &sNC);
+      sNC.pParse = pParse;
+      if( pCopy ) sqlite3SelectPrep(sNC.pParse, p, &sNC);
+      if( sNC.pParse->db->mallocFailed ) return;
       sqlite3WalkSelect(pWalker, p);
-      sqlite3RenameExprlistUnmap(pWalker->pParse, pWith->a[i].pCols);
+      sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols);
+    }
+    if( pCopy && pParse->pWith==pCopy ){
+      pParse->pWith = pCopy->pOuter;
     }
   }
 }
@@ -107034,12 +108835,12 @@ static void renameWalkWith(Walker *pWalker, Select *pSelect){
 */
 static void unmapColumnIdlistNames(
   Parse *pParse,
-  IdList *pIdList
+  const IdList *pIdList
 ){
   if( pIdList ){
     int ii;
     for(ii=0; ii<pIdList->nId; ii++){
-      sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName);
+      sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
     }
   }
 }
@@ -107051,7 +108852,11 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){
   Parse *pParse = pWalker->pParse;
   int i;
   if( pParse->nErr ) return WRC_Abort;
-  if( NEVER(p->selFlags & SF_View) ) return WRC_Prune;
+  testcase( p->selFlags & SF_View );
+  testcase( p->selFlags & SF_CopyCte );
+  if( p->selFlags & (SF_View|SF_CopyCte) ){
+    return WRC_Prune;
+  }
   if( ALWAYS(p->pEList) ){
     ExprList *pList = p->pEList;
     for(i=0; i<pList->nExpr; i++){
@@ -107064,7 +108869,7 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){
     SrcList *pSrc = p->pSrc;
     for(i=0; i<pSrc->nSrc; i++){
       sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
-      if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
+      sqlite3WalkExpr(pWalker, pSrc->a[i].pOn);
       unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
     }
   }
@@ -107122,23 +108927,35 @@ static void renameTokenFree(sqlite3 *db, RenameToken *pToken){
 
 /*
 ** Search the Parse object passed as the first argument for a RenameToken
-** object associated with parse tree element pPtr. If found, remove it
-** from the Parse object and add it to the list maintained by the
-** RenameCtx object passed as the second argument.
+** object associated with parse tree element pPtr. If found, return a pointer
+** to it. Otherwise, return NULL.
+**
+** If the second argument passed to this function is not NULL and a matching
+** RenameToken object is found, remove it from the Parse object and add it to
+** the list maintained by the RenameCtx object.
 */
-static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){
+static RenameToken *renameTokenFind(
+  Parse *pParse,
+  struct RenameCtx *pCtx,
+  const void *pPtr
+){
   RenameToken **pp;
-  assert( pPtr!=0 );
+  if( NEVER(pPtr==0) ){
+    return 0;
+  }
   for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
     if( (*pp)->p==pPtr ){
       RenameToken *pToken = *pp;
-      *pp = pToken->pNext;
-      pToken->pNext = pCtx->pList;
-      pCtx->pList = pToken;
-      pCtx->nList++;
-      break;
+      if( pCtx ){
+        *pp = pToken->pNext;
+        pToken->pNext = pCtx->pList;
+        pCtx->pList = pToken;
+        pCtx->nList++;
+      }
+      return pToken;
     }
   }
+  return 0;
 }
 
 /*
@@ -107147,7 +108964,11 @@ static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){
 ** descend into sub-select statements.
 */
 static int renameColumnSelectCb(Walker *pWalker, Select *p){
-  if( p->selFlags & SF_View ) return WRC_Prune;
+  if( p->selFlags & (SF_View|SF_CopyCte) ){
+    testcase( p->selFlags & SF_View );
+    testcase( p->selFlags & SF_CopyCte );
+    return WRC_Prune;
+  }
   renameWalkWith(pWalker, p);
   return WRC_Continue;
 }
@@ -107170,6 +108991,7 @@ static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
     renameTokenFind(pWalker->pParse, p, (void*)pExpr);
   }else if( pExpr->op==TK_COLUMN
    && pExpr->iColumn==p->iCol
+   && ALWAYS(ExprUseYTab(pExpr))
    && p->pTab==pExpr->y.pTab
   ){
     renameTokenFind(pWalker->pParse, p, (void*)pExpr);
@@ -107209,7 +109031,7 @@ static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){
 */
 static void renameColumnParseError(
   sqlite3_context *pCtx,
-  int bPost,
+  const char *zWhen,
   sqlite3_value *pType,
   sqlite3_value *pObject,
   Parse *pParse
@@ -107218,8 +109040,8 @@ static void renameColumnParseError(
   const char *zN = (const char*)sqlite3_value_text(pObject);
   char *zErr;
 
-  zErr = sqlite3_mprintf("error in %s %s%s: %s",
-      zT, zN, (bPost ? " after rename" : ""),
+  zErr = sqlite3_mprintf("error in %s %s%s%s: %s",
+      zT, zN, (zWhen[0] ? " " : ""), zWhen,
       pParse->zErrMsg
   );
   sqlite3_result_error(pCtx, zErr, -1);
@@ -107235,18 +109057,18 @@ static void renameColumnParseError(
 static void renameColumnElistNames(
   Parse *pParse,
   RenameCtx *pCtx,
-  ExprList *pEList,
+  const ExprList *pEList,
   const char *zOld
 ){
   if( pEList ){
     int i;
     for(i=0; i<pEList->nExpr; i++){
-      char *zName = pEList->a[i].zEName;
+      const char *zName = pEList->a[i].zEName;
       if( ALWAYS(pEList->a[i].eEName==ENAME_NAME)
        && ALWAYS(zName!=0)
        && 0==sqlite3_stricmp(zName, zOld)
       ){
-        renameTokenFind(pParse, pCtx, (void*)zName);
+        renameTokenFind(pParse, pCtx, (const void*)zName);
       }
     }
   }
@@ -107260,15 +109082,15 @@ static void renameColumnElistNames(
 static void renameColumnIdlistNames(
   Parse *pParse,
   RenameCtx *pCtx,
-  IdList *pIdList,
+  const IdList *pIdList,
   const char *zOld
 ){
   if( pIdList ){
     int i;
     for(i=0; i<pIdList->nId; i++){
-      char *zName = pIdList->a[i].zName;
+      const char *zName = pIdList->a[i].zName;
       if( 0==sqlite3_stricmp(zName, zOld) ){
-        renameTokenFind(pParse, pCtx, (void*)zName);
+        renameTokenFind(pParse, pCtx, (const void*)zName);
       }
     }
   }
@@ -107298,7 +109120,7 @@ static int renameParseSql(
   p->eParseMode = PARSE_MODE_RENAME;
   p->db = db;
   p->nQueryLoop = 1;
-  rc = sqlite3RunParser(p, zSql, &zErr);
+  rc = zSql ? sqlite3RunParser(p, zSql, &zErr) : SQLITE_NOMEM;
   assert( p->zErrMsg==0 );
   assert( rc!=SQLITE_OK || zErr==0 );
   p->zErrMsg = zErr;
@@ -107341,51 +109163,76 @@ static int renameEditSql(
   const char *zNew,               /* New token text */
   int bQuote                      /* True to always quote token */
 ){
-  int nNew = sqlite3Strlen30(zNew);
-  int nSql = sqlite3Strlen30(zSql);
+  i64 nNew = sqlite3Strlen30(zNew);
+  i64 nSql = sqlite3Strlen30(zSql);
   sqlite3 *db = sqlite3_context_db_handle(pCtx);
   int rc = SQLITE_OK;
-  char *zQuot;
+  char *zQuot = 0;
   char *zOut;
-  int nQuot;
-
-  /* Set zQuot to point to a buffer containing a quoted copy of the
-  ** identifier zNew. If the corresponding identifier in the original
-  ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to
-  ** point to zQuot so that all substitutions are made using the
-  ** quoted version of the new column name.  */
-  zQuot = sqlite3MPrintf(db, "\"%w\"", zNew);
-  if( zQuot==0 ){
-    return SQLITE_NOMEM;
+  i64 nQuot = 0;
+  char *zBuf1 = 0;
+  char *zBuf2 = 0;
+
+  if( zNew ){
+    /* Set zQuot to point to a buffer containing a quoted copy of the
+    ** identifier zNew. If the corresponding identifier in the original
+    ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to
+    ** point to zQuot so that all substitutions are made using the
+    ** quoted version of the new column name.  */
+    zQuot = sqlite3MPrintf(db, "\"%w\" ", zNew);
+    if( zQuot==0 ){
+      return SQLITE_NOMEM;
+    }else{
+      nQuot = sqlite3Strlen30(zQuot)-1;
+    }
+
+    assert( nQuot>=nNew );
+    zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
   }else{
-    nQuot = sqlite3Strlen30(zQuot);
-  }
-  if( bQuote ){
-    zNew = zQuot;
-    nNew = nQuot;
+    zOut = (char*)sqlite3DbMallocZero(db, (nSql*2+1) * 3);
+    if( zOut ){
+      zBuf1 = &zOut[nSql*2+1];
+      zBuf2 = &zOut[nSql*4+2];
+    }
   }
 
   /* At this point pRename->pList contains a list of RenameToken objects
   ** corresponding to all tokens in the input SQL that must be replaced
-  ** with the new column name. All that remains is to construct and
-  ** return the edited SQL string. */
-  assert( nQuot>=nNew );
-  zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
+  ** with the new column name, or with single-quoted versions of themselves.
+  ** All that remains is to construct and return the edited SQL string. */
   if( zOut ){
     int nOut = nSql;
     memcpy(zOut, zSql, nSql);
     while( pRename->pList ){
       int iOff;                   /* Offset of token to replace in zOut */
-      RenameToken *pBest = renameColumnTokenNext(pRename);
-
       u32 nReplace;
       const char *zReplace;
-      if( sqlite3IsIdChar(*pBest->t.z) ){
-        nReplace = nNew;
-        zReplace = zNew;
+      RenameToken *pBest = renameColumnTokenNext(pRename);
+
+      if( zNew ){
+        if( bQuote==0 && sqlite3IsIdChar(*pBest->t.z) ){
+          nReplace = nNew;
+          zReplace = zNew;
+        }else{
+          nReplace = nQuot;
+          zReplace = zQuot;
+          if( pBest->t.z[pBest->t.n]=='"' ) nReplace++;
+        }
       }else{
-        nReplace = nQuot;
-        zReplace = zQuot;
+        /* Dequote the double-quoted token. Then requote it again, this time
+        ** using single quotes. If the character immediately following the
+        ** original token within the input SQL was a single quote ('), then
+        ** add another space after the new, single-quoted version of the
+        ** token. This is so that (SELECT "string"'alias') maps to
+        ** (SELECT 'string' 'alias'), and not (SELECT 'string''alias').  */
+        memcpy(zBuf1, pBest->t.z, pBest->t.n);
+        zBuf1[pBest->t.n] = 0;
+        sqlite3Dequote(zBuf1);
+        sqlite3_snprintf(nSql*2, zBuf2, "%Q%s", zBuf1,
+            pBest->t.z[pBest->t.n]=='\'' ? " " : ""
+        );
+        zReplace = zBuf2;
+        nReplace = sqlite3Strlen30(zReplace);
       }
 
       iOff = pBest->t.z - zSql;
@@ -107451,7 +109298,7 @@ static int renameResolveTrigger(Parse *pParse){
       if( pSrc ){
         int i;
         for(i=0; i<pSrc->nSrc && rc==SQLITE_OK; i++){
-          struct SrcList_item *p = &pSrc->a[i];
+          SrcItem *p = &pSrc->a[i];
           p->iCursor = pParse->nTab++;
           if( p->pSelect ){
             sqlite3SelectPrep(pParse, p->pSelect, 0);
@@ -107469,6 +109316,9 @@ static int renameResolveTrigger(Parse *pParse){
             }
           }
         }
+        if( rc==SQLITE_OK && db->mallocFailed ){
+          rc = SQLITE_NOMEM;
+        }
         sNC.pSrcList = pSrc;
         if( rc==SQLITE_OK && pStep->pWhere ){
           rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere);
@@ -107477,9 +109327,8 @@ static int renameResolveTrigger(Parse *pParse){
           rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList);
         }
         assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) );
-        if( pStep->pUpsert ){
+        if( pStep->pUpsert && rc==SQLITE_OK ){
           Upsert *pUpsert = pStep->pUpsert;
-          assert( rc==SQLITE_OK );
           pUpsert->pUpsertSrc = pSrc;
           sNC.uNC.pUpsert = pUpsert;
           sNC.ncFlags = NC_UUpsert;
@@ -107617,7 +109466,7 @@ static void renameColumnFunc(
     sqlite3BtreeLeaveAll(db);
     return;
   }
-  zOld = pTab->aCol[iCol].zName;
+  zOld = pTab->aCol[iCol].zCnName;
   memset(&sCtx, 0, sizeof(sCtx));
   sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
 
@@ -107636,8 +109485,8 @@ static void renameColumnFunc(
   sCtx.pTab = pTab;
   if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
   if( sParse.pNewTable ){
-    Select *pSelect = sParse.pNewTable->pSelect;
-    if( pSelect ){
+    if( IsView(sParse.pNewTable) ){
+      Select *pSelect = sParse.pNewTable->u.view.pSelect;
       pSelect->selFlags &= ~SF_View;
       sParse.rc = SQLITE_OK;
       sqlite3SelectPrep(&sParse, pSelect, 0);
@@ -107646,16 +109495,17 @@ static void renameColumnFunc(
         sqlite3WalkSelect(&sWalker, pSelect);
       }
       if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
-    }else{
+    }else if( IsOrdinaryTable(sParse.pNewTable) ){
       /* A regular table */
       int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
       FKey *pFKey;
-      assert( sParse.pNewTable->pSelect==0 );
       sCtx.pTab = sParse.pNewTable;
       if( bFKOnly==0 ){
-        renameTokenFind(
-            &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName
-        );
+        if( iCol<sParse.pNewTable->nCol ){
+          renameTokenFind(
+              &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
+          );
+        }
         if( sCtx.iCol<0 ){
           renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey);
         }
@@ -107666,14 +109516,17 @@ static void renameColumnFunc(
         for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
           sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
         }
-      }
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
-      for(i=0; i<sParse.pNewTable->nCol; i++){
-        sqlite3WalkExpr(&sWalker, sParse.pNewTable->aCol[i].pDflt);
-      }
+        for(i=0; i<sParse.pNewTable->nCol; i++){
+          Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
+                                                  &sParse.pNewTable->aCol[i]);
+          sqlite3WalkExpr(&sWalker, pExpr);
+        }
 #endif
+      }
 
-      for(pFKey=sParse.pNewTable->pFKey; pFKey; pFKey=pFKey->pNextFrom){
+      assert( IsOrdinaryTable(sParse.pNewTable) );
+      for(pFKey=sParse.pNewTable->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
         for(i=0; i<pFKey->nCol; i++){
           if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
             renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]);
@@ -107725,7 +109578,7 @@ static void renameColumnFunc(
 renameColumnFunc_done:
   if( rc!=SQLITE_OK ){
     if( sParse.zErrMsg ){
-      renameColumnParseError(context, 0, argv[1], argv[2], &sParse);
+      renameColumnParseError(context, "", argv[1], argv[2], &sParse);
     }else{
       sqlite3_result_error_code(context, rc);
     }
@@ -107744,7 +109597,10 @@ static void renameColumnFunc(
 */
 static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
   RenameCtx *p = pWalker->u.pRename;
-  if( pExpr->op==TK_COLUMN && p->pTab==pExpr->y.pTab ){
+  if( pExpr->op==TK_COLUMN
+   && ALWAYS(ExprUseYTab(pExpr))
+   && p->pTab==pExpr->y.pTab
+  ){
     renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
   }
   return WRC_Continue;
@@ -107757,13 +109613,17 @@ static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
   int i;
   RenameCtx *p = pWalker->u.pRename;
   SrcList *pSrc = pSelect->pSrc;
-  if( pSelect->selFlags & SF_View ) return WRC_Prune;
-  if( pSrc==0 ){
+  if( pSelect->selFlags & (SF_View|SF_CopyCte) ){
+    testcase( pSelect->selFlags & SF_View );
+    testcase( pSelect->selFlags & SF_CopyCte );
+    return WRC_Prune;
+  }
+  if( NEVER(pSrc==0) ){
     assert( pWalker->pParse->db->mallocFailed );
     return WRC_Abort;
   }
   for(i=0; i<pSrc->nSrc; i++){
-    struct SrcList_item *pItem = &pSrc->a[i];
+    SrcItem *pItem = &pSrc->a[i];
     if( pItem->pTab==p->pTab ){
       renameTokenFind(pWalker->pParse, p, pItem->zName);
     }
@@ -107835,28 +109695,31 @@ static void renameTableFunc(
       if( sParse.pNewTable ){
         Table *pTab = sParse.pNewTable;
 
-        if( pTab->pSelect ){
+        if( IsView(pTab) ){
           if( isLegacy==0 ){
-            Select *pSelect = pTab->pSelect;
+            Select *pSelect = pTab->u.view.pSelect;
             NameContext sNC;
             memset(&sNC, 0, sizeof(sNC));
             sNC.pParse = &sParse;
 
             assert( pSelect->selFlags & SF_View );
             pSelect->selFlags &= ~SF_View;
-            sqlite3SelectPrep(&sParse, pTab->pSelect, &sNC);
+            sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC);
             if( sParse.nErr ){
               rc = sParse.rc;
             }else{
-              sqlite3WalkSelect(&sWalker, pTab->pSelect);
+              sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect);
             }
           }
         }else{
           /* Modify any FK definitions to point to the new table. */
 #ifndef SQLITE_OMIT_FOREIGN_KEY
-          if( isLegacy==0 || (db->flags & SQLITE_ForeignKeys) ){
+          if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys))
+           && !IsVirtual(pTab)
+          ){
             FKey *pFKey;
-            for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
+            assert( IsOrdinaryTable(pTab) );
+            for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
               if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){
                 renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo);
               }
@@ -107914,7 +109777,7 @@ static void renameTableFunc(
     }
     if( rc!=SQLITE_OK ){
       if( sParse.zErrMsg ){
-        renameColumnParseError(context, 0, argv[1], argv[2], &sParse);
+        renameColumnParseError(context, "", argv[1], argv[2], &sParse);
       }else{
         sqlite3_result_error_code(context, rc);
       }
@@ -107931,6 +109794,121 @@ static void renameTableFunc(
   return;
 }
 
+static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
+  if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
+    renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
+  }
+  return WRC_Continue;
+}
+
+/*
+** The implementation of an SQL scalar function that rewrites DDL statements
+** so that any string literals that use double-quotes are modified so that
+** they use single quotes.
+**
+** Two arguments must be passed:
+**
+**   0: Database name ("main", "temp" etc.).
+**   1: SQL statement to edit.
+**
+** The returned value is the modified SQL statement. For example, given
+** the database schema:
+**
+**   CREATE TABLE t1(a, b, c);
+**
+**   SELECT sqlite_rename_quotefix('main',
+**       'CREATE VIEW v1 AS SELECT "a", "string" FROM t1'
+**   );
+**
+** returns the string:
+**
+**   CREATE VIEW v1 AS SELECT "a", 'string' FROM t1
+*/
+static void renameQuotefixFunc(
+  sqlite3_context *context,
+  int NotUsed,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  char const *zDb = (const char*)sqlite3_value_text(argv[0]);
+  char const *zInput = (const char*)sqlite3_value_text(argv[1]);
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  sqlite3_xauth xAuth = db->xAuth;
+  db->xAuth = 0;
+#endif
+
+  sqlite3BtreeEnterAll(db);
+
+  UNUSED_PARAMETER(NotUsed);
+  if( zDb && zInput ){
+    int rc;
+    Parse sParse;
+    rc = renameParseSql(&sParse, zDb, db, zInput, 0);
+
+    if( rc==SQLITE_OK ){
+      RenameCtx sCtx;
+      Walker sWalker;
+
+      /* Walker to find tokens that need to be replaced. */
+      memset(&sCtx, 0, sizeof(RenameCtx));
+      memset(&sWalker, 0, sizeof(Walker));
+      sWalker.pParse = &sParse;
+      sWalker.xExprCallback = renameQuotefixExprCb;
+      sWalker.xSelectCallback = renameColumnSelectCb;
+      sWalker.u.pRename = &sCtx;
+
+      if( sParse.pNewTable ){
+        if( IsView(sParse.pNewTable) ){
+          Select *pSelect = sParse.pNewTable->u.view.pSelect;
+          pSelect->selFlags &= ~SF_View;
+          sParse.rc = SQLITE_OK;
+          sqlite3SelectPrep(&sParse, pSelect, 0);
+          rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc);
+          if( rc==SQLITE_OK ){
+            sqlite3WalkSelect(&sWalker, pSelect);
+          }
+        }else{
+          int i;
+          sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck);
+#ifndef SQLITE_OMIT_GENERATED_COLUMNS
+          for(i=0; i<sParse.pNewTable->nCol; i++){
+            sqlite3WalkExpr(&sWalker,
+               sqlite3ColumnExpr(sParse.pNewTable,
+                                         &sParse.pNewTable->aCol[i]));
+          }
+#endif /* SQLITE_OMIT_GENERATED_COLUMNS */
+        }
+      }else if( sParse.pNewIndex ){
+        sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr);
+        sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
+      }else{
+#ifndef SQLITE_OMIT_TRIGGER
+        rc = renameResolveTrigger(&sParse);
+        if( rc==SQLITE_OK ){
+          renameWalkTrigger(&sWalker, sParse.pNewTrigger);
+        }
+#endif /* SQLITE_OMIT_TRIGGER */
+      }
+
+      if( rc==SQLITE_OK ){
+        rc = renameEditSql(context, &sCtx, zInput, 0, 0);
+      }
+      renameTokenFree(db, sCtx.pList);
+    }
+    if( rc!=SQLITE_OK ){
+      sqlite3_result_error_code(context, rc);
+    }
+    renameParseCleanup(&sParse);
+  }
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  db->xAuth = xAuth;
+#endif
+
+  sqlite3BtreeLeaveAll(db);
+}
+
 /*
 ** An SQL user function that checks that there are no parse or symbol
 ** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement.
@@ -107943,6 +109921,8 @@ static void renameTableFunc(
 **   2: Object type ("view", "table", "trigger" or "index").
 **   3: Object name.
 **   4: True if object is from temp schema.
+**   5: "when" part of error message.
+**   6: True to disable the DQS quirk when parsing SQL.
 **
 ** Unless it finds an error, this function normally returns NULL. However, it
 ** returns integer value 1 if:
@@ -107960,6 +109940,8 @@ static void renameTableTest(
   char const *zInput = (const char*)sqlite3_value_text(argv[1]);
   int bTemp = sqlite3_value_int(argv[4]);
   int isLegacy = (db->flags & SQLITE_LegacyAlter);
+  char const *zWhen = (const char*)sqlite3_value_text(argv[5]);
+  int bNoDQS = sqlite3_value_int(argv[6]);
 
 #ifndef SQLITE_OMIT_AUTHORIZATION
   sqlite3_xauth xAuth = db->xAuth;
@@ -107967,16 +109949,20 @@ static void renameTableTest(
 #endif
 
   UNUSED_PARAMETER(NotUsed);
+
   if( zDb && zInput ){
     int rc;
     Parse sParse;
+    int flags = db->flags;
+    if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL);
     rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
+    db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL));
     if( rc==SQLITE_OK ){
-      if( isLegacy==0 && sParse.pNewTable && sParse.pNewTable->pSelect ){
+      if( isLegacy==0 && sParse.pNewTable && IsView(sParse.pNewTable) ){
         NameContext sNC;
         memset(&sNC, 0, sizeof(sNC));
         sNC.pParse = &sParse;
-        sqlite3SelectPrep(&sParse, sParse.pNewTable->pSelect, &sNC);
+        sqlite3SelectPrep(&sParse, sParse.pNewTable->u.view.pSelect, &sNC);
         if( sParse.nErr ) rc = sParse.rc;
       }
 
@@ -107992,8 +109978,8 @@ static void renameTableTest(
       }
     }
 
-    if( rc!=SQLITE_OK ){
-      renameColumnParseError(context, 1, argv[2], argv[3], &sParse);
+    if( rc!=SQLITE_OK && zWhen ){
+      renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse);
     }
     renameParseCleanup(&sParse);
   }
@@ -108003,14 +109989,226 @@ static void renameTableTest(
 #endif
 }
 
+/*
+** The implementation of internal UDF sqlite_drop_column().
+**
+** Arguments:
+**
+**  argv[0]: An integer - the index of the schema containing the table
+**  argv[1]: CREATE TABLE statement to modify.
+**  argv[2]: An integer - the index of the column to remove.
+**
+** The value returned is a string containing the CREATE TABLE statement
+** with column argv[2] removed.
+*/
+static void dropColumnFunc(
+  sqlite3_context *context,
+  int NotUsed,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  int iSchema = sqlite3_value_int(argv[0]);
+  const char *zSql = (const char*)sqlite3_value_text(argv[1]);
+  int iCol = sqlite3_value_int(argv[2]);
+  const char *zDb = db->aDb[iSchema].zDbSName;
+  int rc;
+  Parse sParse;
+  RenameToken *pCol;
+  Table *pTab;
+  const char *zEnd;
+  char *zNew = 0;
+
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  sqlite3_xauth xAuth = db->xAuth;
+  db->xAuth = 0;
+#endif
+
+  UNUSED_PARAMETER(NotUsed);
+  rc = renameParseSql(&sParse, zDb, db, zSql, iSchema==1);
+  if( rc!=SQLITE_OK ) goto drop_column_done;
+  pTab = sParse.pNewTable;
+  if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
+    /* This can happen if the sqlite_schema table is corrupt */
+    rc = SQLITE_CORRUPT_BKPT;
+    goto drop_column_done;
+  }
+
+  pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
+  if( iCol<pTab->nCol-1 ){
+    RenameToken *pEnd;
+    pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
+    zEnd = (const char*)pEnd->t.z;
+  }else{
+    assert( IsOrdinaryTable(pTab) );
+    zEnd = (const char*)&zSql[pTab->u.tab.addColOffset];
+    while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--;
+  }
+
+  zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd);
+  sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT);
+  sqlite3_free(zNew);
+
+drop_column_done:
+  renameParseCleanup(&sParse);
+#ifndef SQLITE_OMIT_AUTHORIZATION
+  db->xAuth = xAuth;
+#endif
+  if( rc!=SQLITE_OK ){
+    sqlite3_result_error_code(context, rc);
+  }
+}
+
+/*
+** This function is called by the parser upon parsing an
+**
+**     ALTER TABLE pSrc DROP COLUMN pName
+**
+** statement. Argument pSrc contains the possibly qualified name of the
+** table being edited, and token pName the name of the column to drop.
+*/
+SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const Token *pName){
+  sqlite3 *db = pParse->db;       /* Database handle */
+  Table *pTab;                    /* Table to modify */
+  int iDb;                        /* Index of db containing pTab in aDb[] */
+  const char *zDb;                /* Database containing pTab ("main" etc.) */
+  char *zCol = 0;                 /* Name of column to drop */
+  int iCol;                       /* Index of column zCol in pTab->aCol[] */
+
+  /* Look up the table being altered. */
+  assert( pParse->pNewTable==0 );
+  assert( sqlite3BtreeHoldsAllMutexes(db) );
+  if( NEVER(db->mallocFailed) ) goto exit_drop_column;
+  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
+  if( !pTab ) goto exit_drop_column;
+
+  /* Make sure this is not an attempt to ALTER a view, virtual table or
+  ** system table. */
+  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
+  if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
+
+  /* Find the index of the column being dropped. */
+  zCol = sqlite3NameFromToken(db, pName);
+  if( zCol==0 ){
+    assert( db->mallocFailed );
+    goto exit_drop_column;
+  }
+  iCol = sqlite3ColumnIndex(pTab, zCol);
+  if( iCol<0 ){
+    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zCol);
+    goto exit_drop_column;
+  }
+
+  /* Do not allow the user to drop a PRIMARY KEY column or a column
+  ** constrained by a UNIQUE constraint.  */
+  if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
+    sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"",
+        (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
+        zCol
+    );
+    goto exit_drop_column;
+  }
+
+  /* Do not allow the number of columns to go to zero */
+  if( pTab->nCol<=1 ){
+    sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol);
+    goto exit_drop_column;
+  }
+
+  /* Edit the sqlite_schema table */
+  iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+  assert( iDb>=0 );
+  zDb = db->aDb[iDb].zDbSName;
+  renameTestSchema(pParse, zDb, iDb==1, "", 0);
+  renameFixQuotes(pParse, zDb, iDb==1);
+  sqlite3NestedParse(pParse,
+      "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
+      "sql = sqlite_drop_column(%d, sql, %d) "
+      "WHERE (type=='table' AND tbl_name=%Q COLLATE nocase)"
+      , zDb, iDb, iCol, pTab->zName
+  );
+
+  /* Drop and reload the database schema. */
+  renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
+  renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
+
+  /* Edit rows of table on disk */
+  if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
+    int i;
+    int addr;
+    int reg;
+    int regRec;
+    Index *pPk = 0;
+    int nField = 0;               /* Number of non-virtual columns after drop */
+    int iCur;
+    Vdbe *v = sqlite3GetVdbe(pParse);
+    iCur = pParse->nTab++;
+    sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
+    addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
+    reg = ++pParse->nMem;
+    if( HasRowid(pTab) ){
+      sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg);
+      pParse->nMem += pTab->nCol;
+    }else{
+      pPk = sqlite3PrimaryKeyIndex(pTab);
+      pParse->nMem += pPk->nColumn;
+      for(i=0; i<pPk->nKeyCol; i++){
+        sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1);
+      }
+      nField = pPk->nKeyCol;
+    }
+    regRec = ++pParse->nMem;
+    for(i=0; i<pTab->nCol; i++){
+      if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
+        int regOut;
+        if( pPk ){
+          int iPos = sqlite3TableColumnToIndex(pPk, i);
+          int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
+          if( iPos<pPk->nKeyCol ) continue;
+          regOut = reg+1+iPos-(iPos>iColPos);
+        }else{
+          regOut = reg+1+nField;
+        }
+        if( i==pTab->iPKey ){
+          sqlite3VdbeAddOp2(v, OP_Null, 0, regOut);
+        }else{
+          sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
+        }
+        nField++;
+      }
+    }
+    if( nField==0 ){
+      /* dbsqlfuzz 5f09e7bcc78b4954d06bf9f2400d7715f48d1fef */
+      pParse->nMem++;
+      sqlite3VdbeAddOp2(v, OP_Null, 0, reg+1);
+      nField = 1;
+    }
+    sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec);
+    if( pPk ){
+      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
+    }else{
+      sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg);
+    }
+    sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
+
+    sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v);
+    sqlite3VdbeJumpHere(v, addr);
+  }
+
+exit_drop_column:
+  sqlite3DbFree(db, zCol);
+  sqlite3SrcListDelete(db, pSrc);
+}
+
 /*
 ** Register built-in functions used to help implement ALTER TABLE
 */
 SQLITE_PRIVATE void sqlite3AlterFunctions(void){
   static FuncDef aAlterTableFuncs[] = {
-    INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc),
-    INTERNAL_FUNCTION(sqlite_rename_table,  7, renameTableFunc),
-    INTERNAL_FUNCTION(sqlite_rename_test,   5, renameTableTest),
+    INTERNAL_FUNCTION(sqlite_rename_column,  9, renameColumnFunc),
+    INTERNAL_FUNCTION(sqlite_rename_table,   7, renameTableFunc),
+    INTERNAL_FUNCTION(sqlite_rename_test,    7, renameTableTest),
+    INTERNAL_FUNCTION(sqlite_drop_column,    3, dropColumnFunc),
+    INTERNAL_FUNCTION(sqlite_rename_quotefix,2, renameQuotefixFunc),
   };
   sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs));
 }
@@ -108453,7 +110651,6 @@ static void statInit(
       + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
   }
 #endif
-  db = sqlite3_context_db_handle(context);
   p = sqlite3DbMallocZero(db, n);
   if( p==0 ){
     sqlite3_result_error_nomem(context);
@@ -108872,28 +111069,19 @@ static void statGet(
     **
     **        I = (K+D-1)/D
     */
-    char *z;
-    int i;
-
-    char *zRet = sqlite3MallocZero( (p->nKeyCol+1)*25 );
-    if( zRet==0 ){
-      sqlite3_result_error_nomem(context);
-      return;
-    }
+    sqlite3_str sStat;   /* Text of the constructed "stat" line */
+    int i;               /* Loop counter */
 
-    sqlite3_snprintf(24, zRet, "%llu",
+    sqlite3StrAccumInit(&sStat, 0, 0, 0, (p->nKeyCol+1)*100);
+    sqlite3_str_appendf(&sStat, "%llu",
         p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow);
-    z = zRet + sqlite3Strlen30(zRet);
     for(i=0; i<p->nKeyCol; i++){
       u64 nDistinct = p->current.anDLt[i] + 1;
       u64 iVal = (p->nRow + nDistinct - 1) / nDistinct;
-      sqlite3_snprintf(24, z, " %llu", iVal);
-      z += sqlite3Strlen30(z);
+      sqlite3_str_appendf(&sStat, " %llu", iVal);
       assert( p->current.anEq[i] );
     }
-    assert( z[0]=='\0' && z>zRet );
-
-    sqlite3_result_text(context, zRet, -1, sqlite3_free);
+    sqlite3ResultStrAccum(context, &sStat);
   }
 #ifdef SQLITE_ENABLE_STAT4
   else if( eCall==STAT_GET_ROWID ){
@@ -108912,6 +111100,8 @@ static void statGet(
     }
   }else{
     tRowcnt *aCnt = 0;
+    sqlite3_str sStat;
+    int i;
 
     assert( p->iGet<p->nSample );
     switch( eCall ){
@@ -108923,23 +111113,12 @@ static void statGet(
         break;
       }
     }
-
-    {
-      char *zRet = sqlite3MallocZero(p->nCol * 25);
-      if( zRet==0 ){
-        sqlite3_result_error_nomem(context);
-      }else{
-        int i;
-        char *z = zRet;
-        for(i=0; i<p->nCol; i++){
-          sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]);
-          z += sqlite3Strlen30(z);
-        }
-        assert( z[0]=='\0' && z>zRet );
-        z[-1] = '\0';
-        sqlite3_result_text(context, zRet, -1, sqlite3_free);
-      }
+    sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
+    for(i=0; i<p->nCol; i++){
+      sqlite3_str_appendf(&sStat, "%llu ", (u64)aCnt[i]);
     }
+    if( sStat.nChar ) sStat.nChar--;
+    sqlite3ResultStrAccum(context, &sStat);
   }
 #endif /* SQLITE_ENABLE_STAT4 */
 #ifndef SQLITE_DEBUG
@@ -108988,7 +111167,7 @@ static void analyzeVdbeCommentIndexWithColumnName(
   }else if( i==XN_EXPR ){
     VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
   }else{
-    VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zName));
+    VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
   }
 }
 #else
@@ -109035,7 +111214,7 @@ static void analyzeOneTable(
   if( v==0 || NEVER(pTab==0) ){
     return;
   }
-  if( pTab->tnum==0 ){
+  if( !IsOrdinaryTable(pTab) ){
     /* Do not gather statistics on views or virtual tables */
     return;
   }
@@ -109860,9 +112039,12 @@ static int loadStatTbl(
 */
 static int loadStat4(sqlite3 *db, const char *zDb){
   int rc = SQLITE_OK;             /* Result codes from subroutines */
+  const Table *pStat4;
 
   assert( db->lookaside.bDisable );
-  if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){
+  if( (pStat4 = sqlite3FindTable(db, "sqlite_stat4", zDb))!=0
+   && IsOrdinaryTable(pStat4)
+  ){
     rc = loadStatTbl(db,
       "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx",
       "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4",
@@ -109899,6 +112081,7 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
   char *zSql;
   int rc = SQLITE_OK;
   Schema *pSchema = db->aDb[iDb].pSchema;
+  const Table *pStat1;
 
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pBt!=0 );
@@ -109921,7 +112104,9 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
   /* Load new statistics out of the sqlite_stat1 table */
   sInfo.db = db;
   sInfo.zDatabase = db->aDb[iDb].zDbSName;
-  if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)!=0 ){
+  if( (pStat1 = sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase))
+   && IsOrdinaryTable(pStat1)
+  ){
     zSql = sqlite3MPrintf(db,
         "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
     if( zSql==0 ){
@@ -110061,7 +112246,7 @@ static void attachFunc(
   if( zFile==0 ) zFile = "";
   if( zName==0 ) zName = "";
 
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
 # define REOPEN_AS_MEMDB(db)  (db->init.reopenMemdb)
 #else
 # define REOPEN_AS_MEMDB(db)  (0)
@@ -110312,9 +112497,9 @@ static void codeAttach(
   sName.pParse = pParse;
 
   if(
-      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
-      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
-      SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
+      SQLITE_OK!=resolveAttachExpr(&sName, pFilename) ||
+      SQLITE_OK!=resolveAttachExpr(&sName, pDbname) ||
+      SQLITE_OK!=resolveAttachExpr(&sName, pKey)
   ){
     goto attach_end;
   }
@@ -110323,6 +112508,7 @@ static void codeAttach(
   if( pAuthArg ){
     char *zAuthArg;
     if( pAuthArg->op==TK_STRING ){
+      assert( !ExprHasProperty(pAuthArg, EP_IntValue) );
       zAuthArg = pAuthArg->u.zToken;
     }else{
       zAuthArg = 0;
@@ -110399,6 +112585,65 @@ SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *p
 }
 #endif /* SQLITE_OMIT_ATTACH */
 
+/*
+** Expression callback used by sqlite3FixAAAA() routines.
+*/
+static int fixExprCb(Walker *p, Expr *pExpr){
+  DbFixer *pFix = p->u.pFix;
+  if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
+  if( pExpr->op==TK_VARIABLE ){
+    if( pFix->pParse->db->init.busy ){
+      pExpr->op = TK_NULL;
+    }else{
+      sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
+      return WRC_Abort;
+    }
+  }
+  return WRC_Continue;
+}
+
+/*
+** Select callback used by sqlite3FixAAAA() routines.
+*/
+static int fixSelectCb(Walker *p, Select *pSelect){
+  DbFixer *pFix = p->u.pFix;
+  int i;
+  SrcItem *pItem;
+  sqlite3 *db = pFix->pParse->db;
+  int iDb = sqlite3FindDbName(db, pFix->zDb);
+  SrcList *pList = pSelect->pSrc;
+
+  if( NEVER(pList==0) ) return WRC_Continue;
+  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
+    if( pFix->bTemp==0 ){
+      if( pItem->zDatabase ){
+        if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
+          sqlite3ErrorMsg(pFix->pParse,
+              "%s %T cannot reference objects in database %s",
+              pFix->zType, pFix->pName, pItem->zDatabase);
+          return WRC_Abort;
+        }
+        sqlite3DbFree(db, pItem->zDatabase);
+        pItem->zDatabase = 0;
+        pItem->fg.notCte = 1;
+      }
+      pItem->pSchema = pFix->pSchema;
+      pItem->fg.fromDDL = 1;
+    }
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
+    if( sqlite3WalkExpr(&pFix->w, pList->a[i].pOn) ) return WRC_Abort;
+#endif
+  }
+  if( pSelect->pWith ){
+    for(i=0; i<pSelect->pWith->nCte; i++){
+      if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){
+        return WRC_Abort;
+      }
+    }
+  }
+  return WRC_Continue;
+}
+
 /*
 ** Initialize a DbFixer structure.  This routine must be called prior
 ** to passing the structure to one of the sqliteFixAAAA() routines below.
@@ -110410,9 +112655,7 @@ SQLITE_PRIVATE void sqlite3FixInit(
   const char *zType,  /* "view", "trigger", or "index" */
   const Token *pName  /* Name of the view, trigger, or index */
 ){
-  sqlite3 *db;
-
-  db = pParse->db;
+  sqlite3 *db = pParse->db;
   assert( db->nDb>iDb );
   pFix->pParse = pParse;
   pFix->zDb = db->aDb[iDb].zDbSName;
@@ -110420,6 +112663,13 @@ SQLITE_PRIVATE void sqlite3FixInit(
   pFix->zType = zType;
   pFix->pName = pName;
   pFix->bTemp = (iDb==1);
+  pFix->w.pParse = pParse;
+  pFix->w.xExprCallback = fixExprCb;
+  pFix->w.xSelectCallback = fixSelectCb;
+  pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback;
+  pFix->w.walkerDepth = 0;
+  pFix->w.eCode = 0;
+  pFix->w.u.pFix = pFix;
 }
 
 /*
@@ -110440,115 +112690,27 @@ SQLITE_PRIVATE int sqlite3FixSrcList(
   DbFixer *pFix,       /* Context of the fixation */
   SrcList *pList       /* The Source list to check and modify */
 ){
-  int i;
-  struct SrcList_item *pItem;
-  sqlite3 *db = pFix->pParse->db;
-  int iDb = sqlite3FindDbName(db, pFix->zDb);
-
-  if( NEVER(pList==0) ) return 0;
-
-  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
-    if( pFix->bTemp==0 ){
-      if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
-        sqlite3ErrorMsg(pFix->pParse,
-            "%s %T cannot reference objects in database %s",
-            pFix->zType, pFix->pName, pItem->zDatabase);
-        return 1;
-      }
-      sqlite3DbFree(db, pItem->zDatabase);
-      pItem->zDatabase = 0;
-      pItem->pSchema = pFix->pSchema;
-      pItem->fg.fromDDL = 1;
-    }
-#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
-    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
-    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
-#endif
-    if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
-      return 1;
-    }
+  int res = 0;
+  if( pList ){
+    Select s;
+    memset(&s, 0, sizeof(s));
+    s.pSrc = pList;
+    res = sqlite3WalkSelect(&pFix->w, &s);
   }
-  return 0;
+  return res;
 }
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
 SQLITE_PRIVATE int sqlite3FixSelect(
   DbFixer *pFix,       /* Context of the fixation */
   Select *pSelect      /* The SELECT statement to be fixed to one database */
 ){
-  while( pSelect ){
-    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
-      return 1;
-    }
-    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
-      return 1;
-    }
-    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
-      return 1;
-    }
-    if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
-      return 1;
-    }
-    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
-      return 1;
-    }
-    if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
-      return 1;
-    }
-    if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
-      return 1;
-    }
-    if( pSelect->pWith ){
-      int i;
-      for(i=0; i<pSelect->pWith->nCte; i++){
-        if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
-          return 1;
-        }
-      }
-    }
-    pSelect = pSelect->pPrior;
-  }
-  return 0;
+  return sqlite3WalkSelect(&pFix->w, pSelect);
 }
 SQLITE_PRIVATE int sqlite3FixExpr(
   DbFixer *pFix,     /* Context of the fixation */
   Expr *pExpr        /* The expression to be fixed to one database */
 ){
-  while( pExpr ){
-    if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
-    if( pExpr->op==TK_VARIABLE ){
-      if( pFix->pParse->db->init.busy ){
-        pExpr->op = TK_NULL;
-      }else{
-        sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
-        return 1;
-      }
-    }
-    if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
-    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
-      if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
-    }else{
-      if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
-    }
-    if( sqlite3FixExpr(pFix, pExpr->pRight) ){
-      return 1;
-    }
-    pExpr = pExpr->pLeft;
-  }
-  return 0;
-}
-SQLITE_PRIVATE int sqlite3FixExprList(
-  DbFixer *pFix,     /* Context of the fixation */
-  ExprList *pList    /* The expression to be fixed to one database */
-){
-  int i;
-  struct ExprList_item *pItem;
-  if( pList==0 ) return 0;
-  for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
-    if( sqlite3FixExpr(pFix, pItem->pExpr) ){
-      return 1;
-    }
-  }
-  return 0;
+  return sqlite3WalkExpr(&pFix->w, pExpr);
 }
 #endif
 
@@ -110558,32 +112720,30 @@ SQLITE_PRIVATE int sqlite3FixTriggerStep(
   TriggerStep *pStep /* The trigger step be fixed to one database */
 ){
   while( pStep ){
-    if( sqlite3FixSelect(pFix, pStep->pSelect) ){
-      return 1;
-    }
-    if( sqlite3FixExpr(pFix, pStep->pWhere) ){
-      return 1;
-    }
-    if( sqlite3FixExprList(pFix, pStep->pExprList) ){
-      return 1;
-    }
-    if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){
+    if( sqlite3WalkSelect(&pFix->w, pStep->pSelect)
+     || sqlite3WalkExpr(&pFix->w, pStep->pWhere)
+     || sqlite3WalkExprList(&pFix->w, pStep->pExprList)
+     || sqlite3FixSrcList(pFix, pStep->pFrom)
+    ){
       return 1;
     }
 #ifndef SQLITE_OMIT_UPSERT
-    if( pStep->pUpsert ){
-      Upsert *pUp = pStep->pUpsert;
-      if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
-       || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
-       || sqlite3FixExprList(pFix, pUp->pUpsertSet)
-       || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
-      ){
-        return 1;
+    {
+      Upsert *pUp;
+      for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){
+        if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget)
+         || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere)
+         || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet)
+         || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere)
+        ){
+          return 1;
+        }
       }
     }
 #endif
     pStep = pStep->pNext;
   }
+
   return 0;
 }
 #endif
@@ -110735,7 +112895,6 @@ SQLITE_PRIVATE void sqlite3AuthRead(
   Schema *pSchema,      /* The schema of the expression */
   SrcList *pTabList     /* All table that pExpr might refer to */
 ){
-  sqlite3 *db = pParse->db;
   Table *pTab = 0;      /* The table being read */
   const char *zCol;     /* Name of the column of the table */
   int iSrc;             /* Index in pTabList->a[] of table being read */
@@ -110743,8 +112902,8 @@ SQLITE_PRIVATE void sqlite3AuthRead(
   int iCol;             /* Index of column in table */
 
   assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
-  assert( !IN_RENAME_OBJECT || db->xAuth==0 );
-  if( db->xAuth==0 ) return;
+  assert( !IN_RENAME_OBJECT );
+  assert( pParse->db->xAuth!=0 );
   iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
   if( iDb<0 ){
     /* An attempt to read a column out of a subquery or other
@@ -110756,7 +112915,7 @@ SQLITE_PRIVATE void sqlite3AuthRead(
     pTab = pParse->pTriggerTab;
   }else{
     assert( pTabList );
-    for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){
+    for(iSrc=0; iSrc<pTabList->nSrc; iSrc++){
       if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
         pTab = pTabList->a[iSrc].pTab;
         break;
@@ -110764,18 +112923,18 @@ SQLITE_PRIVATE void sqlite3AuthRead(
     }
   }
   iCol = pExpr->iColumn;
-  if( NEVER(pTab==0) ) return;
+  if( pTab==0 ) return;
 
   if( iCol>=0 ){
     assert( iCol<pTab->nCol );
-    zCol = pTab->aCol[iCol].zName;
+    zCol = pTab->aCol[iCol].zCnName;
   }else if( pTab->iPKey>=0 ){
     assert( pTab->iPKey<pTab->nCol );
-    zCol = pTab->aCol[pTab->iPKey].zName;
+    zCol = pTab->aCol[pTab->iPKey].zCnName;
   }else{
     zCol = "ROWID";
   }
-  assert( iDb>=0 && iDb<db->nDb );
+  assert( iDb>=0 && iDb<pParse->db->nDb );
   if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
     pExpr->op = TK_NULL;
   }
@@ -110801,11 +112960,7 @@ SQLITE_PRIVATE int sqlite3AuthCheck(
   ** or if the parser is being invoked from within sqlite3_declare_vtab.
   */
   assert( !IN_RENAME_OBJECT || db->xAuth==0 );
-  if( db->init.busy || IN_SPECIAL_PARSE ){
-    return SQLITE_OK;
-  }
-
-  if( db->xAuth==0 ){
+  if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){
     return SQLITE_OK;
   }
 
@@ -110914,7 +113069,7 @@ struct TableLock {
 ** code to make the lock occur is generated by a later call to
 ** codeTableLocks() which occurs during sqlite3FinishCoding().
 */
-SQLITE_PRIVATE void sqlite3TableLock(
+static SQLITE_NOINLINE void lockTable(
   Parse *pParse,     /* Parsing context */
   int iDb,           /* Index of the database containing the table to lock */
   Pgno iTab,         /* Root page number of the table to be locked */
@@ -110927,8 +113082,6 @@ SQLITE_PRIVATE void sqlite3TableLock(
   TableLock *p;
   assert( iDb>=0 );
 
-  if( iDb==1 ) return;
-  if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
   pToplevel = sqlite3ParseToplevel(pParse);
   for(i=0; i<pToplevel->nTableLock; i++){
     p = &pToplevel->aTableLock[i];
@@ -110952,6 +113105,17 @@ SQLITE_PRIVATE void sqlite3TableLock(
     sqlite3OomFault(pToplevel->db);
   }
 }
+SQLITE_PRIVATE void sqlite3TableLock(
+  Parse *pParse,     /* Parsing context */
+  int iDb,           /* Index of the database containing the table to lock */
+  Pgno iTab,         /* Root page number of the table to be locked */
+  u8 isWriteLock,    /* True for a write lock */
+  const char *zName  /* Name of the table to be locked */
+){
+  if( iDb==1 ) return;
+  if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
+  lockTable(pParse, iDb, iTab, isWriteLock, zName);
+}
 
 /*
 ** Code an OP_TableLock instruction for each table locked by the
@@ -111011,10 +113175,40 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
   /* Begin by generating some termination code at the end of the
   ** vdbe program
   */
-  v = sqlite3GetVdbe(pParse);
+  v = pParse->pVdbe;
+  if( v==0 ){
+    if( db->init.busy ){
+      pParse->rc = SQLITE_DONE;
+      return;
+    }
+    v = sqlite3GetVdbe(pParse);
+    if( v==0 ) pParse->rc = SQLITE_ERROR;
+  }
   assert( !pParse->isMultiWrite
        || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
   if( v ){
+    if( pParse->bReturning ){
+      Returning *pReturning = pParse->u1.pReturning;
+      int addrRewind;
+      int i;
+      int reg;
+
+      if( pReturning->nRetCol==0 ){
+        assert( CORRUPT_DB );
+      }else{
+        addrRewind =
+           sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
+        VdbeCoverage(v);
+        reg = pReturning->iRetReg;
+        for(i=0; i<pReturning->nRetCol; i++){
+          sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
+        }
+        sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
+        sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
+        VdbeCoverage(v);
+        sqlite3VdbeJumpHere(v, addrRewind);
+      }
+    }
     sqlite3VdbeAddOp0(v, OP_Halt);
 
 #if SQLITE_USER_AUTHENTICATION
@@ -111092,12 +113286,20 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
         }
       }
 
+      if( pParse->bReturning ){
+        Returning *pRet = pParse->u1.pReturning;
+        if( pRet->nRetCol==0 ){
+          assert( CORRUPT_DB );
+        }else{
+          sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
+        }
+      }
+
       /* Finally, jump back to the beginning of the executable code. */
       sqlite3VdbeGoto(v, 1);
     }
   }
 
-
   /* Get the VDBE program ready for execution
   */
   if( v && pParse->nErr==0 && !db->mallocFailed ){
@@ -111114,20 +113316,22 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
 /*
 ** Run the parser and code generator recursively in order to generate
 ** code for the SQL statement given onto the end of the pParse context
-** currently under construction.  When the parser is run recursively
-** this way, the final OP_Halt is not appended and other initialization
-** and finalization steps are omitted because those are handling by the
-** outermost parser.
+** currently under construction.  Notes:
 **
-** Not everything is nestable.  This facility is designed to permit
-** INSERT, UPDATE, and DELETE operations against the schema table.  Use
-** care if you decide to try to use this routine for some other purposes.
+**   *  The final OP_Halt is not appended and other initialization
+**      and finalization steps are omitted because those are handling by the
+**      outermost parser.
+**
+**   *  Built-in SQL functions always take precedence over application-defined
+**      SQL functions.  In other words, it is not possible to override a
+**      built-in function.
 */
 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
   va_list ap;
   char *zSql;
   char *zErrMsg = 0;
   sqlite3 *db = pParse->db;
+  u32 savedDbFlags = db->mDbFlags;
   char saveBuf[PARSE_TAIL_SZ];
 
   if( pParse->nErr ) return;
@@ -111146,7 +113350,9 @@ SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
   pParse->nested++;
   memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
   memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
+  db->mDbFlags |= DBFLAG_PreferBuiltin;
   sqlite3RunParser(pParse, zSql, &zErrMsg);
+  db->mDbFlags = savedDbFlags;
   sqlite3DbFree(db, zErrMsg);
   sqlite3DbFree(db, zSql);
   memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
@@ -111204,17 +113410,17 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const cha
     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
+        if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0
+         || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0
+         || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0
         ){
           p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
-                              DFLT_TEMP_SCHEMA_TABLE);
+                              LEGACY_TEMP_SCHEMA_TABLE);
         }
       }else{
-        if( sqlite3StrICmp(zName+7, &ALT_SCHEMA_TABLE[7])==0 ){
+        if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
           p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash,
-                              DFLT_SCHEMA_TABLE);
+                              LEGACY_SCHEMA_TABLE);
         }
       }
     }
@@ -111232,11 +113438,11 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const cha
       if( p ) break;
     }
     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 ){
+      if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){
+        p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, LEGACY_SCHEMA_TABLE);
+      }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){
         p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash,
-                            DFLT_TEMP_SCHEMA_TABLE);
+                            LEGACY_TEMP_SCHEMA_TABLE);
       }
     }
   }
@@ -111276,12 +113482,13 @@ SQLITE_PRIVATE Table *sqlite3LocateTable(
     /* If zName is the not the name of a table in the schema created using
     ** CREATE, then check to see if it is the name of an virtual table that
     ** can be an eponymous virtual table. */
-    if( pParse->disableVtab==0 ){
+    if( pParse->disableVtab==0 && db->init.busy==0 ){
       Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
       if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
         pMod = sqlite3PragmaVtabRegister(db, zName);
       }
       if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
+        testcase( pMod->pEpoTab==0 );
         return pMod->pEpoTab;
       }
     }
@@ -111299,6 +113506,8 @@ SQLITE_PRIVATE Table *sqlite3LocateTable(
     }else{
       sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
     }
+  }else{
+    assert( HasRowid(p) || p->iPKey<0 );
   }
 
   return p;
@@ -111316,7 +113525,7 @@ SQLITE_PRIVATE Table *sqlite3LocateTable(
 SQLITE_PRIVATE Table *sqlite3LocateTableItem(
   Parse *pParse,
   u32 flags,
-  struct SrcList_item *p
+  SrcItem *p
 ){
   const char *zDb;
   assert( p->pSchema==0 || p->zDatabase==0 );
@@ -111329,6 +113538,22 @@ SQLITE_PRIVATE Table *sqlite3LocateTableItem(
   return sqlite3LocateTable(pParse, flags, p->zName, zDb);
 }
 
+/*
+** Return the preferred table name for system tables.  Translate legacy
+** names into the new preferred names, as appropriate.
+*/
+SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){
+  if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){
+    if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){
+      return PREFERRED_SCHEMA_TABLE;
+    }
+    if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){
+      return PREFERRED_TEMP_SCHEMA_TABLE;
+    }
+  }
+  return zName;
+}
+
 /*
 ** Locate the in-memory structure that describes
 ** a particular index given the name of that index
@@ -111493,6 +113718,84 @@ SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
   db->mDbFlags &= ~DBFLAG_SchemaChange;
 }
 
+/*
+** Set the expression associated with a column.  This is usually
+** the DEFAULT value, but might also be the expression that computes
+** the value for a generated column.
+*/
+SQLITE_PRIVATE void sqlite3ColumnSetExpr(
+  Parse *pParse,    /* Parsing context */
+  Table *pTab,      /* The table containing the column */
+  Column *pCol,     /* The column to receive the new DEFAULT expression */
+  Expr *pExpr       /* The new default expression */
+){
+  ExprList *pList;
+  assert( IsOrdinaryTable(pTab) );
+  pList = pTab->u.tab.pDfltList;
+  if( pCol->iDflt==0
+   || NEVER(pList==0)
+   || NEVER(pList->nExpr<pCol->iDflt)
+  ){
+    pCol->iDflt = pList==0 ? 1 : pList->nExpr+1;
+    pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
+  }else{
+    sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
+    pList->a[pCol->iDflt-1].pExpr = pExpr;
+  }
+}
+
+/*
+** Return the expression associated with a column.  The expression might be
+** the DEFAULT clause or the AS clause of a generated column.
+** Return NULL if the column has no associated expression.
+*/
+SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){
+  if( pCol->iDflt==0 ) return 0;
+  if( NEVER(!IsOrdinaryTable(pTab)) ) return 0;
+  if( NEVER(pTab->u.tab.pDfltList==0) ) return 0;
+  if( NEVER(pTab->u.tab.pDfltList->nExpr<pCol->iDflt) ) return 0;
+  return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr;
+}
+
+/*
+** Set the collating sequence name for a column.
+*/
+SQLITE_PRIVATE void sqlite3ColumnSetColl(
+  sqlite3 *db,
+  Column *pCol,
+  const char *zColl
+){
+  i64 nColl;
+  i64 n;
+  char *zNew;
+  assert( zColl!=0 );
+  n = sqlite3Strlen30(pCol->zCnName) + 1;
+  if( pCol->colFlags & COLFLAG_HASTYPE ){
+    n += sqlite3Strlen30(pCol->zCnName+n) + 1;
+  }
+  nColl = sqlite3Strlen30(zColl) + 1;
+  zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n);
+  if( zNew ){
+    pCol->zCnName = zNew;
+    memcpy(pCol->zCnName + n, zColl, nColl);
+    pCol->colFlags |= COLFLAG_HASCOLL;
+  }
+}
+
+/*
+** Return the collating squence name for a column
+*/
+SQLITE_PRIVATE const char *sqlite3ColumnColl(Column *pCol){
+  const char *z;
+  if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0;
+  z = pCol->zCnName;
+  while( *z ){ z++; }
+  if( pCol->colFlags & COLFLAG_HASTYPE ){
+    do{ z++; }while( *z );
+  }
+  return z+1;
+}
+
 /*
 ** Delete memory allocated for the column names of a table or view (the
 ** Table.aCol[] array).
@@ -111503,12 +113806,20 @@ SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
   assert( pTable!=0 );
   if( (pCol = pTable->aCol)!=0 ){
     for(i=0; i<pTable->nCol; i++, pCol++){
-      assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) );
-      sqlite3DbFree(db, pCol->zName);
-      sqlite3ExprDelete(db, pCol->pDflt);
-      sqlite3DbFree(db, pCol->zColl);
+      assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) );
+      sqlite3DbFree(db, pCol->zCnName);
     }
     sqlite3DbFree(db, pTable->aCol);
+    if( IsOrdinaryTable(pTable) ){
+      sqlite3ExprListDelete(db, pTable->u.tab.pDfltList);
+    }
+    if( db==0 || db->pnBytesFreed==0 ){
+      pTable->aCol = 0;
+      pTable->nCol = 0;
+      if( IsOrdinaryTable(pTable) ){
+        pTable->u.tab.pDfltList = 0;
+      }
+    }
   }
 }
 
@@ -111560,19 +113871,25 @@ static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
     sqlite3FreeIndex(db, pIndex);
   }
 
-  /* Delete any foreign keys attached to this table. */
-  sqlite3FkDelete(db, pTable);
+  if( IsOrdinaryTable(pTable) ){
+    sqlite3FkDelete(db, pTable);
+  }
+#ifndef SQLITE_OMIT_VIRTUAL_TABLE
+  else if( IsVirtual(pTable) ){
+    sqlite3VtabClear(db, pTable);
+  }
+#endif
+  else{
+    assert( IsView(pTable) );
+    sqlite3SelectDelete(db, pTable->u.view.pSelect);
+  }
 
   /* Delete the Table structure itself.
   */
   sqlite3DeleteColumnNames(db, pTable);
   sqlite3DbFree(db, pTable->zName);
   sqlite3DbFree(db, pTable->zColAff);
-  sqlite3SelectDelete(db, pTable->pSelect);
   sqlite3ExprListDelete(db, pTable->pCheck);
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  sqlite3VtabClear(db, pTable);
-#endif
   sqlite3DbFree(db, pTable);
 
   /* Verify that no lookaside memory was used by schema tables */
@@ -111618,10 +113935,10 @@ SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char
 ** are not \000 terminated and are not persistent.  The returned string
 ** is \000 terminated and is persistent.
 */
-SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
+SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, const Token *pName){
   char *zName;
   if( pName ){
-    zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
+    zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n);
     sqlite3Dequote(zName);
   }else{
     zName = 0;
@@ -111635,7 +113952,7 @@ SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
 */
 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
   Vdbe *v = sqlite3GetVdbe(p);
-  sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, DFLT_SCHEMA_TABLE);
+  sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE);
   sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
   if( p->nTab==0 ){
     p->nTab = 1;
@@ -111715,7 +114032,7 @@ SQLITE_PRIVATE int sqlite3TwoPartName(
       return -1;
     }
   }else{
-    assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
+    assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE
              || (db->mDbFlags & DBFLAG_Vacuum)!=0);
     iDb = db->init.iDb;
     *pUnqual = pName1;
@@ -111884,6 +114201,23 @@ SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
 }
 #endif
 
+/*
+** Insert a single OP_JournalMode query opcode in order to force the
+** prepared statement to return false for sqlite3_stmt_readonly().  This
+** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
+** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS
+** will return false for sqlite3_stmt_readonly() even if that statement
+** is a read-only no-op.
+*/
+static void sqlite3ForceNotReadOnly(Parse *pParse){
+  int iReg = ++pParse->nMem;
+  Vdbe *v = sqlite3GetVdbe(pParse);
+  if( v ){
+    sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
+    sqlite3VdbeUsesBtree(v, 0);
+  }
+}
+
 /*
 ** Begin constructing a new table representation in memory.  This is
 ** the first of several action routines that get called in response
@@ -111983,6 +114317,7 @@ SQLITE_PRIVATE void sqlite3StartTable(
       }else{
         assert( !db->init.busy || CORRUPT_DB );
         sqlite3CodeVerifySchema(pParse, iDb);
+        sqlite3ForceNotReadOnly(pParse);
       }
       goto begin_table_error;
     }
@@ -112011,17 +114346,6 @@ SQLITE_PRIVATE void sqlite3StartTable(
   assert( pParse->pNewTable==0 );
   pParse->pNewTable = pTable;
 
-  /* If this is the magic sqlite_sequence table used by autoincrement,
-  ** then record a pointer to this table in the main database structure
-  ** so that INSERT can find the table easily.
-  */
-#ifndef SQLITE_OMIT_AUTOINCREMENT
-  if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
-    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
-    pTable->pSchema->pSeqTab = pTable;
-  }
-#endif
-
   /* Begin generating the code that will insert the table record into
   ** the schema table.  Note in particular that we must go ahead
   ** and allocate the record number for the table entry now.  Before any
@@ -112074,7 +114398,8 @@ SQLITE_PRIVATE void sqlite3StartTable(
     }else
 #endif
     {
-      pParse->addrCrTab =
+      assert( !pParse->bReturning );
+      pParse->u1.addrCrTab =
          sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
     }
     sqlite3OpenSchemaTable(pParse, iDb);
@@ -112090,6 +114415,7 @@ SQLITE_PRIVATE void sqlite3StartTable(
 
   /* If an error occurs, we jump here */
 begin_table_error:
+  pParse->checkSchema = 1;
   sqlite3DbFree(db, zName);
   return;
 }
@@ -112099,14 +114425,88 @@ SQLITE_PRIVATE void sqlite3StartTable(
 */
 #if SQLITE_ENABLE_HIDDEN_COLUMNS
 SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
-  if( sqlite3_strnicmp(pCol->zName, "__hidden__", 10)==0 ){
+  if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){
     pCol->colFlags |= COLFLAG_HIDDEN;
+    if( pTab ) pTab->tabFlags |= TF_HasHidden;
   }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){
     pTab->tabFlags |= TF_OOOHidden;
   }
 }
 #endif
 
+/*
+** Name of the special TEMP trigger used to implement RETURNING.  The
+** name begins with "sqlite_" so that it is guaranteed not to collide
+** with any application-generated triggers.
+*/
+#define RETURNING_TRIGGER_NAME  "sqlite_returning"
+
+/*
+** Clean up the data structures associated with the RETURNING clause.
+*/
+static void sqlite3DeleteReturning(sqlite3 *db, Returning *pRet){
+  Hash *pHash;
+  pHash = &(db->aDb[1].pSchema->trigHash);
+  sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0);
+  sqlite3ExprListDelete(db, pRet->pReturnEL);
+  sqlite3DbFree(db, pRet);
+}
+
+/*
+** Add the RETURNING clause to the parse currently underway.
+**
+** This routine creates a special TEMP trigger that will fire for each row
+** of the DML statement.  That TEMP trigger contains a single SELECT
+** statement with a result set that is the argument of the RETURNING clause.
+** The trigger has the Trigger.bReturning flag and an opcode of
+** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
+** knows to handle it specially.  The TEMP trigger is automatically
+** removed at the end of the parse.
+**
+** When this routine is called, we do not yet know if the RETURNING clause
+** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
+** RETURNING trigger instead.  It will then be converted into the appropriate
+** type on the first call to sqlite3TriggersExist().
+*/
+SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){
+  Returning *pRet;
+  Hash *pHash;
+  sqlite3 *db = pParse->db;
+  if( pParse->pNewTrigger ){
+    sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
+  }else{
+    assert( pParse->bReturning==0 );
+  }
+  pParse->bReturning = 1;
+  pRet = sqlite3DbMallocZero(db, sizeof(*pRet));
+  if( pRet==0 ){
+    sqlite3ExprListDelete(db, pList);
+    return;
+  }
+  pParse->u1.pReturning = pRet;
+  pRet->pParse = pParse;
+  pRet->pReturnEL = pList;
+  sqlite3ParserAddCleanup(pParse,
+     (void(*)(sqlite3*,void*))sqlite3DeleteReturning, pRet);
+  testcase( pParse->earlyCleanup );
+  if( db->mallocFailed ) return;
+  pRet->retTrig.zName = RETURNING_TRIGGER_NAME;
+  pRet->retTrig.op = TK_RETURNING;
+  pRet->retTrig.tr_tm = TRIGGER_AFTER;
+  pRet->retTrig.bReturning = 1;
+  pRet->retTrig.pSchema = db->aDb[1].pSchema;
+  pRet->retTrig.pTabSchema = db->aDb[1].pSchema;
+  pRet->retTrig.step_list = &pRet->retTStep;
+  pRet->retTStep.op = TK_RETURNING;
+  pRet->retTStep.pTrig = &pRet->retTrig;
+  pRet->retTStep.pExprList = pList;
+  pHash = &(db->aDb[1].pSchema->trigHash);
+  assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr );
+  if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig)
+          ==&pRet->retTrig ){
+    sqlite3OomFault(db);
+  }
+}
 
 /*
 ** Add a new column to the table currently being constructed.
@@ -112116,60 +114516,104 @@ SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){
 ** first to get things going.  Then this routine is called for each
 ** column.
 */
-SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName, Token *pType){
+SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
   Table *p;
   int i;
   char *z;
   char *zType;
   Column *pCol;
   sqlite3 *db = pParse->db;
+  u8 hName;
+  Column *aNew;
+  u8 eType = COLTYPE_CUSTOM;
+  u8 szEst = 1;
+  char affinity = SQLITE_AFF_BLOB;
+
   if( (p = pParse->pNewTable)==0 ) return;
   if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
     sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
     return;
   }
-  z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
+  if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName);
+
+  /* Because keywords GENERATE ALWAYS can be converted into indentifiers
+  ** by the parser, we can sometimes end up with a typename that ends
+  ** with "generated always".  Check for this case and omit the surplus
+  ** text. */
+  if( sType.n>=16
+   && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0
+  ){
+    sType.n -= 6;
+    while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
+    if( sType.n>=9
+     && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0
+    ){
+      sType.n -= 9;
+      while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--;
+    }
+  }
+
+  /* Check for standard typenames.  For standard typenames we will
+  ** set the Column.eType field rather than storing the typename after
+  ** the column name, in order to save space. */
+  if( sType.n>=3 ){
+    sqlite3DequoteToken(&sType);
+    for(i=0; i<SQLITE_N_STDTYPE; i++){
+       if( sType.n==sqlite3StdTypeLen[i]
+        && sqlite3_strnicmp(sType.z, sqlite3StdType[i], sType.n)==0
+       ){
+         sType.n = 0;
+         eType = i+1;
+         affinity = sqlite3StdTypeAffinity[i];
+         if( affinity<=SQLITE_AFF_TEXT ) szEst = 5;
+         break;
+       }
+    }
+  }
+
+  z = sqlite3DbMallocRaw(db, (i64)sName.n + 1 + (i64)sType.n + (sType.n>0) );
   if( z==0 ) return;
-  if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName);
-  memcpy(z, pName->z, pName->n);
-  z[pName->n] = 0;
+  if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName);
+  memcpy(z, sName.z, sName.n);
+  z[sName.n] = 0;
   sqlite3Dequote(z);
+  hName = sqlite3StrIHash(z);
   for(i=0; i<p->nCol; i++){
-    if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
+    if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){
       sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
       sqlite3DbFree(db, z);
       return;
     }
   }
-  if( (p->nCol & 0x7)==0 ){
-    Column *aNew;
-    aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
-    if( aNew==0 ){
-      sqlite3DbFree(db, z);
-      return;
-    }
-    p->aCol = aNew;
+  aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
+  if( aNew==0 ){
+    sqlite3DbFree(db, z);
+    return;
   }
+  p->aCol = aNew;
   pCol = &p->aCol[p->nCol];
   memset(pCol, 0, sizeof(p->aCol[0]));
-  pCol->zName = z;
-  pCol->hName = sqlite3StrIHash(z);
+  pCol->zCnName = z;
+  pCol->hName = hName;
   sqlite3ColumnPropertiesFromName(p, pCol);
 
-  if( pType->n==0 ){
+  if( sType.n==0 ){
     /* If there is no type specified, columns have the default affinity
     ** 'BLOB' with a default size of 4 bytes. */
-    pCol->affinity = SQLITE_AFF_BLOB;
-    pCol->szEst = 1;
+    pCol->affinity = affinity;
+    pCol->eCType = eType;
+    pCol->szEst = szEst;
 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( 4>=sqlite3GlobalConfig.szSorterRef ){
-      pCol->colFlags |= COLFLAG_SORTERREF;
+    if( affinity==SQLITE_AFF_BLOB ){
+      if( 4>=sqlite3GlobalConfig.szSorterRef ){
+        pCol->colFlags |= COLFLAG_SORTERREF;
+      }
     }
 #endif
   }else{
     zType = z + sqlite3Strlen30(z) + 1;
-    memcpy(zType, pType->z, pType->n);
-    zType[pType->n] = 0;
+    memcpy(zType, sType.z, sType.n);
+    zType[sType.n] = 0;
     sqlite3Dequote(zType);
     pCol->affinity = sqlite3AffinityType(zType, pCol);
     pCol->colFlags |= COLFLAG_HASTYPE;
@@ -112324,7 +114768,7 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue(
     pCol = &(p->aCol[p->nCol-1]);
     if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
       sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
-          pCol->zName);
+          pCol->zCnName);
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
     }else if( pCol->colFlags & COLFLAG_GENERATED ){
       testcase( pCol->colFlags & COLFLAG_VIRTUAL );
@@ -112335,15 +114779,15 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue(
       /* A copy of pExpr is used instead of the original, as pExpr contains
       ** tokens that point to volatile memory.
       */
-      Expr x;
-      sqlite3ExprDelete(db, pCol->pDflt);
+      Expr x, *pDfltExpr;
       memset(&x, 0, sizeof(x));
       x.op = TK_SPAN;
       x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
       x.pLeft = pExpr;
       x.flags = EP_Skip;
-      pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
+      pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
       sqlite3DbFree(db, x.u.zToken);
+      sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
     }
   }
   if( IN_RENAME_OBJECT ){
@@ -112439,9 +114883,11 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey(
       assert( pCExpr!=0 );
       sqlite3StringToId(pCExpr);
       if( pCExpr->op==TK_ID ){
-        const char *zCName = pCExpr->u.zToken;
+        const char *zCName;
+        assert( !ExprHasProperty(pCExpr, EP_IntValue) );
+        zCName = pCExpr->u.zToken;
         for(iCol=0; iCol<pTab->nCol; iCol++){
-          if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
+          if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
             pCol = &pTab->aCol[iCol];
             makeColumnPartOfPrimaryKey(pParse, pCol);
             break;
@@ -112452,7 +114898,7 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey(
   }
   if( nTerm==1
    && pCol
-   && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
+   && pCol->eCType==COLTYPE_INTEGER
    && sortOrder!=SQLITE_SO_DESC
   ){
     if( IN_RENAME_OBJECT && pList ){
@@ -112532,8 +114978,7 @@ SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
 
   if( sqlite3LocateCollSeq(pParse, zColl) ){
     Index *pIdx;
-    sqlite3DbFree(db, p->aCol[i].zColl);
-    p->aCol[i].zColl = zColl;
+    sqlite3ColumnSetColl(db, &p->aCol[i], zColl);
 
     /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
     ** then an index may have been created on this column before the
@@ -112542,12 +114987,11 @@ SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
     for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
       assert( pIdx->nKeyCol==1 );
       if( pIdx->aiColumn[0]==i ){
-        pIdx->azColl[0] = p->aCol[i].zColl;
+        pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
       }
     }
-  }else{
-    sqlite3DbFree(db, zColl);
   }
+  sqlite3DbFree(db, zColl);
 }
 
 /* Change the most recently parsed column to be a GENERATED ALWAYS AS
@@ -112567,7 +115011,7 @@ SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType
     sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
     goto generated_done;
   }
-  if( pCol->pDflt ) goto generated_error;
+  if( pCol->iDflt>0 ) goto generated_error;
   if( pType ){
     if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
       /* no-op */
@@ -112585,13 +115029,13 @@ SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType
   if( pCol->colFlags & COLFLAG_PRIMKEY ){
     makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
   }
-  pCol->pDflt = pExpr;
+  sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
   pExpr = 0;
   goto generated_done;
 
 generated_error:
   sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
-                  pCol->zName);
+                  pCol->zCnName);
 generated_done:
   sqlite3ExprDelete(pParse->db, pExpr);
 #else
@@ -112693,7 +115137,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){
   Column *pCol;
   n = 0;
   for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
-    n += identLength(pCol->zName) + 5;
+    n += identLength(pCol->zCnName) + 5;
   }
   n += identLength(p->zName);
   if( n<50 ){
@@ -112729,7 +115173,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){
     sqlite3_snprintf(n-k, &zStmt[k], zSep);
     k += sqlite3Strlen30(&zStmt[k]);
     zSep = zSep2;
-    identPut(zStmt, &k, pCol->zName);
+    identPut(zStmt, &k, pCol->zCnName);
     assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 );
     assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) );
     testcase( pCol->affinity==SQLITE_AFF_BLOB );
@@ -112813,7 +115257,6 @@ static void estimateIndexWidth(Index *pIdx){
 */
 static int hasColumn(const i16 *aiCol, int nCol, int x){
   while( nCol-- > 0 ){
-    assert( aiCol[0]>=0 );
     if( x==*(aiCol++) ){
       return 1;
     }
@@ -112926,7 +115369,9 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   */
   if( !db->init.imposterTable ){
     for(i=0; i<pTab->nCol; i++){
-      if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 ){
+      if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
+       && (pTab->aCol[i].notNull==OE_None)
+      ){
         pTab->aCol[i].notNull = OE_Abort;
       }
     }
@@ -112936,9 +115381,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY
   ** into BTREE_BLOBKEY.
   */
-  if( pParse->addrCrTab ){
+  assert( !pParse->bReturning );
+  if( pParse->u1.addrCrTab ){
     assert( v );
-    sqlite3VdbeChangeP3(v, pParse->addrCrTab, BTREE_BLOBKEY);
+    sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
   }
 
   /* Locate the PRIMARY KEY index.  Or, if this table was originally
@@ -112947,10 +115393,13 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   if( pTab->iPKey>=0 ){
     ExprList *pList;
     Token ipkToken;
-    sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
+    sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName);
     pList = sqlite3ExprListAppend(pParse, 0,
                   sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
-    if( pList==0 ) return;
+    if( pList==0 ){
+      pTab->tabFlags &= ~TF_WithoutRowid;
+      return;
+    }
     if( IN_RENAME_OBJECT ){
       sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
     }
@@ -112959,7 +115408,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
     pTab->iPKey = -1;
     sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
                        SQLITE_IDXTYPE_PRIMARYKEY);
-    if( db->mallocFailed || pParse->nErr ) return;
+    if( db->mallocFailed || pParse->nErr ){
+      pTab->tabFlags &= ~TF_WithoutRowid;
+      return;
+    }
     pPk = sqlite3PrimaryKeyIndex(pTab);
     assert( pPk->nKeyCol==1 );
   }else{
@@ -113071,7 +115523,7 @@ SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *
   nName = sqlite3Strlen30(pTab->zName);
   if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
   if( zName[nName]!='_' ) return 0;
-  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
+  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
   if( pMod==0 ) return 0;
   if( pMod->pModule->iVersion<3 ) return 0;
   if( pMod->pModule->xShadowName==0 ) return 0;
@@ -113079,6 +115531,41 @@ SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *
 }
 #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
 
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** Table pTab is a virtual table.  If it the virtual table implementation
+** exists and has an xShadowName method, then loop over all other ordinary
+** tables within the same schema looking for shadow tables of pTab, and mark
+** any shadow tables seen using the TF_Shadow flag.
+*/
+SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
+  int nName;                    /* Length of pTab->zName */
+  Module *pMod;                 /* Module for the virtual table */
+  HashElem *k;                  /* For looping through the symbol table */
+
+  assert( IsVirtual(pTab) );
+  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]);
+  if( pMod==0 ) return;
+  if( NEVER(pMod->pModule==0) ) return;
+  if( pMod->pModule->iVersion<3 ) return;
+  if( pMod->pModule->xShadowName==0 ) return;
+  assert( pTab->zName!=0 );
+  nName = sqlite3Strlen30(pTab->zName);
+  for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){
+    Table *pOther = sqliteHashData(k);
+    assert( pOther->zName!=0 );
+    if( !IsOrdinaryTable(pOther) ) continue;
+    if( pOther->tabFlags & TF_Shadow ) continue;
+    if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0
+     && pOther->zName[nName]=='_'
+     && pMod->pModule->xShadowName(pOther->zName+nName+1)
+    ){
+      pOther->tabFlags |= TF_Shadow;
+    }
+  }
+}
+#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
+
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /*
 ** Return true if zName is a shadow table name in the current database
@@ -113152,7 +115639,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
   Parse *pParse,          /* Parse context */
   Token *pCons,           /* The ',' token after the last column defn. */
   Token *pEnd,            /* The ')' before options in the CREATE TABLE */
-  u8 tabOpts,             /* Extra table options. Usually 0. */
+  u32 tabOpts,            /* Extra table options. Usually 0. */
   Select *pSelect         /* Select from a "CREATE ... AS SELECT" */
 ){
   Table *p;                 /* The new table */
@@ -113163,7 +115650,6 @@ SQLITE_PRIVATE void sqlite3EndTable(
   if( pEnd==0 && pSelect==0 ){
     return;
   }
-  assert( !db->mallocFailed );
   p = pParse->pNewTable;
   if( p==0 ) return;
 
@@ -113181,7 +115667,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
   ** table itself.  So mark it read-only.
   */
   if( db->init.busy ){
-    if( pSelect ){
+    if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
       sqlite3ErrorMsg(pParse, "");
       return;
     }
@@ -113189,6 +115675,44 @@ SQLITE_PRIVATE void sqlite3EndTable(
     if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
   }
 
+  /* Special processing for tables that include the STRICT keyword:
+  **
+  **   *  Do not allow custom column datatypes.  Every column must have
+  **      a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB.
+  **
+  **   *  If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY,
+  **      then all columns of the PRIMARY KEY must have a NOT NULL
+  **      constraint.
+  */
+  if( tabOpts & TF_Strict ){
+    int ii;
+    p->tabFlags |= TF_Strict;
+    for(ii=0; ii<p->nCol; ii++){
+      Column *pCol = &p->aCol[ii];
+      if( pCol->eCType==COLTYPE_CUSTOM ){
+        if( pCol->colFlags & COLFLAG_HASTYPE ){
+          sqlite3ErrorMsg(pParse,
+            "unknown datatype for %s.%s: \"%s\"",
+            p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "")
+          );
+        }else{
+          sqlite3ErrorMsg(pParse, "missing datatype for %s.%s",
+                          p->zName, pCol->zCnName);
+        }
+        return;
+      }else if( pCol->eCType==COLTYPE_ANY ){
+        pCol->affinity = SQLITE_AFF_BLOB;
+      }
+      if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0
+       && p->iPKey!=ii
+       && pCol->notNull == OE_None
+      ){
+        pCol->notNull = OE_Abort;
+        p->tabFlags |= TF_HasNotNull;
+      }
+    }
+  }
+
   assert( (p->tabFlags & TF_HasPrimaryKey)==0
        || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
   assert( (p->tabFlags & TF_HasPrimaryKey)!=0
@@ -113233,7 +115757,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     for(ii=0; ii<p->nCol; ii++){
       u32 colFlags = p->aCol[ii].colFlags;
       if( (colFlags & COLFLAG_GENERATED)!=0 ){
-        Expr *pX = p->aCol[ii].pDflt;
+        Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]);
         testcase( colFlags & COLFLAG_VIRTUAL );
         testcase( colFlags & COLFLAG_STORED );
         if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
@@ -113243,8 +115767,8 @@ SQLITE_PRIVATE void sqlite3EndTable(
           ** tree that have been allocated from lookaside memory, which is
           ** illegal in a schema and will lead to errors or heap corruption
           ** when the database connection closes. */
-          sqlite3ExprDelete(db, pX);
-          p->aCol[ii].pDflt = sqlite3ExprAlloc(db, TK_NULL, 0, 0);
+          sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
+               sqlite3ExprAlloc(db, TK_NULL, 0, 0));
         }
       }else{
         nNG++;
@@ -113284,7 +115808,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     /*
     ** Initialize zType for the new view or table.
     */
-    if( p->pSelect==0 ){
+    if( IsOrdinaryTable(p) ){
       /* A regular table */
       zType = "table";
       zType2 = "TABLE";
@@ -113370,7 +115894,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     ** the information we've collected.
     */
     sqlite3NestedParse(pParse,
-      "UPDATE %Q." DFLT_SCHEMA_TABLE
+      "UPDATE %Q." LEGACY_SCHEMA_TABLE
       " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q"
       " WHERE rowid=#%d",
       db->aDb[iDb].zDbSName,
@@ -113388,7 +115912,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     /* Check to see if we need to create an sqlite_sequence table for
     ** keeping track of autoincrement keys.
     */
-    if( (p->tabFlags & TF_Autoincrement)!=0 ){
+    if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){
       Db *pDb = &db->aDb[iDb];
       assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
       if( pDb->pSchema->pSeqTab==0 ){
@@ -113402,7 +115926,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
 
     /* Reparse everything to update our internal data structures */
     sqlite3VdbeAddParseSchemaOp(v, iDb,
-           sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
+           sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0);
   }
 
   /* Add the table to the in-memory representation of the database.
@@ -113411,6 +115935,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     Table *pOld;
     Schema *pSchema = p->pSchema;
     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
+    assert( HasRowid(p) || p->iPKey<0 );
     pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
     if( pOld ){
       assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
@@ -113420,19 +115945,27 @@ SQLITE_PRIVATE void sqlite3EndTable(
     pParse->pNewTable = 0;
     db->mDbFlags |= DBFLAG_SchemaChange;
 
-#ifndef SQLITE_OMIT_ALTERTABLE
-    if( !p->pSelect ){
-      const char *zName = (const char *)pParse->sNameToken.z;
-      int nName;
-      assert( !pSelect && pCons && pEnd );
-      if( pCons->z==0 ){
-        pCons = pEnd;
-      }
-      nName = (int)((const char *)pCons->z - zName);
-      p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
+    /* If this is the magic sqlite_sequence table used by autoincrement,
+    ** then record a pointer to this table in the main database structure
+    ** so that INSERT can find the table easily.  */
+    assert( !pParse->nested );
+#ifndef SQLITE_OMIT_AUTOINCREMENT
+    if( strcmp(p->zName, "sqlite_sequence")==0 ){
+      assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
+      p->pSchema->pSeqTab = p;
     }
 #endif
   }
+
+#ifndef SQLITE_OMIT_ALTERTABLE
+  if( !pSelect && IsOrdinaryTable(p) ){
+    assert( pCons && pEnd );
+    if( pCons->z==0 ){
+      pCons = pEnd;
+    }
+    p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
+  }
+#endif
 }
 
 #ifndef SQLITE_OMIT_VIEW
@@ -113465,6 +115998,16 @@ SQLITE_PRIVATE void sqlite3CreateView(
   sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
   p = pParse->pNewTable;
   if( p==0 || pParse->nErr ) goto create_view_fail;
+
+  /* Legacy versions of SQLite allowed the use of the magic "rowid" column
+  ** on a view, even though views do not have rowids.  The following flag
+  ** setting fixes this problem.  But the fix can be disabled by compiling
+  ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that
+  ** depend upon the old buggy behavior. */
+#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
+  p->tabFlags |= TF_NoVisibleRowid;
+#endif
+
   sqlite3TwoPartName(pParse, pName1, pName2, &pName);
   iDb = sqlite3SchemaToIndex(db, p->pSchema);
   sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
@@ -113477,12 +116020,13 @@ SQLITE_PRIVATE void sqlite3CreateView(
   */
   pSelect->selFlags |= SF_View;
   if( IN_RENAME_OBJECT ){
-    p->pSelect = pSelect;
+    p->u.view.pSelect = pSelect;
     pSelect = 0;
   }else{
-    p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
+    p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
   }
   p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
+  p->eTabType = TABTYP_VIEW;
   if( db->mallocFailed ) goto create_view_fail;
 
   /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
@@ -113536,13 +116080,12 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   assert( pTable );
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-  db->nSchemaLock++;
-  rc = sqlite3VtabCallConnect(pParse, pTable);
-  db->nSchemaLock--;
-  if( rc ){
-    return 1;
+  if( IsVirtual(pTable) ){
+    db->nSchemaLock++;
+    rc = sqlite3VtabCallConnect(pParse, pTable);
+    db->nSchemaLock--;
+    return rc;
   }
-  if( IsVirtual(pTable) ) return 0;
 #endif
 
 #ifndef SQLITE_OMIT_VIEW
@@ -113579,8 +116122,8 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   ** to be permanent.  So the computation is done on a copy of the SELECT
   ** statement that defines the view.
   */
-  assert( pTable->pSelect );
-  pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
+  assert( IsView(pTable) );
+  pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
   if( pSel ){
     u8 eParseMode = pParse->eParseMode;
     pParse->eParseMode = PARSE_MODE_NORMAL;
@@ -113623,6 +116166,7 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
       assert( pTable->aCol==0 );
       pTable->nCol = pSelTab->nCol;
       pTable->aCol = pSelTab->aCol;
+      pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT);
       pSelTab->nCol = 0;
       pSelTab->aCol = 0;
       assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
@@ -113638,8 +116182,6 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   pTable->pSchema->schemaFlags |= DB_UnresetViews;
   if( db->mallocFailed ){
     sqlite3DeleteColumnNames(db, pTable);
-    pTable->aCol = 0;
-    pTable->nCol = 0;
   }
 #endif /* SQLITE_OMIT_VIEW */
   return nErr;
@@ -113656,10 +116198,8 @@ static void sqliteViewResetAll(sqlite3 *db, int idx){
   if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
   for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
     Table *pTab = sqliteHashData(i);
-    if( pTab->pSelect ){
+    if( IsView(pTab) ){
       sqlite3DeleteColumnNames(db, pTab);
-      pTab->aCol = 0;
-      pTab->nCol = 0;
     }
   }
   DbClearProperty(db, idx, DB_UnresetViews);
@@ -113733,7 +116273,7 @@ static void destroyRootPage(Parse *pParse, int iTable, int iDb){
   ** token for additional information.
   */
   sqlite3NestedParse(pParse,
-     "UPDATE %Q." DFLT_SCHEMA_TABLE
+     "UPDATE %Q." LEGACY_SCHEMA_TABLE
      " SET rootpage=%d WHERE #%d AND rootpage=#%d",
      pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
 #endif
@@ -113868,7 +116408,7 @@ SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, in
   ** database.
   */
   sqlite3NestedParse(pParse,
-      "DELETE FROM %Q." DFLT_SCHEMA_TABLE
+      "DELETE FROM %Q." LEGACY_SCHEMA_TABLE
       " WHERE tbl_name=%Q and type!='trigger'",
       pDb->zDbSName, pTab->zName);
   if( !isView && !IsVirtual(pTab) ){
@@ -113896,6 +116436,7 @@ SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db){
   if( (db->flags & SQLITE_Defensive)!=0
    && db->pVtabCtx==0
    && db->nVdbeExec==0
+   && !sqlite3VtabInSync(db)
   ){
     return 1;
   }
@@ -113915,6 +116456,9 @@ static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){
   if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){
     return 1;
   }
+  if( pTab->tabFlags & TF_Eponymous ){
+    return 1;
+  }
   return 0;
 }
 
@@ -113940,7 +116484,10 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView,
   if( noErr ) db->suppressErr--;
 
   if( pTab==0 ){
-    if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
+    if( noErr ){
+      sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
+      sqlite3ForceNotReadOnly(pParse);
+    }
     goto exit_drop_table;
   }
   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
@@ -113996,11 +116543,11 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView,
   /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
   ** on a table.
   */
-  if( isView && pTab->pSelect==0 ){
+  if( isView && !IsView(pTab) ){
     sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
     goto exit_drop_table;
   }
-  if( !isView && pTab->pSelect ){
+  if( !isView && IsView(pTab) ){
     sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
     goto exit_drop_table;
   }
@@ -114051,7 +116598,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
   FKey *pFKey = 0;
   FKey *pNextTo;
   Table *p = pParse->pNewTable;
-  int nByte;
+  i64 nByte;
   int i;
   int nCol;
   char *z;
@@ -114064,7 +116611,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
     if( pToCol && pToCol->nExpr!=1 ){
       sqlite3ErrorMsg(pParse, "foreign key on %s"
          " should reference only one column of table %T",
-         p->aCol[iCol].zName, pTo);
+         p->aCol[iCol].zCnName, pTo);
       goto fk_end;
     }
     nCol = 1;
@@ -114087,7 +116634,8 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
     goto fk_end;
   }
   pFKey->pFrom = p;
-  pFKey->pNextFrom = p->pFKey;
+  assert( IsOrdinaryTable(p) );
+  pFKey->pNextFrom = p->u.tab.pFKey;
   z = (char*)&pFKey->aCol[nCol];
   pFKey->zTo = z;
   if( IN_RENAME_OBJECT ){
@@ -114104,7 +116652,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
     for(i=0; i<nCol; i++){
       int j;
       for(j=0; j<p->nCol; j++){
-        if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zEName)==0 ){
+        if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){
           pFKey->aCol[i].iFrom = j;
           break;
         }
@@ -114152,7 +116700,8 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
 
   /* Link the foreign key to the table as the last step.
   */
-  p->pFKey = pFKey;
+  assert( IsOrdinaryTable(p) );
+  p->u.tab.pFKey = pFKey;
   pFKey = 0;
 
 fk_end:
@@ -114173,7 +116722,9 @@ SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
 #ifndef SQLITE_OMIT_FOREIGN_KEY
   Table *pTab;
   FKey *pFKey;
-  if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
+  if( (pTab = pParse->pNewTable)==0 ) return;
+  if( NEVER(!IsOrdinaryTable(pTab)) ) return;
+  if( (pFKey = pTab->u.tab.pFKey)==0 ) return;
   assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
   pFKey->isDeferred = (u8)isDeferred;
 #endif
@@ -114465,7 +117016,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     goto exit_create_index;
   }
 #ifndef SQLITE_OMIT_VIEW
-  if( pTab->pSelect ){
+  if( IsView(pTab) ){
     sqlite3ErrorMsg(pParse, "views may not be indexed");
     goto exit_create_index;
   }
@@ -114510,6 +117061,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
         }else{
           assert( !db->init.busy );
           sqlite3CodeVerifySchema(pParse, iDb);
+          sqlite3ForceNotReadOnly(pParse);
         }
         goto exit_create_index;
       }
@@ -114555,7 +117107,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     Token prevCol;
     Column *pCol = &pTab->aCol[pTab->nCol-1];
     pCol->colFlags |= COLFLAG_UNIQUE;
-    sqlite3TokenInit(&prevCol, pCol->zName);
+    sqlite3TokenInit(&prevCol, pCol->zCnName);
     pList = sqlite3ExprListAppend(pParse, 0,
               sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
     if( pList==0 ) goto exit_create_index;
@@ -114573,6 +117125,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     Expr *pExpr = pList->a[i].pExpr;
     assert( pExpr!=0 );
     if( pExpr->op==TK_COLLATE ){
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
       nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken));
     }
   }
@@ -114668,6 +117221,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     zColl = 0;
     if( pListItem->pExpr->op==TK_COLLATE ){
       int nColl;
+      assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) );
       zColl = pListItem->pExpr->u.zToken;
       nColl = sqlite3Strlen30(zColl) + 1;
       assert( nExtra>=nColl );
@@ -114676,7 +117230,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
       zExtra += nColl;
       nExtra -= nColl;
     }else if( j>=0 ){
-      zColl = pTab->aCol[j].zColl;
+      zColl = sqlite3ColumnColl(&pTab->aCol[j]);
     }
     if( !zColl ) zColl = sqlite3StrBINARY;
     if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
@@ -114874,7 +117428,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
       /* Add an entry in sqlite_schema for this index
       */
       sqlite3NestedParse(pParse,
-          "INSERT INTO %Q." DFLT_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
+          "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
           db->aDb[iDb].zDbSName,
           pIndex->zName,
           pTab->zName,
@@ -114890,7 +117444,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
         sqlite3RefillIndex(pParse, pIndex, iMem);
         sqlite3ChangeCookie(pParse, iDb);
         sqlite3VdbeAddParseSchemaOp(v, iDb,
-            sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
+            sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
         sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
       }
 
@@ -114911,8 +117465,12 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   /* Clean up before exiting */
 exit_create_index:
   if( pIndex ) sqlite3FreeIndex(db, pIndex);
-  if( pTab ){  /* Ensure all REPLACE indexes are at the end of the list */
-    Index **ppFrom = &pTab->pIndex;
+  if( pTab ){
+    /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
+    ** The list was already ordered when this routine was entered, so at this
+    ** point at most a single index (the newly added index) will be out of
+    ** order.  So we have to reorder at most one index. */
+    Index **ppFrom;
     Index *pThis;
     for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){
       Index *pNext;
@@ -114925,6 +117483,16 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
       }
       break;
     }
+#ifdef SQLITE_DEBUG
+    /* Verify that all REPLACE indexes really are now at the end
+    ** of the index list.  In other words, no other index type ever
+    ** comes after a REPLACE index on the list. */
+    for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){
+      assert( pThis->onError!=OE_Replace
+           || pThis->pNext==0
+           || pThis->pNext->onError==OE_Replace );
+    }
+#endif
   }
   sqlite3ExprDelete(db, pPIWhere);
   sqlite3ExprListDelete(db, pList);
@@ -114976,7 +117544,7 @@ SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
   if( x<99 ){
     pIdx->pTable->nRowLogEst = x = 99;
   }
-  if( pIdx->pPartIdxWhere!=0 ) x -= 10;  assert( 10==sqlite3LogEst(2) );
+  if( pIdx->pPartIdxWhere!=0 ){ x -= 10;  assert( 10==sqlite3LogEst(2) ); }
   a[0] = x;
 
   /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
@@ -115011,9 +117579,10 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists
   pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
   if( pIndex==0 ){
     if( !ifExists ){
-      sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
+      sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
     }else{
       sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
+      sqlite3ForceNotReadOnly(pParse);
     }
     pParse->checkSchema = 1;
     goto exit_drop_index;
@@ -115033,7 +117602,7 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists
     if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
       goto exit_drop_index;
     }
-    if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
+    if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX;
     if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
       goto exit_drop_index;
     }
@@ -115045,7 +117614,7 @@ SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists
   if( v ){
     sqlite3BeginWriteOperation(pParse, 1, iDb);
     sqlite3NestedParse(pParse,
-       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
+       "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='index'",
        db->aDb[iDb].zDbSName, pIndex->zName
     );
     sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
@@ -115283,7 +117852,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
   Token *pTable,      /* Table to append */
   Token *pDatabase    /* Database of the table */
 ){
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   sqlite3 *db;
   assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
   assert( pParse!=0 );
@@ -115324,9 +117893,9 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
 */
 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
   int i;
-  struct SrcList_item *pItem;
-  assert(pList || pParse->db->mallocFailed );
-  if( pList ){
+  SrcItem *pItem;
+  assert( pList || pParse->db->mallocFailed );
+  if( ALWAYS(pList) ){
     for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
       if( pItem->iCursor>=0 ) continue;
       pItem->iCursor = pParse->nTab++;
@@ -115342,7 +117911,7 @@ SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
 */
 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
   int i;
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   if( pList==0 ) return;
   for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
     if( pItem->zDatabase ) sqlite3DbFreeNN(db, pItem->zDatabase);
@@ -115384,7 +117953,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
   Expr *pOn,              /* The ON clause of a join */
   IdList *pUsing          /* The USING clause of a join */
 ){
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   sqlite3 *db = pParse->db;
   if( !p && (pOn || pUsing) ){
     sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
@@ -115428,7 +117997,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
   assert( pIndexedBy!=0 );
   if( p && pIndexedBy->n>0 ){
-    struct SrcList_item *pItem;
+    SrcItem *pItem;
     assert( p->nSrc>0 );
     pItem = &p->a[p->nSrc-1];
     assert( pItem->fg.notIndexed==0 );
@@ -115441,6 +118010,7 @@ SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pI
     }else{
       pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
       pItem->fg.isIndexedBy = 1;
+      assert( pItem->fg.isCte==0 );  /* No collision on union u2 */
     }
   }
 }
@@ -115458,7 +118028,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, Src
       sqlite3SrcListDelete(pParse->db, p2);
     }else{
       p1 = pNew;
-      memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(struct SrcList_item));
+      memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem));
       sqlite3DbFree(pParse->db, p2);
     }
   }
@@ -115471,7 +118041,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, Src
 */
 SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
   if( p ){
-    struct SrcList_item *pItem = &p->a[p->nSrc-1];
+    SrcItem *pItem = &p->a[p->nSrc-1];
     assert( pItem->fg.notIndexed==0 );
     assert( pItem->fg.isIndexedBy==0 );
     assert( pItem->fg.isTabFunc==0 );
@@ -115626,7 +118196,7 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
 static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){
   assert( iDb>=0 && iDb<pToplevel->db->nDb );
   assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 );
-  assert( iDb<SQLITE_MAX_ATTACHED+2 );
+  assert( iDb<SQLITE_MAX_DB );
   assert( sqlite3SchemaMutexHeld(pToplevel->db, iDb, 0) );
   if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
     DbMaskSet(pToplevel->cookieMask, iDb);
@@ -115753,7 +118323,7 @@ SQLITE_PRIVATE void sqlite3UniqueConstraint(
     for(j=0; j<pIdx->nKeyCol; j++){
       char *zCol;
       assert( pIdx->aiColumn[j]>=0 );
-      zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
+      zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
       if( j ) sqlite3_str_append(&errMsg, ", ", 2);
       sqlite3_str_appendall(&errMsg, pTab->zName);
       sqlite3_str_append(&errMsg, ".", 1);
@@ -115780,7 +118350,7 @@ SQLITE_PRIVATE void sqlite3RowidConstraint(
   int rc;
   if( pTab->iPKey>=0 ){
     zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
-                          pTab->aCol[pTab->iPKey].zName);
+                          pTab->aCol[pTab->iPKey].zCnName);
     rc = SQLITE_CONSTRAINT_PRIMARYKEY;
   }else{
     zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
@@ -115968,24 +118538,76 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
 }
 
 #ifndef SQLITE_OMIT_CTE
+/*
+** Create a new CTE object
+*/
+SQLITE_PRIVATE Cte *sqlite3CteNew(
+  Parse *pParse,          /* Parsing context */
+  Token *pName,           /* Name of the common-table */
+  ExprList *pArglist,     /* Optional column name list for the table */
+  Select *pQuery,         /* Query used to initialize the table */
+  u8 eM10d                /* The MATERIALIZED flag */
+){
+  Cte *pNew;
+  sqlite3 *db = pParse->db;
+
+  pNew = sqlite3DbMallocZero(db, sizeof(*pNew));
+  assert( pNew!=0 || db->mallocFailed );
+
+  if( db->mallocFailed ){
+    sqlite3ExprListDelete(db, pArglist);
+    sqlite3SelectDelete(db, pQuery);
+  }else{
+    pNew->pSelect = pQuery;
+    pNew->pCols = pArglist;
+    pNew->zName = sqlite3NameFromToken(pParse->db, pName);
+    pNew->eM10d = eM10d;
+  }
+  return pNew;
+}
+
+/*
+** Clear information from a Cte object, but do not deallocate storage
+** for the object itself.
+*/
+static void cteClear(sqlite3 *db, Cte *pCte){
+  assert( pCte!=0 );
+  sqlite3ExprListDelete(db, pCte->pCols);
+  sqlite3SelectDelete(db, pCte->pSelect);
+  sqlite3DbFree(db, pCte->zName);
+}
+
+/*
+** Free the contents of the CTE object passed as the second argument.
+*/
+SQLITE_PRIVATE void sqlite3CteDelete(sqlite3 *db, Cte *pCte){
+  assert( pCte!=0 );
+  cteClear(db, pCte);
+  sqlite3DbFree(db, pCte);
+}
+
 /*
 ** This routine is invoked once per CTE by the parser while parsing a
-** WITH clause.
+** WITH clause.  The CTE described by teh third argument is added to
+** the WITH clause of the second argument.  If the second argument is
+** NULL, then a new WITH argument is created.
 */
 SQLITE_PRIVATE With *sqlite3WithAdd(
   Parse *pParse,          /* Parsing context */
   With *pWith,            /* Existing WITH clause, or NULL */
-  Token *pName,           /* Name of the common-table */
-  ExprList *pArglist,     /* Optional column name list for the table */
-  Select *pQuery          /* Query used to initialize the table */
+  Cte *pCte               /* CTE to add to the WITH clause */
 ){
   sqlite3 *db = pParse->db;
   With *pNew;
   char *zName;
 
+  if( pCte==0 ){
+    return pWith;
+  }
+
   /* Check that the CTE name is unique within this WITH clause. If
   ** not, store an error in the Parse structure. */
-  zName = sqlite3NameFromToken(pParse->db, pName);
+  zName = pCte->zName;
   if( zName && pWith ){
     int i;
     for(i=0; i<pWith->nCte; i++){
@@ -116004,16 +118626,11 @@ SQLITE_PRIVATE With *sqlite3WithAdd(
   assert( (pNew!=0 && zName!=0) || db->mallocFailed );
 
   if( db->mallocFailed ){
-    sqlite3ExprListDelete(db, pArglist);
-    sqlite3SelectDelete(db, pQuery);
-    sqlite3DbFree(db, zName);
+    sqlite3CteDelete(db, pCte);
     pNew = pWith;
   }else{
-    pNew->a[pNew->nCte].pSelect = pQuery;
-    pNew->a[pNew->nCte].pCols = pArglist;
-    pNew->a[pNew->nCte].zName = zName;
-    pNew->a[pNew->nCte].zCteErr = 0;
-    pNew->nCte++;
+    pNew->a[pNew->nCte++] = *pCte;
+    sqlite3DbFree(db, pCte);
   }
 
   return pNew;
@@ -116026,10 +118643,7 @@ SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){
   if( pWith ){
     int i;
     for(i=0; i<pWith->nCte; i++){
-      struct Cte *pCte = &pWith->a[i];
-      sqlite3ExprListDelete(db, pCte->pCols);
-      sqlite3SelectDelete(db, pCte->pSelect);
-      sqlite3DbFree(db, pCte->zName);
+      cteClear(db, &pWith->a[i]);
     }
     sqlite3DbFree(db, pWith);
   }
@@ -116377,6 +118991,7 @@ SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(
 ){
   FuncDef *p;
   for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){
+    assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
     if( sqlite3StrICmp(p->zName, zFunc)==0 ){
       return p;
     }
@@ -116398,6 +119013,7 @@ SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(
     int nName = sqlite3Strlen30(zName);
     int h = SQLITE_FUNC_HASH(zName[0], nName);
     assert( zName[0]>='a' && zName[0]<='z' );
+    assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN );
     pOther = sqlite3FunctionSearch(h, zName);
     if( pOther ){
       assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
@@ -116608,7 +119224,7 @@ SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
 **
 */
 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
-  struct SrcList_item *pItem = pSrc->a;
+  SrcItem *pItem = pSrc->a;
   Table *pTab;
   assert( pItem && pSrc->nSrc>=1 );
   pTab = sqlite3LocateTableItem(pParse, 0, pItem);
@@ -116616,9 +119232,9 @@ SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
   pItem->pTab = pTab;
   if( pTab ){
     pTab->nTabRef++;
-  }
-  if( sqlite3IndexedByLookup(pParse, pItem) ){
-    pTab = 0;
+    if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
+      pTab = 0;
+    }
   }
   return pTab;
 }
@@ -116663,7 +119279,7 @@ SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
     return 1;
   }
 #ifndef SQLITE_OMIT_VIEW
-  if( !viewOk && pTab->pSelect ){
+  if( !viewOk && IsView(pTab) ){
     sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
     return 1;
   }
@@ -116767,13 +119383,13 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(
   }else{
     Index *pPk = sqlite3PrimaryKeyIndex(pTab);
     if( pPk->nKeyCol==1 ){
-      const char *zName = pTab->aCol[pPk->aiColumn[0]].zName;
+      const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName;
       pLhs = sqlite3Expr(db, TK_ID, zName);
       pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
     }else{
       int i;
       for(i=0; i<pPk->nKeyCol; i++){
-        Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zName);
+        Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName);
         pEList = sqlite3ExprListAppend(pParse, pEList, p);
       }
       pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
@@ -116786,9 +119402,16 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(
   /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
   ** and the SELECT subtree. */
   pSrc->a[0].pTab = 0;
-  pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
+  pSelectSrc = sqlite3SrcListDup(db, pSrc, 0);
   pSrc->a[0].pTab = pTab;
-  pSrc->a[0].pIBIndex = 0;
+  if( pSrc->a[0].fg.isIndexedBy ){
+    assert( pSrc->a[0].fg.isCte==0 );
+    pSrc->a[0].u2.pIBIndex = 0;
+    pSrc->a[0].fg.isIndexedBy = 0;
+    sqlite3DbFree(db, pSrc->a[0].u1.zIndexedBy);
+  }else if( pSrc->a[0].fg.isCte ){
+    pSrc->a[0].u2.pCteUse->nUse++;
+  }
 
   /* generate the SELECT expression tree. */
   pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0,
@@ -116874,7 +119497,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   */
 #ifndef SQLITE_OMIT_TRIGGER
   pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
-  isView = pTab->pSelect!=0;
+  isView = IsView(pTab);
 #else
 # define pTrigger 0
 # define isView 0
@@ -116966,6 +119589,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   if( (db->flags & SQLITE_CountRows)!=0
    && !pParse->nested
    && !pParse->pTriggerTab
+   && !pParse->bReturning
   ){
     memCnt = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
@@ -117000,6 +119624,9 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
       assert( pIdx->pSchema==pTab->pSchema );
       sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
+      if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
+        sqlite3VdbeChangeP3(v, -1, memCnt ? memCnt : -1);
+      }
     }
   }else
 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
@@ -117120,7 +119747,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     if( eOnePass!=ONEPASS_OFF ){
       assert( nKey==nPk );  /* OP_Found will use an unpacked key */
       if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){
-        assert( pPk!=0 || pTab->pSelect!=0 );
+        assert( pPk!=0 || IsView(pTab) );
         sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
         VdbeCoverage(v);
       }
@@ -117187,7 +119814,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   ** invoke the callback function.
   */
   if( memCnt ){
-    sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
+    sqlite3VdbeAddOp2(v, OP_ChngCntRow, memCnt, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
   }
@@ -117354,7 +119981,7 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(
   ** the update-hook is not invoked for rows removed by REPLACE, but the
   ** pre-update-hook is.
   */
-  if( pTab->pSelect==0 ){
+  if( !IsView(pTab) ){
     u8 p5 = 0;
     sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
     sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
@@ -117511,13 +120138,15 @@ SQLITE_PRIVATE int sqlite3GenerateIndexKey(
       continue;
     }
     sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);
-    /* If the column affinity is REAL but the number is an integer, then it
-    ** might be stored in the table as an integer (using a compact
-    ** representation) then converted to REAL by an OP_RealAffinity opcode.
-    ** But we are getting ready to store this value back into an index, where
-    ** it should be converted by to INTEGER again.  So omit the OP_RealAffinity
-    ** opcode if it is present */
-    sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
+    if( pIdx->aiColumn[j]>=0 ){
+      /* If the column affinity is REAL but the number is an integer, then it
+      ** might be stored in the table as an integer (using a compact
+      ** representation) then converted to REAL by an OP_RealAffinity opcode.
+      ** But we are getting ready to store this value back into an index, where
+      ** it should be converted by to INTEGER again.  So omit the
+      ** OP_RealAffinity opcode if it is present */
+      sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
+    }
   }
   if( regOut ){
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
@@ -118112,9 +120741,9 @@ static void last_insert_rowid(
 /*
 ** Implementation of the changes() SQL function.
 **
-** IMP: R-62073-11209 The changes() SQL function is a wrapper
-** around the sqlite3_changes() C/C++ function and hence follows the same
-** rules for counting changes.
+** IMP: R-32760-32347 The changes() SQL function is a wrapper
+** around the sqlite3_changes64() C/C++ function and hence follows the
+** same rules for counting changes.
 */
 static void changes(
   sqlite3_context *context,
@@ -118123,12 +120752,12 @@ static void changes(
 ){
   sqlite3 *db = sqlite3_context_db_handle(context);
   UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  sqlite3_result_int(context, sqlite3_changes(db));
+  sqlite3_result_int64(context, sqlite3_changes64(db));
 }
 
 /*
 ** Implementation of the total_changes() SQL function.  The return value is
-** the same as the sqlite3_total_changes() API function.
+** the same as the sqlite3_total_changes64() API function.
 */
 static void total_changes(
   sqlite3_context *context,
@@ -118137,9 +120766,9 @@ static void total_changes(
 ){
   sqlite3 *db = sqlite3_context_db_handle(context);
   UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  /* IMP: R-52756-41993 This function is a wrapper around the
-  ** sqlite3_total_changes() C/C++ interface. */
-  sqlite3_result_int(context, sqlite3_total_changes(db));
+  /* IMP: R-11217-42568 This function is a wrapper around the
+  ** sqlite3_total_changes64() C/C++ interface. */
+  sqlite3_result_int64(context, sqlite3_total_changes64(db));
 }
 
 /*
@@ -118235,7 +120864,8 @@ static int patternCompare(
       /* Skip over multiple "*" characters in the pattern.  If there
       ** are also "?" characters, skip those as well, but consume a
       ** single character of the input string for each "?" skipped */
-      while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){
+      while( (c=Utf8Read(zPattern)) == matchAll
+             || (c == matchOne && matchOne!=0) ){
         if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
           return SQLITE_NOWILDCARDMATCH;
         }
@@ -118856,10 +121486,10 @@ static void trimFunc(
 ){
   const unsigned char *zIn;         /* Input string */
   const unsigned char *zCharSet;    /* Set of characters to trim */
-  int nIn;                          /* Number of bytes in input */
+  unsigned int nIn;                 /* Number of bytes in input */
   int flags;                        /* 1: trimleft  2: trimright  3: trim */
   int i;                            /* Loop counter */
-  unsigned char *aLen = 0;          /* Length of each character in zCharSet */
+  unsigned int *aLen = 0;           /* Length of each character in zCharSet */
   unsigned char **azChar = 0;       /* Individual characters in zCharSet */
   int nChar;                        /* Number of characters in zCharSet */
 
@@ -118868,13 +121498,13 @@ static void trimFunc(
   }
   zIn = sqlite3_value_text(argv[0]);
   if( zIn==0 ) return;
-  nIn = sqlite3_value_bytes(argv[0]);
+  nIn = (unsigned)sqlite3_value_bytes(argv[0]);
   assert( zIn==sqlite3_value_text(argv[0]) );
   if( argc==1 ){
-    static const unsigned char lenOne[] = { 1 };
+    static const unsigned lenOne[] = { 1 };
     static unsigned char * const azOne[] = { (u8*)" " };
     nChar = 1;
-    aLen = (u8*)lenOne;
+    aLen = (unsigned*)lenOne;
     azChar = (unsigned char **)azOne;
     zCharSet = 0;
   }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
@@ -118885,15 +121515,16 @@ static void trimFunc(
       SQLITE_SKIP_UTF8(z);
     }
     if( nChar>0 ){
-      azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
+      azChar = contextMalloc(context,
+                     ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
       if( azChar==0 ){
         return;
       }
-      aLen = (unsigned char*)&azChar[nChar];
+      aLen = (unsigned*)&azChar[nChar];
       for(z=zCharSet, nChar=0; *z; nChar++){
         azChar[nChar] = (unsigned char *)z;
         SQLITE_SKIP_UTF8(z);
-        aLen[nChar] = (u8)(z - azChar[nChar]);
+        aLen[nChar] = (unsigned)(z - azChar[nChar]);
       }
     }
   }
@@ -118901,7 +121532,7 @@ static void trimFunc(
     flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
     if( flags & 1 ){
       while( nIn>0 ){
-        int len = 0;
+        unsigned int len = 0;
         for(i=0; i<nChar; i++){
           len = aLen[i];
           if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
@@ -118913,7 +121544,7 @@ static void trimFunc(
     }
     if( flags & 2 ){
       while( nIn>0 ){
-        int len = 0;
+        unsigned int len = 0;
         for(i=0; i<nChar; i++){
           len = aLen[i];
           if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
@@ -119254,97 +121885,167 @@ static void minMaxFinalize(sqlite3_context *context){
 
 /*
 ** group_concat(EXPR, ?SEPARATOR?)
+**
+** The SEPARATOR goes before the EXPR string.  This is tragic.  The
+** groupConcatInverse() implementation would have been easier if the
+** SEPARATOR were appended after EXPR.  And the order is undocumented,
+** so we could change it, in theory.  But the old behavior has been
+** around for so long that we dare not, for fear of breaking something.
 */
+typedef struct {
+  StrAccum str;          /* The accumulated concatenation */
+#ifndef SQLITE_OMIT_WINDOWFUNC
+  int nAccum;            /* Number of strings presently concatenated */
+  int nFirstSepLength;   /* Used to detect separator length change */
+  /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
+  ** stored as actually incorporated into presently accumulated result.
+  ** (Hence, its slots in use number nAccum-1 between method calls.)
+  ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
+  */
+  int *pnSepLengths;
+#endif
+} GroupConcatCtx;
+
 static void groupConcatStep(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
   const char *zVal;
-  StrAccum *pAccum;
+  GroupConcatCtx *pGCC;
   const char *zSep;
   int nVal, nSep;
   assert( argc==1 || argc==2 );
   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
-  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
-
-  if( pAccum ){
+  pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
+  if( pGCC ){
     sqlite3 *db = sqlite3_context_db_handle(context);
-    int firstTerm = pAccum->mxAlloc==0;
-    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
-    if( !firstTerm ){
-      if( argc==2 ){
-        zSep = (char*)sqlite3_value_text(argv[1]);
-        nSep = sqlite3_value_bytes(argv[1]);
-      }else{
-        zSep = ",";
-        nSep = 1;
+    int firstTerm = pGCC->str.mxAlloc==0;
+    pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
+    if( argc==1 ){
+      if( !firstTerm ){
+        sqlite3_str_appendchar(&pGCC->str, 1, ',');
       }
-      if( zSep ) sqlite3_str_append(pAccum, zSep, nSep);
+#ifndef SQLITE_OMIT_WINDOWFUNC
+      else{
+        pGCC->nFirstSepLength = 1;
+      }
+#endif
+    }else if( !firstTerm ){
+      zSep = (char*)sqlite3_value_text(argv[1]);
+      nSep = sqlite3_value_bytes(argv[1]);
+      if( zSep ){
+        sqlite3_str_append(&pGCC->str, zSep, nSep);
+      }
+#ifndef SQLITE_OMIT_WINDOWFUNC
+      else{
+        nSep = 0;
+      }
+      if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){
+        int *pnsl = pGCC->pnSepLengths;
+        if( pnsl == 0 ){
+          /* First separator length variation seen, start tracking them. */
+          pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int));
+          if( pnsl!=0 ){
+            int i = 0, nA = pGCC->nAccum-1;
+            while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
+          }
+        }else{
+          pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int));
+        }
+        if( pnsl!=0 ){
+          if( ALWAYS(pGCC->nAccum>0) ){
+            pnsl[pGCC->nAccum-1] = nSep;
+          }
+          pGCC->pnSepLengths = pnsl;
+        }else{
+          sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM);
+        }
+      }
+#endif
     }
+#ifndef SQLITE_OMIT_WINDOWFUNC
+    else{
+      pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]);
+    }
+    pGCC->nAccum += 1;
+#endif
     zVal = (char*)sqlite3_value_text(argv[0]);
     nVal = sqlite3_value_bytes(argv[0]);
-    if( zVal ) sqlite3_str_append(pAccum, zVal, nVal);
+    if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal);
   }
 }
+
 #ifndef SQLITE_OMIT_WINDOWFUNC
 static void groupConcatInverse(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
-  int n;
-  StrAccum *pAccum;
+  GroupConcatCtx *pGCC;
   assert( argc==1 || argc==2 );
+  (void)argc;  /* Suppress unused parameter warning */
   if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
-  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
-  /* pAccum is always non-NULL since groupConcatStep() will have always
+  pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
+  /* pGCC is always non-NULL since groupConcatStep() will have always
   ** run frist to initialize it */
-  if( ALWAYS(pAccum) ){
-    n = sqlite3_value_bytes(argv[0]);
-    if( argc==2 ){
-      n += sqlite3_value_bytes(argv[1]);
+  if( ALWAYS(pGCC) ){
+    int nVS;
+    /* Must call sqlite3_value_text() to convert the argument into text prior
+    ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
+    (void)sqlite3_value_text(argv[0]);
+    nVS = sqlite3_value_bytes(argv[0]);
+    pGCC->nAccum -= 1;
+    if( pGCC->pnSepLengths!=0 ){
+      assert(pGCC->nAccum >= 0);
+      if( pGCC->nAccum>0 ){
+        nVS += *pGCC->pnSepLengths;
+        memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
+               (pGCC->nAccum-1)*sizeof(int));
+      }
     }else{
-      n++;
+      /* If removing single accumulated string, harmlessly over-do. */
+      nVS += pGCC->nFirstSepLength;
     }
-    if( n>=(int)pAccum->nChar ){
-      pAccum->nChar = 0;
+    if( nVS>=(int)pGCC->str.nChar ){
+      pGCC->str.nChar = 0;
     }else{
-      pAccum->nChar -= n;
-      memmove(pAccum->zText, &pAccum->zText[n], pAccum->nChar);
+      pGCC->str.nChar -= nVS;
+      memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
+    }
+    if( pGCC->str.nChar==0 ){
+      pGCC->str.mxAlloc = 0;
+      sqlite3_free(pGCC->pnSepLengths);
+      pGCC->pnSepLengths = 0;
     }
-    if( pAccum->nChar==0 ) pAccum->mxAlloc = 0;
   }
 }
 #else
 # define groupConcatInverse 0
 #endif /* SQLITE_OMIT_WINDOWFUNC */
 static void groupConcatFinalize(sqlite3_context *context){
-  StrAccum *pAccum;
-  pAccum = sqlite3_aggregate_context(context, 0);
-  if( pAccum ){
-    if( pAccum->accError==SQLITE_TOOBIG ){
-      sqlite3_result_error_toobig(context);
-    }else if( pAccum->accError==SQLITE_NOMEM ){
-      sqlite3_result_error_nomem(context);
-    }else{
-      sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
-                          sqlite3_free);
-    }
+  GroupConcatCtx *pGCC
+    = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
+  if( pGCC ){
+    sqlite3ResultStrAccum(context, &pGCC->str);
+#ifndef SQLITE_OMIT_WINDOWFUNC
+    sqlite3_free(pGCC->pnSepLengths);
+#endif
   }
 }
 #ifndef SQLITE_OMIT_WINDOWFUNC
 static void groupConcatValue(sqlite3_context *context){
-  sqlite3_str *pAccum;
-  pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0);
-  if( pAccum ){
+  GroupConcatCtx *pGCC
+    = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
+  if( pGCC ){
+    StrAccum *pAccum = &pGCC->str;
     if( pAccum->accError==SQLITE_TOOBIG ){
       sqlite3_result_error_toobig(context);
     }else if( pAccum->accError==SQLITE_NOMEM ){
       sqlite3_result_error_nomem(context);
     }else{
       const char *zText = sqlite3_str_value(pAccum);
-      sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
+      sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
     }
   }
 }
@@ -119406,11 +122107,14 @@ SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive)
 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
   FuncDef *pDef;
   int nExpr;
-  if( pExpr->op!=TK_FUNCTION || !pExpr->x.pList ){
+  assert( pExpr!=0 );
+  assert( pExpr->op==TK_FUNCTION );
+  assert( ExprUseXList(pExpr) );
+  if( !pExpr->x.pList ){
     return 0;
   }
-  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
   nExpr = pExpr->x.pList->nExpr;
+  assert( !ExprHasProperty(pExpr, EP_IntValue) );
   pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
   if( pDef==0 ) return 0;
@@ -119434,6 +122138,7 @@ SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocas
     Expr *pEscape = pExpr->x.pList->a[2].pExpr;
     char *zEscape;
     if( pEscape->op!=TK_STRING ) return 0;
+    assert( !ExprHasProperty(pEscape, EP_IntValue) );
     zEscape = pEscape->u.zToken;
     if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
     if( zEscape[0]==aWc[0] ) return 0;
@@ -119445,6 +122150,201 @@ SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocas
   return 1;
 }
 
+/* Mathematical Constants */
+#ifndef M_PI
+# define M_PI   3.141592653589793238462643383279502884
+#endif
+#ifndef M_LN10
+# define M_LN10 2.302585092994045684017991454684364208
+#endif
+#ifndef M_LN2
+# define M_LN2  0.693147180559945309417232121458176568
+#endif
+
+
+/* Extra math functions that require linking with -lm
+*/
+#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
+/*
+** Implementation SQL functions:
+**
+**   ceil(X)
+**   ceiling(X)
+**   floor(X)
+**
+** The sqlite3_user_data() pointer is a pointer to the libm implementation
+** of the underlying C function.
+*/
+static void ceilingFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  assert( argc==1 );
+  switch( sqlite3_value_numeric_type(argv[0]) ){
+    case SQLITE_INTEGER: {
+       sqlite3_result_int64(context, sqlite3_value_int64(argv[0]));
+       break;
+    }
+    case SQLITE_FLOAT: {
+       double (*x)(double) = (double(*)(double))sqlite3_user_data(context);
+       sqlite3_result_double(context, x(sqlite3_value_double(argv[0])));
+       break;
+    }
+    default: {
+       break;
+    }
+  }
+}
+
+/*
+** On some systems, ceil() and floor() are intrinsic function.  You are
+** unable to take a pointer to these functions.  Hence, we here wrap them
+** in our own actual functions.
+*/
+static double xCeil(double x){ return ceil(x); }
+static double xFloor(double x){ return floor(x); }
+
+/*
+** Implementation of SQL functions:
+**
+**   ln(X)       - natural logarithm
+**   log(X)      - log X base 10
+**   log10(X)    - log X base 10
+**   log(B,X)    - log X base B
+*/
+static void logFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  double x, b, ans;
+  assert( argc==1 || argc==2 );
+  switch( sqlite3_value_numeric_type(argv[0]) ){
+    case SQLITE_INTEGER:
+    case SQLITE_FLOAT:
+      x = sqlite3_value_double(argv[0]);
+      if( x<=0.0 ) return;
+      break;
+    default:
+      return;
+  }
+  if( argc==2 ){
+    switch( sqlite3_value_numeric_type(argv[0]) ){
+      case SQLITE_INTEGER:
+      case SQLITE_FLOAT:
+        b = log(x);
+        if( b<=0.0 ) return;
+        x = sqlite3_value_double(argv[1]);
+        if( x<=0.0 ) return;
+        break;
+     default:
+        return;
+    }
+    ans = log(x)/b;
+  }else{
+    ans = log(x);
+    switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){
+      case 1:
+        /* Convert from natural logarithm to log base 10 */
+        ans *= 1.0/M_LN10;
+        break;
+      case 2:
+        /* Convert from natural logarithm to log base 2 */
+        ans *= 1.0/M_LN2;
+        break;
+      default:
+        break;
+    }
+  }
+  sqlite3_result_double(context, ans);
+}
+
+/*
+** Functions to converts degrees to radians and radians to degrees.
+*/
+static double degToRad(double x){ return x*(M_PI/180.0); }
+static double radToDeg(double x){ return x*(180.0/M_PI); }
+
+/*
+** Implementation of 1-argument SQL math functions:
+**
+**   exp(X)  - Compute e to the X-th power
+*/
+static void math1Func(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int type0;
+  double v0, ans;
+  double (*x)(double);
+  assert( argc==1 );
+  type0 = sqlite3_value_numeric_type(argv[0]);
+  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
+  v0 = sqlite3_value_double(argv[0]);
+  x = (double(*)(double))sqlite3_user_data(context);
+  ans = x(v0);
+  sqlite3_result_double(context, ans);
+}
+
+/*
+** Implementation of 2-argument SQL math functions:
+**
+**   power(X,Y)  - Compute X to the Y-th power
+*/
+static void math2Func(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int type0, type1;
+  double v0, v1, ans;
+  double (*x)(double,double);
+  assert( argc==2 );
+  type0 = sqlite3_value_numeric_type(argv[0]);
+  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
+  type1 = sqlite3_value_numeric_type(argv[1]);
+  if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return;
+  v0 = sqlite3_value_double(argv[0]);
+  v1 = sqlite3_value_double(argv[1]);
+  x = (double(*)(double,double))sqlite3_user_data(context);
+  ans = x(v0, v1);
+  sqlite3_result_double(context, ans);
+}
+
+/*
+** Implementation of 0-argument pi() function.
+*/
+static void piFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  assert( argc==0 );
+  sqlite3_result_double(context, M_PI);
+}
+
+#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
+
+/*
+** Implementation of sign(X) function.
+*/
+static void signFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  int type0;
+  double x;
+  UNUSED_PARAMETER(argc);
+  assert( argc==1 );
+  type0 = sqlite3_value_numeric_type(argv[0]);
+  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
+  x = sqlite3_value_double(argv[0]);
+  sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
+}
+
 /*
 ** All of the FuncDef structures in the aBuiltinFunc[] array above
 ** to the global function hash table.  This occurs at start-time (as
@@ -119465,12 +122365,12 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
   */
   static FuncDef aBuiltinFunc[] = {
 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
+#if !defined(SQLITE_UNTESTABLE)
     TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0),
     TEST_FUNC(expr_compare,        2, INLINEFUNC_expr_compare,        0),
     TEST_FUNC(expr_implies_expr,   2, INLINEFUNC_expr_implies_expr,   0),
-#ifdef SQLITE_DEBUG
-    TEST_FUNC(affinity,          1, INLINEFUNC_affinity, 0),
-#endif
+    TEST_FUNC(affinity,            1, INLINEFUNC_affinity,            0),
+#endif /* !defined(SQLITE_UNTESTABLE) */
 /***** Regular functions *****/
 #ifdef SQLITE_SOUNDEX
     FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
@@ -119502,11 +122402,11 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
     FUNCTION(min,                0, 0, 1, 0                ),
     WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
-                                          SQLITE_FUNC_MINMAX ),
+                                 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
     FUNCTION(max,                0, 1, 1, 0                ),
     WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
-                                          SQLITE_FUNC_MINMAX ),
+                                 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
     FUNCTION(instr,              2, 0, 0, instrFunc        ),
@@ -119542,9 +122442,10 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
     WAGGREGATE(avg,   1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
     WAGGREGATE(count, 0,0,0, countStep,
-        countFinalize, countFinalize, countInverse, SQLITE_FUNC_COUNT  ),
+        countFinalize, countFinalize, countInverse,
+        SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER  ),
     WAGGREGATE(count, 1,0,0, countStep,
-        countFinalize, countFinalize, countInverse, 0  ),
+        countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ),
     WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
         groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
     WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
@@ -119563,6 +122464,43 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
 #endif
     FUNCTION(coalesce,           1, 0, 0, 0                ),
     FUNCTION(coalesce,           0, 0, 0, 0                ),
+#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
+    MFUNCTION(ceil,              1, xCeil,     ceilingFunc ),
+    MFUNCTION(ceiling,           1, xCeil,     ceilingFunc ),
+    MFUNCTION(floor,             1, xFloor,    ceilingFunc ),
+#if SQLITE_HAVE_C99_MATH_FUNCS
+    MFUNCTION(trunc,             1, trunc,     ceilingFunc ),
+#endif
+    FUNCTION(ln,                 1, 0, 0,      logFunc     ),
+    FUNCTION(log,                1, 1, 0,      logFunc     ),
+    FUNCTION(log10,              1, 1, 0,      logFunc     ),
+    FUNCTION(log2,               1, 2, 0,      logFunc     ),
+    FUNCTION(log,                2, 0, 0,      logFunc     ),
+    MFUNCTION(exp,               1, exp,       math1Func   ),
+    MFUNCTION(pow,               2, pow,       math2Func   ),
+    MFUNCTION(power,             2, pow,       math2Func   ),
+    MFUNCTION(mod,               2, fmod,      math2Func   ),
+    MFUNCTION(acos,              1, acos,      math1Func   ),
+    MFUNCTION(asin,              1, asin,      math1Func   ),
+    MFUNCTION(atan,              1, atan,      math1Func   ),
+    MFUNCTION(atan2,             2, atan2,     math2Func   ),
+    MFUNCTION(cos,               1, cos,       math1Func   ),
+    MFUNCTION(sin,               1, sin,       math1Func   ),
+    MFUNCTION(tan,               1, tan,       math1Func   ),
+    MFUNCTION(cosh,              1, cosh,      math1Func   ),
+    MFUNCTION(sinh,              1, sinh,      math1Func   ),
+    MFUNCTION(tanh,              1, tanh,      math1Func   ),
+#if SQLITE_HAVE_C99_MATH_FUNCS
+    MFUNCTION(acosh,             1, acosh,     math1Func   ),
+    MFUNCTION(asinh,             1, asinh,     math1Func   ),
+    MFUNCTION(atanh,             1, atanh,     math1Func   ),
+#endif
+    MFUNCTION(sqrt,              1, sqrt,      math1Func   ),
+    MFUNCTION(radians,           1, degToRad,  math1Func   ),
+    MFUNCTION(degrees,           1, radToDeg,  math1Func   ),
+    FUNCTION(pi,                 0, 0, 0,      piFunc      ),
+#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
+    FUNCTION(sign,               1, 0, 0,      signFunc    ),
     INLINE_FUNC(coalesce,       -1, INLINEFUNC_coalesce, 0 ),
     INLINE_FUNC(iif,             3, INLINEFUNC_iif,      0 ),
   };
@@ -119582,6 +122520,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
         int n = sqlite3Strlen30(p->zName);
         int h = p->zName[0] + n;
+        assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
         printf(" %s(%d)", p->zName, h);
       }
       printf("\n");
@@ -119809,7 +122748,9 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex(
     */
     if( pParent->iPKey>=0 ){
       if( !zKey ) return 0;
-      if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
+      if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zCnName, zKey) ){
+        return 0;
+      }
     }
   }else if( paiCol ){
     assert( nCol>1 );
@@ -119851,11 +122792,11 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex(
           /* If the index uses a collation sequence that is different from
           ** the default collation sequence for the column, this index is
           ** unusable. Bail out early in this case.  */
-          zDfltColl = pParent->aCol[iCol].zColl;
+          zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
           if( !zDfltColl ) zDfltColl = sqlite3StrBINARY;
           if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
 
-          zIdxCol = pParent->aCol[iCol].zName;
+          zIdxCol = pParent->aCol[iCol].zCnName;
           for(j=0; j<nCol; j++){
             if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){
               if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;
@@ -120079,7 +123020,7 @@ static Expr *exprTableRegister(
       pCol = &pTab->aCol[iCol];
       pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
       pExpr->affExpr = pCol->affinity;
-      zColl = pCol->zColl;
+      zColl = sqlite3ColumnColl(pCol);
       if( zColl==0 ) zColl = db->pDfltColl->zName;
       pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
     }else{
@@ -120102,6 +123043,7 @@ static Expr *exprTableColumn(
 ){
   Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
   if( pExpr ){
+    assert( ExprUseYTab(pExpr) );
     pExpr->y.pTab = pTab;
     pExpr->iTable = iCursor;
     pExpr->iColumn = iCol;
@@ -120188,7 +123130,7 @@ static void fkScanChildren(
     pLeft = exprTableRegister(pParse, pTab, regData, iCol);
     iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
     assert( iCol>=0 );
-    zCol = pFKey->pFrom->aCol[iCol].zName;
+    zCol = pFKey->pFrom->aCol[iCol].zCnName;
     pRight = sqlite3Expr(db, TK_ID, zCol);
     pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight);
     pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
@@ -120223,7 +123165,7 @@ static void fkScanChildren(
         i16 iCol = pIdx->aiColumn[i];
         assert( iCol>=0 );
         pLeft = exprTableRegister(pParse, pTab, regData, iCol);
-        pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName);
+        pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
         pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight);
         pAll = sqlite3ExprAnd(pParse, pAll, pEq);
       }
@@ -120312,12 +123254,12 @@ static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
 */
 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
   sqlite3 *db = pParse->db;
-  if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) ){
+  if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){
     int iSkip = 0;
     Vdbe *v = sqlite3GetVdbe(pParse);
 
     assert( v );                  /* VDBE has already been allocated */
-    assert( pTab->pSelect==0 );   /* Not a view */
+    assert( IsOrdinaryTable(pTab) );
     if( sqlite3FkReferences(pTab)==0 ){
       /* Search for a deferred foreign key constraint for which this table
       ** is the child table. If one cannot be found, return without
@@ -120325,7 +123267,7 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa
       ** the entire DELETE if there are no outstanding deferred constraints
       ** when this statement is run.  */
       FKey *p;
-      for(p=pTab->pFKey; p; p=p->pNextFrom){
+      for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
         if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
       }
       if( !p ) return;
@@ -120414,7 +123356,7 @@ static int fkParentIsModified(
       if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){
         Column *pCol = &pTab->aCol[iKey];
         if( zKey ){
-          if( 0==sqlite3StrICmp(pCol->zName, zKey) ) return 1;
+          if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1;
         }else if( pCol->colFlags & COLFLAG_PRIMKEY ){
           return 1;
         }
@@ -120481,13 +123423,14 @@ SQLITE_PRIVATE void sqlite3FkCheck(
 
   /* If foreign-keys are disabled, this function is a no-op. */
   if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
+  if( !IsOrdinaryTable(pTab) ) return;
 
   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
   zDb = db->aDb[iDb].zDbSName;
 
   /* Loop through all the foreign key constraints for which pTab is the
   ** child table (the table that the foreign key definition is part of).  */
-  for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
+  for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
     Table *pTo;                   /* Parent table of foreign key pFKey */
     Index *pIdx = 0;              /* Index on key columns in pTo */
     int *aiFree = 0;
@@ -120554,7 +123497,7 @@ SQLITE_PRIVATE void sqlite3FkCheck(
       ** values read from the parent table are NULL. */
       if( db->xAuth ){
         int rcauth;
-        char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
+        char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName;
         rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
         bIgnore = (rcauth==SQLITE_IGNORE);
       }
@@ -120618,7 +123561,7 @@ SQLITE_PRIVATE void sqlite3FkCheck(
     ** child table as a SrcList for sqlite3WhereBegin() */
     pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
     if( pSrc ){
-      struct SrcList_item *pItem = pSrc->a;
+      SrcItem *pItem = pSrc->a;
       pItem->pTab = pFKey->pFrom;
       pItem->zName = pFKey->pFrom->zName;
       pItem->pTab->nTabRef++;
@@ -120669,10 +123612,10 @@ SQLITE_PRIVATE u32 sqlite3FkOldmask(
   Table *pTab                     /* Table being modified */
 ){
   u32 mask = 0;
-  if( pParse->db->flags&SQLITE_ForeignKeys ){
+  if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
     FKey *p;
     int i;
-    for(p=pTab->pFKey; p; p=p->pNextFrom){
+    for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
       for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
     }
     for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
@@ -120706,7 +123649,9 @@ SQLITE_PRIVATE u32 sqlite3FkOldmask(
 **
 ** For an UPDATE, this function returns 2 if:
 **
-**   * There are any FKs for which pTab is the child and the parent table, or
+**   * There are any FKs for which pTab is the child and the parent table
+**     and any FK processing at all is required (even of a different FK), or
+**
 **   * the UPDATE modifies one or more parent keys for which the action is
 **     not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL).
 **
@@ -120718,23 +123663,24 @@ SQLITE_PRIVATE int sqlite3FkRequired(
   int *aChange,                   /* Non-NULL for UPDATE operations */
   int chngRowid                   /* True for UPDATE that affects rowid */
 ){
-  int eRet = 0;
-  if( pParse->db->flags&SQLITE_ForeignKeys ){
+  int eRet = 1;                   /* Value to return if bHaveFK is true */
+  int bHaveFK = 0;                /* If FK processing is required */
+  if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
     if( !aChange ){
       /* A DELETE operation. Foreign key processing is required if the
       ** table in question is either the child or parent table for any
       ** foreign key constraint.  */
-      eRet = (sqlite3FkReferences(pTab) || pTab->pFKey);
+      bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey);
     }else{
       /* This is an UPDATE. Foreign key processing is only required if the
       ** operation modifies one or more child or parent key columns. */
       FKey *p;
 
       /* Check if any child key columns are being modified. */
-      for(p=pTab->pFKey; p; p=p->pNextFrom){
-        if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2;
+      for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){
         if( fkChildIsModified(pTab, p, aChange, chngRowid) ){
-          eRet = 1;
+          if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2;
+          bHaveFK = 1;
         }
       }
 
@@ -120742,12 +123688,12 @@ SQLITE_PRIVATE int sqlite3FkRequired(
       for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
         if( fkParentIsModified(pTab, p, aChange, chngRowid) ){
           if( p->aAction[1]!=OE_None ) return 2;
-          eRet = 1;
+          bHaveFK = 1;
         }
       }
     }
   }
-  return eRet;
+  return bHaveFK ? eRet : 0;
 }
 
 /*
@@ -120824,8 +123770,8 @@ static Trigger *fkActionTrigger(
       assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
       assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
       sqlite3TokenInit(&tToCol,
-                   pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName);
-      sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName);
+                   pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName);
+      sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName);
 
       /* Create the expression "OLD.zToCol = zFromCol". It is important
       ** that the "OLD.zToCol" term is on the LHS of the = operator, so
@@ -120870,7 +123816,7 @@ static Trigger *fkActionTrigger(
             testcase( pCol->colFlags & COLFLAG_STORED );
             pDflt = 0;
           }else{
-            pDflt = pCol->pDflt;
+            pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol);
           }
           if( pDflt ){
             pNew = sqlite3ExprDup(db, pDflt, 0);
@@ -121007,9 +123953,9 @@ SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
   FKey *pFKey;                    /* Iterator variable */
   FKey *pNext;                    /* Copy of pFKey->pNextFrom */
 
-  assert( db==0 || IsVirtual(pTab)
-         || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
-  for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
+  assert( IsOrdinaryTable(pTab) );
+  for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){
+    assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
 
     /* Remove the FK from the fkeyHash hash table. */
     if( !db || db->pnBytesFreed==0 ){
@@ -121156,28 +124102,68 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
 }
 
 /*
+** Make changes to the evolving bytecode to do affinity transformations
+** of values that are about to be gathered into a row for table pTab.
+**
+** For ordinary (legacy, non-strict) tables:
+** -----------------------------------------
+**
 ** Compute the affinity string for table pTab, if it has not already been
 ** computed.  As an optimization, omit trailing SQLITE_AFF_BLOB affinities.
 **
-** If the affinity exists (if it is no entirely SQLITE_AFF_BLOB values) and
-** if iReg>0 then code an OP_Affinity opcode that will set the affinities
-** for register iReg and following.  Or if affinities exists and iReg==0,
+** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries
+** which were then optimized out) then this routine becomes a no-op.
+**
+** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
+** affinities for register iReg and following.  Or if iReg==0,
 ** then just set the P4 operand of the previous opcode (which should  be
 ** an OP_MakeRecord) to the affinity string.
 **
 ** A column affinity string has one character per column:
 **
-**  Character      Column affinity
-**  ------------------------------
-**  'A'            BLOB
-**  'B'            TEXT
-**  'C'            NUMERIC
-**  'D'            INTEGER
-**  'E'            REAL
+**    Character      Column affinity
+**    ---------      ---------------
+**    'A'            BLOB
+**    'B'            TEXT
+**    'C'            NUMERIC
+**    'D'            INTEGER
+**    'E'            REAL
+**
+** For STRICT tables:
+** ------------------
+**
+** Generate an appropropriate OP_TypeCheck opcode that will verify the
+** datatypes against the column definitions in pTab.  If iReg==0, that
+** means an OP_MakeRecord opcode has already been generated and should be
+** the last opcode generated.  The new OP_TypeCheck needs to be inserted
+** before the OP_MakeRecord.  The new OP_TypeCheck should use the same
+** register set as the OP_MakeRecord.  If iReg>0 then register iReg is
+** the first of a series of registers that will form the new record.
+** Apply the type checking to that array of registers.
 */
 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
   int i, j;
-  char *zColAff = pTab->zColAff;
+  char *zColAff;
+  if( pTab->tabFlags & TF_Strict ){
+    if( iReg==0 ){
+      /* Move the previous opcode (which should be OP_MakeRecord) forward
+      ** by one slot and insert a new OP_TypeCheck where the current
+      ** OP_MakeRecord is found */
+      VdbeOp *pPrev;
+      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
+      pPrev = sqlite3VdbeGetOp(v, -1);
+      assert( pPrev!=0 );
+      assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
+      pPrev->opcode = OP_TypeCheck;
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);
+    }else{
+      /* Insert an isolated OP_Typecheck */
+      sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
+      sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
+    }
+    return;
+  }
+  zColAff = pTab->zColAff;
   if( zColAff==0 ){
     sqlite3 *db = sqlite3VdbeDb(v);
     zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
@@ -121203,6 +124189,8 @@ SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
     if( iReg ){
       sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
     }else{
+      assert( sqlite3VdbeGetOp(v, -1)->opcode==OP_MakeRecord
+              || sqlite3VdbeDb(v)->mallocFailed );
       sqlite3VdbeChangeP4(v, -1, zColAff, i);
     }
   }
@@ -121286,24 +124274,30 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(
   ** that appropriate affinity has been applied to the regular columns
   */
   sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
-  if( (pTab->tabFlags & TF_HasStored)!=0
-   && (pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1))->opcode==OP_Affinity
-  ){
-    /* Change the OP_Affinity argument to '@' (NONE) for all stored
-    ** columns.  '@' is the no-op affinity and those columns have not
-    ** yet been computed. */
-    int ii, jj;
-    char *zP4 = pOp->p4.z;
-    assert( zP4!=0 );
-    assert( pOp->p4type==P4_DYNAMIC );
-    for(ii=jj=0; zP4[jj]; ii++){
-      if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
-        continue;
-      }
-      if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
-        zP4[jj] = SQLITE_AFF_NONE;
+  if( (pTab->tabFlags & TF_HasStored)!=0 ){
+    pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1);
+    if( pOp->opcode==OP_Affinity ){
+      /* Change the OP_Affinity argument to '@' (NONE) for all stored
+      ** columns.  '@' is the no-op affinity and those columns have not
+      ** yet been computed. */
+      int ii, jj;
+      char *zP4 = pOp->p4.z;
+      assert( zP4!=0 );
+      assert( pOp->p4type==P4_DYNAMIC );
+      for(ii=jj=0; zP4[jj]; ii++){
+        if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){
+          continue;
+        }
+        if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){
+          zP4[jj] = SQLITE_AFF_NONE;
+        }
+        jj++;
       }
-      jj++;
+    }else if( pOp->opcode==OP_TypeCheck ){
+      /* If an OP_TypeCheck was generated because the table is STRICT,
+      ** then set the P3 operand to indicate that generated columns should
+      ** not be checked */
+      pOp->p3 = 1;
     }
   }
 
@@ -121339,7 +124333,7 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(
         int x;
         pCol->colFlags |= COLFLAG_BUSY;
         w.eCode = 0;
-        sqlite3WalkExpr(&w, pCol->pDflt);
+        sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol));
         pCol->colFlags &= ~COLFLAG_BUSY;
         if( w.eCode & COLFLAG_NOTAVAIL ){
           pRedo = pCol;
@@ -121348,13 +124342,13 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(
         eProgress = 1;
         assert( pCol->colFlags & COLFLAG_GENERATED );
         x = sqlite3TableColumnToStorage(pTab, i) + iRegStore;
-        sqlite3ExprCodeGeneratedColumn(pParse, pCol, x);
+        sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x);
         pCol->colFlags &= ~COLFLAG_NOTAVAIL;
       }
     }
   }while( pRedo && eProgress );
   if( pRedo ){
-    sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zName);
+    sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName);
   }
   pParse->iSelfTab = 0;
 }
@@ -121404,7 +124398,7 @@ static int autoIncBegin(
     ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
     if( pSeqTab==0
      || !HasRowid(pSeqTab)
-     || IsVirtual(pSeqTab)
+     || NEVER(IsVirtual(pSeqTab))
      || pSeqTab->nCol!=2
     ){
       pParse->nErr++;
@@ -121416,7 +124410,9 @@ static int autoIncBegin(
     while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
     if( pInfo==0 ){
       pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
-      if( pInfo==0 ) return 0;
+      sqlite3ParserAddCleanup(pToplevel, sqlite3DbFree, pInfo);
+      testcase( pParse->earlyCleanup );
+      if( pParse->db->mallocFailed ) return 0;
       pInfo->pNext = pToplevel->pAinc;
       pToplevel->pAinc = pInfo;
       pInfo->pTab = pTab;
@@ -121747,7 +124743,7 @@ SQLITE_PRIVATE void sqlite3Insert(
   */
 #ifndef SQLITE_OMIT_TRIGGER
   pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
-  isView = pTab->pSelect!=0;
+  isView = IsView(pTab);
 #else
 # define pTrigger 0
 # define tmask 0
@@ -121838,7 +124834,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     }
     for(i=0; i<pColumn->nId; i++){
       for(j=0; j<pTab->nCol; j++){
-        if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
+        if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){
           pColumn->a[i].idx = j;
           if( i!=j ) bIdListInOrder = 0;
           if( j==pTab->iPKey ){
@@ -121848,7 +124844,7 @@ SQLITE_PRIVATE void sqlite3Insert(
           if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){
             sqlite3ErrorMsg(pParse,
                "cannot INSERT into generated column \"%s\"",
-               pTab->aCol[j].zName);
+               pTab->aCol[j].zCnName);
             goto insert_cleanup;
           }
 #endif
@@ -121861,7 +124857,7 @@ SQLITE_PRIVATE void sqlite3Insert(
           bIdListInOrder = 0;
         }else{
           sqlite3ErrorMsg(pParse, "table %S has no column named %s",
-              pTabList, 0, pColumn->a[i].zName);
+              pTabList->a, pColumn->a[i].zName);
           pParse->checkSchema = 1;
           goto insert_cleanup;
         }
@@ -121974,19 +124970,24 @@ SQLITE_PRIVATE void sqlite3Insert(
       }
     }
 #endif
-  }
 
-  /* Make sure the number of columns in the source data matches the number
-  ** of columns to be inserted into the table.
-  */
-  for(i=0; i<pTab->nCol; i++){
-    if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
-  }
-  if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
-    sqlite3ErrorMsg(pParse,
-       "table %S has %d columns but %d values were supplied",
-       pTabList, 0, pTab->nCol-nHidden, nColumn);
-    goto insert_cleanup;
+    /* Make sure the number of columns in the source data matches the number
+    ** of columns to be inserted into the table.
+    */
+    assert( TF_HasHidden==COLFLAG_HIDDEN );
+    assert( TF_HasGenerated==COLFLAG_GENERATED );
+    assert( COLFLAG_NOINSERT==(COLFLAG_GENERATED|COLFLAG_HIDDEN) );
+    if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){
+      for(i=0; i<pTab->nCol; i++){
+        if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++;
+      }
+    }
+    if( nColumn!=(pTab->nCol-nHidden) ){
+      sqlite3ErrorMsg(pParse,
+         "table %S has %d columns but %d values were supplied",
+         pTabList->a, pTab->nCol-nHidden, nColumn);
+     goto insert_cleanup;
+    }
   }
   if( pColumn!=0 && nColumn!=pColumn->nId ){
     sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
@@ -121998,6 +124999,7 @@ SQLITE_PRIVATE void sqlite3Insert(
   if( (db->flags & SQLITE_CountRows)!=0
    && !pParse->nested
    && !pParse->pTriggerTab
+   && !pParse->bReturning
   ){
     regRowCount = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
@@ -122021,12 +125023,13 @@ SQLITE_PRIVATE void sqlite3Insert(
   }
 #ifndef SQLITE_OMIT_UPSERT
   if( pUpsert ){
+    Upsert *pNx;
     if( IsVirtual(pTab) ){
       sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
               pTab->zName);
       goto insert_cleanup;
     }
-    if( pTab->pSelect ){
+    if( IsView(pTab) ){
       sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
       goto insert_cleanup;
     }
@@ -122034,13 +125037,19 @@ SQLITE_PRIVATE void sqlite3Insert(
       goto insert_cleanup;
     }
     pTabList->a[0].iCursor = iDataCur;
-    pUpsert->pUpsertSrc = pTabList;
-    pUpsert->regData = regData;
-    pUpsert->iDataCur = iDataCur;
-    pUpsert->iIdxCur = iIdxCur;
-    if( pUpsert->pUpsertTarget ){
-      sqlite3UpsertAnalyzeTarget(pParse, pTabList, pUpsert);
-    }
+    pNx = pUpsert;
+    do{
+      pNx->pUpsertSrc = pTabList;
+      pNx->regData = regData;
+      pNx->iDataCur = iDataCur;
+      pNx->iIdxCur = iIdxCur;
+      if( pNx->pUpsertTarget ){
+        if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx) ){
+          goto insert_cleanup;
+        }
+      }
+      pNx = pNx->pNextUpsert;
+    }while( pNx!=0 );
   }
 #endif
 
@@ -122119,7 +125128,9 @@ SQLITE_PRIVATE void sqlite3Insert(
       }else if( pColumn==0 ){
         /* Hidden columns that are not explicitly named in the INSERT
         ** get there default value */
-        sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
+        sqlite3ExprCodeFactorable(pParse,
+            sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
+            iRegStore);
         continue;
       }
     }
@@ -122128,13 +125139,17 @@ SQLITE_PRIVATE void sqlite3Insert(
       if( j>=pColumn->nId ){
         /* A column not named in the insert column list gets its
         ** default value */
-        sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
+        sqlite3ExprCodeFactorable(pParse,
+            sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
+            iRegStore);
         continue;
       }
       k = j;
     }else if( nColumn==0 ){
       /* This is INSERT INTO ... DEFAULT VALUES.  Load the default value. */
-      sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
+      sqlite3ExprCodeFactorable(pParse,
+          sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
+          iRegStore);
       continue;
     }else{
       k = i - nHidden;
@@ -122181,11 +125196,6 @@ SQLITE_PRIVATE void sqlite3Insert(
       sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
     }
 
-    /* Cannot have triggers on a virtual table. If it were possible,
-    ** this block would have to account for hidden column.
-    */
-    assert( !IsVirtual(pTab) );
-
     /* Copy the new data already generated. */
     assert( pTab->nNVCol>0 );
     sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
@@ -122284,7 +125294,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     }else
 #endif
     {
-      int isReplace;    /* Set to true if constraints may cause a replace */
+      int isReplace = 0;/* Set to true if constraints may cause a replace */
       int bUseSeek;     /* True to use OPFLAG_SEEKRESULT */
       sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
           regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert
@@ -122304,6 +125314,13 @@ SQLITE_PRIVATE void sqlite3Insert(
           regIns, aRegIdx, 0, appendFlag, bUseSeek
       );
     }
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+  }else if( pParse->bReturning ){
+    /* If there is a RETURNING clause, populate the rowid register with
+    ** constant value -1, in case one or more of the returned expressions
+    ** refer to the "rowid" of the view.  */
+    sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
+#endif
   }
 
   /* Update the count of rows that are inserted
@@ -122340,7 +125357,9 @@ SQLITE_PRIVATE void sqlite3Insert(
     sqlite3VdbeJumpHere(v, addrInsTop);
   }
 
+#ifndef SQLITE_OMIT_XFER_OPT
 insert_end:
+#endif /* SQLITE_OMIT_XFER_OPT */
   /* Update the sqlite_sequence table by storing the content of the
   ** maximum rowid counter values recorded while inserting into
   ** autoincrement tables.
@@ -122355,7 +125374,7 @@ SQLITE_PRIVATE void sqlite3Insert(
   ** invoke the callback function.
   */
   if( regRowCount ){
-    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
+    sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
   }
@@ -122445,6 +125464,70 @@ SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
   return w.eCode!=0;
 }
 
+/*
+** The sqlite3GenerateConstraintChecks() routine usually wants to visit
+** the indexes of a table in the order provided in the Table->pIndex list.
+** However, sometimes (rarely - when there is an upsert) it wants to visit
+** the indexes in a different order.  The following data structures accomplish
+** this.
+**
+** The IndexIterator object is used to walk through all of the indexes
+** of a table in either Index.pNext order, or in some other order established
+** by an array of IndexListTerm objects.
+*/
+typedef struct IndexListTerm IndexListTerm;
+typedef struct IndexIterator IndexIterator;
+struct IndexIterator {
+  int eType;    /* 0 for Index.pNext list.  1 for an array of IndexListTerm */
+  int i;        /* Index of the current item from the list */
+  union {
+    struct {    /* Use this object for eType==0: A Index.pNext list */
+      Index *pIdx;   /* The current Index */
+    } lx;
+    struct {    /* Use this object for eType==1; Array of IndexListTerm */
+      int nIdx;               /* Size of the array */
+      IndexListTerm *aIdx;    /* Array of IndexListTerms */
+    } ax;
+  } u;
+};
+
+/* When IndexIterator.eType==1, then each index is an array of instances
+** of the following object
+*/
+struct IndexListTerm {
+  Index *p;  /* The index */
+  int ix;    /* Which entry in the original Table.pIndex list is this index*/
+};
+
+/* Return the first index on the list */
+static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
+  assert( pIter->i==0 );
+  if( pIter->eType ){
+    *pIx = pIter->u.ax.aIdx[0].ix;
+    return pIter->u.ax.aIdx[0].p;
+  }else{
+    *pIx = 0;
+    return pIter->u.lx.pIdx;
+  }
+}
+
+/* Return the next index from the list.  Return NULL when out of indexes */
+static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
+  if( pIter->eType ){
+    int i = ++pIter->i;
+    if( i>=pIter->u.ax.nIdx ){
+      *pIx = i;
+      return 0;
+    }
+    *pIx = pIter->u.ax.aIdx[i].ix;
+    return pIter->u.ax.aIdx[i].p;
+  }else{
+    ++(*pIx);
+    pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
+    return pIter->u.lx.pIdx;
+  }
+}
+
 /*
 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
 ** on table pTab.
@@ -122553,7 +125636,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
 ){
   Vdbe *v;             /* VDBE under constrution */
   Index *pIdx;         /* Pointer to one of the indices */
-  Index *pPk = 0;      /* The PRIMARY KEY index */
+  Index *pPk = 0;      /* The PRIMARY KEY index for WITHOUT ROWID tables */
   sqlite3 *db;         /* Database connection */
   int i;               /* loop counter */
   int ix;              /* Index loop counter */
@@ -122561,11 +125644,11 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   int onError;         /* Conflict resolution strategy */
   int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
   int nPkField;        /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
-  Index *pUpIdx = 0;   /* Index to which to apply the upsert */
-  u8 isUpdate;         /* True if this is an UPDATE operation */
+  Upsert *pUpsertClause = 0;  /* The specific ON CONFLICT clause for pIdx */
+  u8 isUpdate;           /* True if this is an UPDATE operation */
   u8 bAffinityDone = 0;  /* True if the OP_Affinity operation has been run */
-  int upsertBypass = 0;  /* Address of Goto to bypass upsert subroutine */
-  int upsertJump = 0;    /* Address of Goto that jumps into upsert subroutine */
+  int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */
+  int upsertIpkDelay = 0;  /* Address of Goto to bypass initial IPK check */
   int ipkTop = 0;        /* Top of the IPK uniqueness check */
   int ipkBottom = 0;     /* OP_Goto at the end of the IPK uniqueness check */
   /* Variables associated with retesting uniqueness constraints after
@@ -122575,12 +125658,13 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */
   Trigger *pTrigger;    /* List of DELETE triggers on the table pTab */
   int nReplaceTrig = 0; /* Number of replace triggers coded */
+  IndexIterator sIdxIter;  /* Index iterator */
 
   isUpdate = regOldData!=0;
   db = pParse->db;
   v = pParse->pVdbe;
   assert( v!=0 );
-  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
+  assert( !IsView(pTab) );  /* This table is not a VIEW */
   nCol = pTab->nCol;
 
   /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
@@ -122631,7 +125715,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         }
         if( onError==OE_Replace ){
           if( b2ndPass        /* REPLACE becomes ABORT on the 2nd pass */
-           || pCol->pDflt==0  /* REPLACE is ABORT if no DEFAULT value */
+           || pCol->iDflt==0  /* REPLACE is ABORT if no DEFAULT value */
           ){
             testcase( pCol->colFlags & COLFLAG_VIRTUAL );
             testcase( pCol->colFlags & COLFLAG_STORED );
@@ -122653,7 +125737,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
             VdbeCoverage(v);
             assert( (pCol->colFlags & COLFLAG_GENERATED)==0 );
             nSeenReplace++;
-            sqlite3ExprCodeCopy(pParse, pCol->pDflt, iReg);
+            sqlite3ExprCodeCopy(pParse,
+               sqlite3ColumnExpr(pTab, pCol), iReg);
             sqlite3VdbeJumpHere(v, addr1);
             break;
           }
@@ -122663,7 +125748,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
           case OE_Rollback:
           case OE_Fail: {
             char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
-                                        pCol->zName);
+                                        pCol->zCnName);
             sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
                               onError, iReg);
             sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
@@ -122772,19 +125857,63 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   ** list of indexes attached to a table puts all OE_Replace indexes last
   ** in the list.  See sqlite3CreateIndex() for where that happens.
   */
-
+  sIdxIter.eType = 0;
+  sIdxIter.i = 0;
+  sIdxIter.u.ax.aIdx = 0;  /* Silence harmless compiler warning */
+  sIdxIter.u.lx.pIdx = pTab->pIndex;
   if( pUpsert ){
     if( pUpsert->pUpsertTarget==0 ){
-      /* An ON CONFLICT DO NOTHING clause, without a constraint-target.
-      ** Make all unique constraint resolution be OE_Ignore */
-      assert( pUpsert->pUpsertSet==0 );
-      overrideError = OE_Ignore;
-      pUpsert = 0;
-    }else if( (pUpIdx = pUpsert->pUpsertIdx)!=0 ){
-      /* If the constraint-target uniqueness check must be run first.
-      ** Jump to that uniqueness check now */
-      upsertJump = sqlite3VdbeAddOp0(v, OP_Goto);
-      VdbeComment((v, "UPSERT constraint goes first"));
+      /* There is just on ON CONFLICT clause and it has no constraint-target */
+      assert( pUpsert->pNextUpsert==0 );
+      if( pUpsert->isDoUpdate==0 ){
+        /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
+        ** Make all unique constraint resolution be OE_Ignore */
+        overrideError = OE_Ignore;
+        pUpsert = 0;
+      }else{
+        /* A single ON CONFLICT DO UPDATE.  Make all resolutions OE_Update */
+        overrideError = OE_Update;
+      }
+    }else if( pTab->pIndex!=0 ){
+      /* Otherwise, we'll need to run the IndexListTerm array version of the
+      ** iterator to ensure that all of the ON CONFLICT conditions are
+      ** checked first and in order. */
+      int nIdx, jj;
+      u64 nByte;
+      Upsert *pTerm;
+      u8 *bUsed;
+      for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
+         assert( aRegIdx[nIdx]>0 );
+      }
+      sIdxIter.eType = 1;
+      sIdxIter.u.ax.nIdx = nIdx;
+      nByte = (sizeof(IndexListTerm)+1)*nIdx + nIdx;
+      sIdxIter.u.ax.aIdx = sqlite3DbMallocZero(db, nByte);
+      if( sIdxIter.u.ax.aIdx==0 ) return; /* OOM */
+      bUsed = (u8*)&sIdxIter.u.ax.aIdx[nIdx];
+      pUpsert->pToFree = sIdxIter.u.ax.aIdx;
+      for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){
+        if( pTerm->pUpsertTarget==0 ) break;
+        if( pTerm->pUpsertIdx==0 ) continue;  /* Skip ON CONFLICT for the IPK */
+        jj = 0;
+        pIdx = pTab->pIndex;
+        while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
+           pIdx = pIdx->pNext;
+           jj++;
+        }
+        if( bUsed[jj] ) continue; /* Duplicate ON CONFLICT clause ignored */
+        bUsed[jj] = 1;
+        sIdxIter.u.ax.aIdx[i].p = pIdx;
+        sIdxIter.u.ax.aIdx[i].ix = jj;
+        i++;
+      }
+      for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
+        if( bUsed[jj] ) continue;
+        sIdxIter.u.ax.aIdx[i].p = pIdx;
+        sIdxIter.u.ax.aIdx[i].ix = jj;
+        i++;
+      }
+      assert( i==nIdx );
     }
   }
 
@@ -122847,11 +125976,20 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     }
 
     /* figure out whether or not upsert applies in this case */
-    if( pUpsert && pUpsert->pUpsertIdx==0 ){
-      if( pUpsert->pUpsertSet==0 ){
-        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
-      }else{
-        onError = OE_Update;  /* DO UPDATE */
+    if( pUpsert ){
+      pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0);
+      if( pUpsertClause!=0 ){
+        if( pUpsertClause->isDoUpdate==0 ){
+          onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
+        }else{
+          onError = OE_Update;  /* DO UPDATE */
+        }
+      }
+      if( pUpsertClause!=pUpsert ){
+        /* The first ON CONFLICT clause has a conflict target other than
+        ** the IPK.  We have to jump ahead to that first ON CONFLICT clause
+        ** and then come back here and deal with the IPK afterwards */
+        upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
       }
     }
 
@@ -122861,7 +125999,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     ** the UNIQUE constraints have run.
     */
     if( onError==OE_Replace      /* IPK rule is REPLACE */
-     && onError!=overrideError   /* Rules for other contraints are different */
+     && onError!=overrideError   /* Rules for other constraints are different */
      && pTab->pIndex             /* There exist other constraints */
     ){
       ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
@@ -122958,7 +126096,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       }
     }
     sqlite3VdbeResolveLabel(v, addrRowidOk);
-    if( ipkTop ){
+    if( pUpsert && pUpsertClause!=pUpsert ){
+      upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
+    }else if( ipkTop ){
       ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
       sqlite3VdbeJumpHere(v, ipkTop-1);
     }
@@ -122971,7 +126111,10 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   ** This loop also handles the case of the PRIMARY KEY index for a
   ** WITHOUT ROWID table.
   */
-  for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
+  for(pIdx = indexIteratorFirst(&sIdxIter, &ix);
+      pIdx;
+      pIdx = indexIteratorNext(&sIdxIter, &ix)
+  ){
     int regIdx;          /* Range of registers hold conent for pIdx */
     int regR;            /* Range of registers holding conflicting PK */
     int iThisCur;        /* Cursor for this UNIQUE index */
@@ -122979,15 +126122,14 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     int addrConflictCk;  /* First opcode in the conflict check logic */
 
     if( aRegIdx[ix]==0 ) continue;  /* Skip indices that do not change */
-    if( pUpIdx==pIdx ){
-      addrUniqueOk = upsertJump+1;
-      upsertBypass = sqlite3VdbeGoto(v, 0);
-      VdbeComment((v, "Skip upsert subroutine"));
-      sqlite3VdbeJumpHere(v, upsertJump);
-    }else{
-      addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
+    if( pUpsert ){
+      pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx);
+      if( upsertIpkDelay && pUpsertClause==pUpsert ){
+        sqlite3VdbeJumpHere(v, upsertIpkDelay);
+      }
     }
-    if( bAffinityDone==0 && (pUpIdx==0 || pUpIdx==pIdx) ){
+    addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
+    if( bAffinityDone==0 ){
       sqlite3TableAffinity(v, pTab, regNewData+1);
       bAffinityDone = 1;
     }
@@ -123024,7 +126166,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField );
         x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1;
         sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
-        VdbeComment((v, "%s", pTab->aCol[iField].zName));
+        VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
       }
     }
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
@@ -123058,8 +126200,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     }
 
     /* Figure out if the upsert clause applies to this index */
-    if( pUpIdx==pIdx ){
-      if( pUpsert->pUpsertSet==0 ){
+    if( pUpsertClause ){
+      if( pUpsertClause->isDoUpdate==0 ){
         onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
       }else{
         onError = OE_Update;  /* DO UPDATE */
@@ -123076,6 +126218,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
     ** must be explicitly deleted in order to ensure any pre-update hook
     ** is invoked.  */
+    assert( IsOrdinaryTable(pTab) );
 #ifndef SQLITE_ENABLE_PREUPDATE_HOOK
     if( (ix==0 && pIdx->pNext==0)                   /* Condition 3 */
      && pPk==pIdx                                   /* Condition 2 */
@@ -123083,7 +126226,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
      && ( 0==(db->flags&SQLITE_RecTriggers) ||      /* Condition 4 */
           0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
      && ( 0==(db->flags&SQLITE_ForeignKeys) ||      /* Condition 5 */
-         (0==pTab->pFKey && 0==sqlite3FkReferences(pTab)))
+         (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab)))
     ){
       sqlite3VdbeResolveLabel(v, addrUniqueOk);
       continue;
@@ -123097,7 +126240,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
                            regIdx, pIdx->nKeyCol); VdbeCoverage(v);
 
     /* Generate code to handle collisions */
-    regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
+    regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField);
     if( isUpdate || onError==OE_Replace ){
       if( HasRowid(pTab) ){
         sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
@@ -123118,7 +126261,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
             x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
             sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
             VdbeComment((v, "%s.%s", pTab->zName,
-                         pTab->aCol[pPk->aiColumn[i]].zName));
+                         pTab->aCol[pPk->aiColumn[i]].zCnName));
           }
         }
         if( isUpdate ){
@@ -123182,7 +126325,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
 
         assert( onError==OE_Replace );
         nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
-        assert( nConflictCk>0 );
+        assert( nConflictCk>0 || db->mallocFailed );
+        testcase( nConflictCk<=0 );
         testcase( nConflictCk>1 );
         if( regTrigCnt ){
           sqlite3MultiWrite(pParse);
@@ -123249,13 +126393,16 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         break;
       }
     }
-    if( pUpIdx==pIdx ){
-      sqlite3VdbeGoto(v, upsertJump+1);
-      sqlite3VdbeJumpHere(v, upsertBypass);
-    }else{
-      sqlite3VdbeResolveLabel(v, addrUniqueOk);
-    }
+    sqlite3VdbeResolveLabel(v, addrUniqueOk);
     if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
+    if( pUpsertClause
+     && upsertIpkReturn
+     && sqlite3UpsertNextIsIPK(pUpsertClause)
+    ){
+      sqlite3VdbeGoto(v, upsertIpkDelay+1);
+      sqlite3VdbeJumpHere(v, upsertIpkReturn);
+      upsertIpkReturn = 0;
+    }
   }
 
   /* If the IPK constraint is a REPLACE, run it last */
@@ -123314,13 +126461,39 @@ SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
   if( pTab->pSchema->file_format<2 ) return;
 
   for(i=pTab->nCol-1; i>0; i--){
-    if( pTab->aCol[i].pDflt!=0 ) break;
+    if( pTab->aCol[i].iDflt!=0 ) break;
     if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break;
   }
   sqlite3VdbeChangeP5(v, i+1);
 }
 #endif
 
+/*
+** Table pTab is a WITHOUT ROWID table that is being written to. The cursor
+** number is iCur, and register regData contains the new record for the
+** PK index. This function adds code to invoke the pre-update hook,
+** if one is registered.
+*/
+#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
+static void codeWithoutRowidPreupdate(
+  Parse *pParse,                  /* Parse context */
+  Table *pTab,                    /* Table being updated */
+  int iCur,                       /* Cursor number for table */
+  int regData                     /* Data containing new record */
+){
+  Vdbe *v = pParse->pVdbe;
+  int r = sqlite3GetTempReg(pParse);
+  assert( !HasRowid(pTab) );
+  assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB );
+  sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
+  sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
+  sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
+  sqlite3ReleaseTempReg(pParse, r);
+}
+#else
+# define codeWithoutRowidPreupdate(a,b,c,d)
+#endif
+
 /*
 ** This routine generates code to finish the INSERT or UPDATE operation
 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
@@ -123353,7 +126526,7 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(
 
   v = pParse->pVdbe;
   assert( v!=0 );
-  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
+  assert( !IsView(pTab) );  /* This table is not a VIEW */
   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     /* All REPLACE indexes are at the end of the list */
     assert( pIdx->onError!=OE_Replace
@@ -123369,17 +126542,9 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(
       assert( pParse->nested==0 );
       pik_flags |= OPFLAG_NCHANGE;
       pik_flags |= (update_flags & OPFLAG_SAVEPOSITION);
-#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
       if( update_flags==0 ){
-        int r = sqlite3GetTempReg(pParse);
-        sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
-        sqlite3VdbeAddOp4(v, OP_Insert,
-            iIdxCur+i, aRegIdx[i], r, (char*)pTab, P4_TABLE
-        );
-        sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
-        sqlite3ReleaseTempReg(pParse, r);
+        codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);
       }
-#endif
     }
     sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
                          aRegIdx[i]+1,
@@ -123447,8 +126612,9 @@ SQLITE_PRIVATE int sqlite3OpenTableAndIndices(
   assert( op==OP_OpenWrite || p5==0 );
   if( IsVirtual(pTab) ){
     /* This routine is a no-op for virtual tables. Leave the output
-    ** variables *piDataCur and *piIdxCur uninitialized so that valgrind
-    ** can detect if they are used by mistake in the caller. */
+    ** variables *piDataCur and *piIdxCur set to illegal cursor numbers
+    ** for improved error detection. */
+    *piDataCur = *piIdxCur = -999;
     return 0;
   }
   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
@@ -123577,7 +126743,7 @@ static int xferOptimization(
   ExprList *pEList;                /* The result set of the SELECT */
   Table *pSrc;                     /* The table in the FROM clause of SELECT */
   Index *pSrcIdx, *pDestIdx;       /* Source and destination indices */
-  struct SrcList_item *pItem;      /* An element of pSelect->pSrc */
+  SrcItem *pItem;                  /* An element of pSelect->pSrc */
   int i;                           /* Loop counter */
   int iDbSrc;                      /* The database of pSrc */
   int iSrc, iDest;                 /* Cursors from source and destination */
@@ -123663,13 +126829,8 @@ static int xferOptimization(
   if( HasRowid(pDest)!=HasRowid(pSrc) ){
     return 0;   /* source and destination must both be WITHOUT ROWID or not */
   }
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  if( IsVirtual(pSrc) ){
-    return 0;   /* tab2 must not be a virtual table */
-  }
-#endif
-  if( pSrc->pSelect ){
-    return 0;   /* tab2 may not be a view */
+  if( !IsOrdinaryTable(pSrc) ){
+    return 0;   /* tab2 may not be a view or virtual table */
   }
   if( pDest->nCol!=pSrc->nCol ){
     return 0;   /* Number of columns must be the same in tab1 and tab2 */
@@ -123677,6 +126838,9 @@ static int xferOptimization(
   if( pDest->iPKey!=pSrc->iPKey ){
     return 0;   /* Both tables must have the same INTEGER PRIMARY KEY */
   }
+  if( (pDest->tabFlags & TF_Strict)!=0 && (pSrc->tabFlags & TF_Strict)==0 ){
+    return 0;   /* Cannot feed from a non-strict into a strict table */
+  }
   for(i=0; i<pDest->nCol; i++){
     Column *pDestCol = &pDest->aCol[i];
     Column *pSrcCol = &pSrc->aCol[i];
@@ -123713,7 +126877,9 @@ static int xferOptimization(
     ** This requirement could be relaxed for VIRTUAL columns, I suppose.
     */
     if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){
-      if( sqlite3ExprCompare(0, pSrcCol->pDflt, pDestCol->pDflt, -1)!=0 ){
+      if( sqlite3ExprCompare(0,
+             sqlite3ColumnExpr(pSrc, pSrcCol),
+             sqlite3ColumnExpr(pDest, pDestCol), -1)!=0 ){
         testcase( pDestCol->colFlags & COLFLAG_VIRTUAL );
         testcase( pDestCol->colFlags & COLFLAG_STORED );
         return 0;  /* Different generator expressions */
@@ -123723,7 +126889,8 @@ static int xferOptimization(
     if( pDestCol->affinity!=pSrcCol->affinity ){
       return 0;    /* Affinity must be the same on all columns */
     }
-    if( sqlite3_stricmp(pDestCol->zColl, pSrcCol->zColl)!=0 ){
+    if( sqlite3_stricmp(sqlite3ColumnColl(pDestCol),
+                        sqlite3ColumnColl(pSrcCol))!=0 ){
       return 0;    /* Collating sequence must be the same on all columns */
     }
     if( pDestCol->notNull && !pSrcCol->notNull ){
@@ -123731,11 +126898,15 @@ static int xferOptimization(
     }
     /* Default values for second and subsequent columns need to match. */
     if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){
-      assert( pDestCol->pDflt==0 || pDestCol->pDflt->op==TK_SPAN );
-      assert( pSrcCol->pDflt==0 || pSrcCol->pDflt->op==TK_SPAN );
-      if( (pDestCol->pDflt==0)!=(pSrcCol->pDflt==0)
-       || (pDestCol->pDflt && strcmp(pDestCol->pDflt->u.zToken,
-                                       pSrcCol->pDflt->u.zToken)!=0)
+      Expr *pDestExpr = sqlite3ColumnExpr(pDest, pDestCol);
+      Expr *pSrcExpr = sqlite3ColumnExpr(pSrc, pSrcCol);
+      assert( pDestExpr==0 || pDestExpr->op==TK_SPAN );
+      assert( pDestExpr==0 || !ExprHasProperty(pDestExpr, EP_IntValue) );
+      assert( pSrcExpr==0 || pSrcExpr->op==TK_SPAN );
+      assert( pSrcExpr==0 || !ExprHasProperty(pSrcExpr, EP_IntValue) );
+      if( (pDestExpr==0)!=(pSrcExpr==0)
+       || (pDestExpr!=0 && strcmp(pDestExpr->u.zToken,
+                                       pSrcExpr->u.zToken)!=0)
       ){
         return 0;    /* Default values must be the same for all columns */
       }
@@ -123772,7 +126943,8 @@ static int xferOptimization(
   ** the extra complication to make this rule less restrictive is probably
   ** not worth the effort.  Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
   */
-  if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
+  assert( IsOrdinaryTable(pDest) );
+  if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){
     return 0;
   }
 #endif
@@ -123794,6 +126966,7 @@ static int xferOptimization(
   iDest = pParse->nTab++;
   regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
   regData = sqlite3GetTempReg(pParse);
+  sqlite3VdbeAddOp2(v, OP_Null, 0, regData);
   regRowid = sqlite3GetTempReg(pParse);
   sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
   assert( HasRowid(pDest) || destHasUniqueIdx );
@@ -123829,11 +127002,13 @@ static int xferOptimization(
     emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
     if( pDest->iPKey>=0 ){
       addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
-      sqlite3VdbeVerifyAbortable(v, onError);
-      addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
-      VdbeCoverage(v);
-      sqlite3RowidConstraint(pParse, onError, pDest);
-      sqlite3VdbeJumpHere(v, addr2);
+      if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
+        sqlite3VdbeVerifyAbortable(v, onError);
+        addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
+        VdbeCoverage(v);
+        sqlite3RowidConstraint(pParse, onError, pDest);
+        sqlite3VdbeJumpHere(v, addr2);
+      }
       autoIncStep(pParse, regAutoinc, regRowid);
     }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
       addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
@@ -123841,16 +127016,28 @@ static int xferOptimization(
       addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
       assert( (pDest->tabFlags & TF_Autoincrement)==0 );
     }
+
     if( db->mDbFlags & DBFLAG_Vacuum ){
       sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
-      insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT;
+      insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
     }else{
-      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND;
+      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT;
+    }
+#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
+    if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
+      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
+      insFlags &= ~OPFLAG_PREFORMAT;
+    }else
+#endif
+    {
+      sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
+    }
+    sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
+    if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
+      sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
     }
-    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
-    sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
-                      (char*)pDest, P4_TABLE);
     sqlite3VdbeChangeP5(v, insFlags);
+
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
@@ -123892,13 +127079,22 @@ static int xferOptimization(
         if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
       }
       if( i==pSrcIdx->nColumn ){
-        idxInsFlags = OPFLAG_USESEEKRESULT;
+        idxInsFlags = OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
         sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
+        sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc);
       }
     }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
       idxInsFlags |= OPFLAG_NCHANGE;
     }
-    sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
+    if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){
+      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
+      if( (db->mDbFlags & DBFLAG_Vacuum)==0
+       && !HasRowid(pDest)
+       && IsPrimaryKeyIndex(pDestIdx)
+      ){
+        codeWithoutRowidPreupdate(pParse, pDest, iDest, regData);
+      }
+    }
     sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
     sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
@@ -124426,6 +127622,13 @@ struct sqlite3_api_routines {
   sqlite3_file *(*database_file_object)(const char*);
   /* Version 3.34.0 and later */
   int (*txn_state)(sqlite3*,const char*);
+  /* Version 3.36.1 and later */
+  sqlite3_int64 (*changes64)(sqlite3*);
+  sqlite3_int64 (*total_changes64)(sqlite3*);
+  /* Version 3.37.0 and later */
+  int (*autovacuum_pages)(sqlite3*,
+     unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+     void*, void(*)(void*));
 };
 
 /*
@@ -124732,6 +127935,11 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_database_file_object   sqlite3_api->database_file_object
 /* Version 3.34.0 and later */
 #define sqlite3_txn_state              sqlite3_api->txn_state
+/* Version 3.36.1 and later */
+#define sqlite3_changes64              sqlite3_api->changes64
+#define sqlite3_total_changes64        sqlite3_api->total_changes64
+/* Version 3.37.0 and later */
+#define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
@@ -125216,6 +128424,11 @@ static const sqlite3_api_routines sqlite3Apis = {
   sqlite3_database_file_object,
   /* Version 3.34.0 and later */
   sqlite3_txn_state,
+  /* Version 3.36.1 and later */
+  sqlite3_changes64,
+  sqlite3_total_changes64,
+  /* Version 3.37.0 and later */
+  sqlite3_autovacuum_pages,
 };
 
 /* True if x is the directory separator character
@@ -125251,7 +128464,7 @@ static int sqlite3LoadExtension(
   const char *zEntry;
   char *zAltEntry = 0;
   void **aHandle;
-  u64 nMsg = 300 + sqlite3Strlen30(zFile);
+  u64 nMsg = strlen(zFile);
   int ii;
   int rc;
 
@@ -125285,6 +128498,12 @@ static int sqlite3LoadExtension(
 
   zEntry = zProc ? zProc : "sqlite3_extension_init";
 
+  /* tag-20210611-1.  Some dlopen() implementations will segfault if given
+  ** an oversize filename.  Most filesystems have a pathname limit of 4K,
+  ** so limit the extension filename length to about twice that.
+  ** https://sqlite.org/forum/forumpost/08a0d6d9bf */
+  if( nMsg>SQLITE_MAX_PATHLEN ) goto extension_not_found;
+
   handle = sqlite3OsDlOpen(pVfs, zFile);
 #if SQLITE_OS_UNIX || SQLITE_OS_WIN
   for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
@@ -125294,17 +128513,7 @@ static int sqlite3LoadExtension(
     sqlite3_free(zAltFile);
   }
 #endif
-  if( handle==0 ){
-    if( pzErrMsg ){
-      *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
-      if( zErrmsg ){
-        sqlite3_snprintf(nMsg, zErrmsg,
-            "unable to open shared library [%s]", zFile);
-        sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
-      }
-    }
-    return SQLITE_ERROR;
-  }
+  if( handle==0 ) goto extension_not_found;
   xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
 
   /* If no entry point was specified and the default legacy
@@ -125341,10 +128550,11 @@ static int sqlite3LoadExtension(
   }
   if( xInit==0 ){
     if( pzErrMsg ){
-      nMsg += sqlite3Strlen30(zEntry);
+      nMsg += strlen(zEntry) + 300;
       *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
       if( zErrmsg ){
-        sqlite3_snprintf(nMsg, zErrmsg,
+        assert( nMsg<0x7fffffff );  /* zErrmsg would be NULL if not so */
+        sqlite3_snprintf((int)nMsg, zErrmsg,
             "no entry point [%s] in shared library [%s]", zEntry, zFile);
         sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
       }
@@ -125378,6 +128588,19 @@ static int sqlite3LoadExtension(
 
   db->aExtension[db->nExtension++] = handle;
   return SQLITE_OK;
+
+extension_not_found:
+  if( pzErrMsg ){
+    nMsg += 300;
+    *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg);
+    if( zErrmsg ){
+      assert( nMsg<0x7fffffff );  /* zErrmsg would be NULL if not so */
+      sqlite3_snprintf((int)nMsg, zErrmsg,
+          "unable to open shared library [%.*s]", SQLITE_MAX_PATHLEN, zFile);
+      sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
+    }
+  }
+  return SQLITE_ERROR;
 }
 SQLITE_API int sqlite3_load_extension(
   sqlite3 *db,          /* Load the extension into this database connection */
@@ -125668,13 +128891,14 @@ SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
 #define PragTyp_SOFT_HEAP_LIMIT               35
 #define PragTyp_SYNCHRONOUS                   36
 #define PragTyp_TABLE_INFO                    37
-#define PragTyp_TEMP_STORE                    38
-#define PragTyp_TEMP_STORE_DIRECTORY          39
-#define PragTyp_THREADS                       40
-#define PragTyp_WAL_AUTOCHECKPOINT            41
-#define PragTyp_WAL_CHECKPOINT                42
-#define PragTyp_LOCK_STATUS                   43
-#define PragTyp_STATS                         44
+#define PragTyp_TABLE_LIST                    38
+#define PragTyp_TEMP_STORE                    39
+#define PragTyp_TEMP_STORE_DIRECTORY          40
+#define PragTyp_THREADS                       41
+#define PragTyp_WAL_AUTOCHECKPOINT            42
+#define PragTyp_WAL_CHECKPOINT                43
+#define PragTyp_LOCK_STATUS                   44
+#define PragTyp_STATS                         45
 
 /* Property flags associated with various pragma. */
 #define PragFlg_NeedSchema 0x01 /* Force schema load before running */
@@ -125707,45 +128931,51 @@ static const char *const pragCName[] = {
   /*  13 */ "pk",
   /*  14 */ "hidden",
                            /* table_info reuses 8 */
-  /*  15 */ "seqno",       /* Used by: index_xinfo */
-  /*  16 */ "cid",
-  /*  17 */ "name",
-  /*  18 */ "desc",
-  /*  19 */ "coll",
-  /*  20 */ "key",
-  /*  21 */ "name",        /* Used by: function_list */
-  /*  22 */ "builtin",
-  /*  23 */ "type",
-  /*  24 */ "enc",
-  /*  25 */ "narg",
-  /*  26 */ "flags",
-  /*  27 */ "tbl",         /* Used by: stats */
-  /*  28 */ "idx",
-  /*  29 */ "wdth",
-  /*  30 */ "hght",
-  /*  31 */ "flgs",
-  /*  32 */ "seq",         /* Used by: index_list */
-  /*  33 */ "name",
-  /*  34 */ "unique",
-  /*  35 */ "origin",
-  /*  36 */ "partial",
-  /*  37 */ "table",       /* Used by: foreign_key_check */
-  /*  38 */ "rowid",
-  /*  39 */ "parent",
-  /*  40 */ "fkid",
-                           /* index_info reuses 15 */
-  /*  41 */ "seq",         /* Used by: database_list */
-  /*  42 */ "name",
-  /*  43 */ "file",
-  /*  44 */ "busy",        /* Used by: wal_checkpoint */
-  /*  45 */ "log",
-  /*  46 */ "checkpointed",
-                           /* collation_list reuses 32 */
-  /*  47 */ "database",    /* Used by: lock_status */
-  /*  48 */ "status",
-  /*  49 */ "cache_size",  /* Used by: default_cache_size */
+  /*  15 */ "schema",      /* Used by: table_list */
+  /*  16 */ "name",
+  /*  17 */ "type",
+  /*  18 */ "ncol",
+  /*  19 */ "wr",
+  /*  20 */ "strict",
+  /*  21 */ "seqno",       /* Used by: index_xinfo */
+  /*  22 */ "cid",
+  /*  23 */ "name",
+  /*  24 */ "desc",
+  /*  25 */ "coll",
+  /*  26 */ "key",
+  /*  27 */ "name",        /* Used by: function_list */
+  /*  28 */ "builtin",
+  /*  29 */ "type",
+  /*  30 */ "enc",
+  /*  31 */ "narg",
+  /*  32 */ "flags",
+  /*  33 */ "tbl",         /* Used by: stats */
+  /*  34 */ "idx",
+  /*  35 */ "wdth",
+  /*  36 */ "hght",
+  /*  37 */ "flgs",
+  /*  38 */ "seq",         /* Used by: index_list */
+  /*  39 */ "name",
+  /*  40 */ "unique",
+  /*  41 */ "origin",
+  /*  42 */ "partial",
+  /*  43 */ "table",       /* Used by: foreign_key_check */
+  /*  44 */ "rowid",
+  /*  45 */ "parent",
+  /*  46 */ "fkid",
+                           /* index_info reuses 21 */
+  /*  47 */ "seq",         /* Used by: database_list */
+  /*  48 */ "name",
+  /*  49 */ "file",
+  /*  50 */ "busy",        /* Used by: wal_checkpoint */
+  /*  51 */ "log",
+  /*  52 */ "checkpointed",
+                           /* collation_list reuses 38 */
+  /*  53 */ "database",    /* Used by: lock_status */
+  /*  54 */ "status",
+  /*  55 */ "cache_size",  /* Used by: default_cache_size */
                            /* module_list pragma_list reuses 9 */
-  /*  50 */ "timeout",     /* Used by: busy_timeout */
+  /*  56 */ "timeout",     /* Used by: busy_timeout */
 };
 
 /* Definitions of all built-in pragmas */
@@ -125796,7 +129026,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "busy_timeout",
   /* ePragTyp:  */ PragTyp_BUSY_TIMEOUT,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 50, 1,
+  /* ColNames:  */ 56, 1,
   /* iArg:      */ 0 },
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
  {/* zName:     */ "cache_size",
@@ -125835,7 +129065,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "collation_list",
   /* ePragTyp:  */ PragTyp_COLLATION_LIST,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 32, 2,
+  /* ColNames:  */ 38, 2,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
@@ -125870,14 +129100,14 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "database_list",
   /* ePragTyp:  */ PragTyp_DATABASE_LIST,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0,
-  /* ColNames:  */ 41, 3,
+  /* ColNames:  */ 47, 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,
-  /* ColNames:  */ 49, 1,
+  /* ColNames:  */ 55, 1,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
@@ -125907,7 +129137,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "foreign_key_check",
   /* ePragTyp:  */ PragTyp_FOREIGN_KEY_CHECK,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 37, 4,
+  /* ColNames:  */ 43, 4,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FOREIGN_KEY)
@@ -125950,7 +129180,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "function_list",
   /* ePragTyp:  */ PragTyp_FUNCTION_LIST,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 21, 6,
+  /* ColNames:  */ 27, 6,
   /* iArg:      */ 0 },
 #endif
 #endif
@@ -125979,23 +129209,23 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "index_info",
   /* ePragTyp:  */ PragTyp_INDEX_INFO,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 15, 3,
+  /* ColNames:  */ 21, 3,
   /* iArg:      */ 0 },
  {/* zName:     */ "index_list",
   /* ePragTyp:  */ PragTyp_INDEX_LIST,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 32, 5,
+  /* ColNames:  */ 38, 5,
   /* iArg:      */ 0 },
  {/* zName:     */ "index_xinfo",
   /* ePragTyp:  */ PragTyp_INDEX_INFO,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 15, 6,
+  /* ColNames:  */ 21, 6,
   /* iArg:      */ 1 },
 #endif
 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
  {/* zName:     */ "integrity_check",
   /* ePragTyp:  */ PragTyp_INTEGRITY_CHECK,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt,
   /* ColNames:  */ 0, 0,
   /* iArg:      */ 0 },
 #endif
@@ -126029,7 +129259,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "lock_status",
   /* ePragTyp:  */ PragTyp_LOCK_STATUS,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 47, 2,
+  /* ColNames:  */ 53, 2,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
@@ -126103,7 +129333,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
  {/* zName:     */ "quick_check",
   /* ePragTyp:  */ PragTyp_INTEGRITY_CHECK,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt,
   /* ColNames:  */ 0, 0,
   /* iArg:      */ 0 },
 #endif
@@ -126168,7 +129398,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "stats",
   /* ePragTyp:  */ PragTyp_STATS,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq,
-  /* ColNames:  */ 27, 5,
+  /* ColNames:  */ 33, 5,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
@@ -126184,6 +129414,11 @@ static const PragmaName aPragmaName[] = {
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
   /* ColNames:  */ 8, 6,
   /* iArg:      */ 0 },
+ {/* zName:     */ "table_list",
+  /* ePragTyp:  */ PragTyp_TABLE_LIST,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1,
+  /* ColNames:  */ 15, 6,
+  /* iArg:      */ 0 },
  {/* zName:     */ "table_xinfo",
   /* ePragTyp:  */ PragTyp_TABLE_INFO,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
@@ -126259,7 +129494,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "wal_checkpoint",
   /* ePragTyp:  */ PragTyp_WAL_CHECKPOINT,
   /* ePragFlg:  */ PragFlg_NeedSchema,
-  /* ColNames:  */ 44, 3,
+  /* ColNames:  */ 50, 3,
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
@@ -126270,7 +129505,7 @@ static const PragmaName aPragmaName[] = {
   /* iArg:      */ SQLITE_WriteSchema|SQLITE_NoSchemaError },
 #endif
 };
-/* Number of pragmas: 67 on by default, 77 total. */
+/* Number of pragmas: 68 on by default, 78 total. */
 
 /************** End of pragma.h **********************************************/
 /************** Continuing where we left off in pragma.c *********************/
@@ -126712,7 +129947,11 @@ SQLITE_PRIVATE void sqlite3Pragma(
 
   /* Locate the pragma in the lookup table */
   pPragma = pragmaLocate(zLeft);
-  if( pPragma==0 ) goto pragma_out;
+  if( pPragma==0 ){
+    /* IMP: R-43042-22504 No error messages are generated if an
+    ** unknown pragma is issued. */
+    goto pragma_out;
+  }
 
   /* Make sure the database schema is loaded if the pragma requires that */
   if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){
@@ -127362,6 +130601,14 @@ SQLITE_PRIVATE void sqlite3Pragma(
       }else{
         db->flags &= ~mask;
         if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
+        if( (mask & SQLITE_WriteSchema)!=0
+         && sqlite3_stricmp(zRight, "reset")==0
+        ){
+          /* IMP: R-60817-01178 If the argument is "RESET" then schema
+          ** writing is disabled (as with "PRAGMA writable_schema=OFF") and,
+          ** in addition, the schema is reloaded. */
+          sqlite3ResetAllSchemasOfConnection(db);
+        }
       }
 
       /* Many of the flag-pragmas modify the code generated by the SQL
@@ -127402,6 +130649,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       sqlite3ViewGetColumnNames(pParse, pTab);
       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
         int isHidden = 0;
+        const Expr *pColExpr;
         if( pCol->colFlags & COLFLAG_NOINSERT ){
           if( pPragma->iArg==0 ){
             nHidden++;
@@ -127422,13 +130670,16 @@ SQLITE_PRIVATE void sqlite3Pragma(
         }else{
           for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
         }
-        assert( pCol->pDflt==0 || pCol->pDflt->op==TK_SPAN || isHidden>=2 );
+        pColExpr = sqlite3ColumnExpr(pTab,pCol);
+        assert( pColExpr==0 || pColExpr->op==TK_SPAN || isHidden>=2 );
+        assert( pColExpr==0 || !ExprHasProperty(pColExpr, EP_IntValue)
+                  || isHidden>=2 );
         sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
                i-nHidden,
-               pCol->zName,
+               pCol->zCnName,
                sqlite3ColumnType(pCol,""),
                pCol->notNull ? 1 : 0,
-               pCol->pDflt && isHidden<2 ? pCol->pDflt->u.zToken : 0,
+               (isHidden>=2 || pColExpr==0) ? 0 : pColExpr->u.zToken,
                k,
                isHidden);
       }
@@ -127436,6 +130687,81 @@ SQLITE_PRIVATE void sqlite3Pragma(
   }
   break;
 
+  /*
+  **   PRAGMA table_list
+  **
+  ** Return a single row for each table, virtual table, or view in the
+  ** entire schema.
+  **
+  ** schema:     Name of attached database hold this table
+  ** name:       Name of the table itself
+  ** type:       "table", "view", "virtual", "shadow"
+  ** ncol:       Number of columns
+  ** wr:         True for a WITHOUT ROWID table
+  ** strict:     True for a STRICT table
+  */
+  case PragTyp_TABLE_LIST: {
+    int ii;
+    pParse->nMem = 6;
+    sqlite3CodeVerifyNamedSchema(pParse, zDb);
+    for(ii=0; ii<db->nDb; ii++){
+      HashElem *k;
+      Hash *pHash;
+      int initNCol;
+      if( zDb && sqlite3_stricmp(zDb, db->aDb[ii].zDbSName)!=0 ) continue;
+
+      /* Ensure that the Table.nCol field is initialized for all views
+      ** and virtual tables.  Each time we initialize a Table.nCol value
+      ** for a table, that can potentially disrupt the hash table, so restart
+      ** the initialization scan.
+      */
+      pHash = &db->aDb[ii].pSchema->tblHash;
+      initNCol = sqliteHashCount(pHash);
+      while( initNCol-- ){
+        for(k=sqliteHashFirst(pHash); 1; k=sqliteHashNext(k) ){
+          Table *pTab;
+          if( k==0 ){ initNCol = 0; break; }
+          pTab = sqliteHashData(k);
+          if( pTab->nCol==0 ){
+            char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName);
+            if( zSql ){
+              sqlite3_stmt *pDummy = 0;
+              (void)sqlite3_prepare(db, zSql, -1, &pDummy, 0);
+              (void)sqlite3_finalize(pDummy);
+              sqlite3DbFree(db, zSql);
+            }
+            pHash = &db->aDb[ii].pSchema->tblHash;
+            break;
+          }
+        }
+      }
+
+      for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k) ){
+        Table *pTab = sqliteHashData(k);
+        const char *zType;
+        if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue;
+        if( IsView(pTab) ){
+          zType = "view";
+        }else if( IsVirtual(pTab) ){
+          zType = "virtual";
+        }else if( pTab->tabFlags & TF_Shadow ){
+          zType = "shadow";
+        }else{
+          zType = "table";
+        }
+        sqlite3VdbeMultiLoad(v, 1, "sssiii",
+           db->aDb[ii].zDbSName,
+           sqlite3PreferredTableName(pTab->zName),
+           zType,
+           pTab->nCol,
+           (pTab->tabFlags & TF_WithoutRowid)!=0,
+           (pTab->tabFlags & TF_Strict)!=0
+        );
+      }
+    }
+  }
+  break;
+
 #ifdef SQLITE_DEBUG
   case PragTyp_STATS: {
     Index *pIdx;
@@ -127445,7 +130771,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
     for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
       Table *pTab = sqliteHashData(i);
       sqlite3VdbeMultiLoad(v, 1, "ssiii",
-           pTab->zName,
+           sqlite3PreferredTableName(pTab->zName),
            0,
            pTab->szTabRow,
            pTab->nRowLogEst,
@@ -127495,7 +130821,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       for(i=0; i<mx; i++){
         i16 cnum = pIdx->aiColumn[i];
         sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
-                             cnum<0 ? 0 : pTab->aCol[cnum].zName);
+                             cnum<0 ? 0 : pTab->aCol[cnum].zCnName);
         if( pPragma->iArg ){
           sqlite3VdbeMultiLoad(v, 4, "isiX",
             pIdx->aSortOrder[i],
@@ -127564,11 +130890,13 @@ SQLITE_PRIVATE void sqlite3Pragma(
     pParse->nMem = 6;
     for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){
+        assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
         pragmaFunclistLine(v, p, 1, showInternFunc);
       }
     }
     for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){
       p = (FuncDef*)sqliteHashData(j);
+      assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 );
       pragmaFunclistLine(v, p, 0, showInternFunc);
     }
   }
@@ -127602,8 +130930,8 @@ SQLITE_PRIVATE void sqlite3Pragma(
     FKey *pFK;
     Table *pTab;
     pTab = sqlite3FindTable(db, zRight, zDb);
-    if( pTab ){
-      pFK = pTab->pFKey;
+    if( pTab && IsOrdinaryTable(pTab) ){
+      pFK = pTab->u.tab.pFKey;
       if( pFK ){
         int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
         int i = 0;
@@ -127616,7 +130944,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
                    i,
                    j,
                    pFK->zTo,
-                   pTab->aCol[pFK->aCol[j].iFrom].zName,
+                   pTab->aCol[pFK->aCol[j].iFrom].zCnName,
                    pFK->aCol[j].zCol,
                    actionName(pFK->aAction[1]),  /* ON UPDATE */
                    actionName(pFK->aAction[0]),  /* ON DELETE */
@@ -127662,7 +130990,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
         pTab = (Table*)sqliteHashData(k);
         k = sqliteHashNext(k);
       }
-      if( pTab==0 || pTab->pFKey==0 ) continue;
+      if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue;
       iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
       zDb = db->aDb[iDb].zDbSName;
       sqlite3CodeVerifySchema(pParse, iDb);
@@ -127670,7 +130998,8 @@ SQLITE_PRIVATE void sqlite3Pragma(
       if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
       sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
       sqlite3VdbeLoadString(v, regResult, pTab->zName);
-      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
+      assert( IsOrdinaryTable(pTab) );
+      for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
         pParent = sqlite3FindTable(db, pFK->zTo, zDb);
         if( pParent==0 ) continue;
         pIdx = 0;
@@ -127692,7 +131021,8 @@ SQLITE_PRIVATE void sqlite3Pragma(
       if( pFK ) break;
       if( pParse->nTab<i ) pParse->nTab = i;
       addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
-      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
+      assert( IsOrdinaryTable(pTab) );
+      for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){
         pParent = sqlite3FindTable(db, pFK->zTo, zDb);
         pIdx = 0;
         aiCols = 0;
@@ -127706,6 +131036,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
         ** regRow..regRow+n. If any of the child key values are NULL, this
         ** row cannot cause an FK violation. Jump directly to addrOk in
         ** this case. */
+        if( regRow+pFK->nCol>pParse->nMem ) pParse->nMem = regRow+pFK->nCol;
         for(j=0; j<pFK->nCol; j++){
           int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
           sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
@@ -127892,8 +131223,9 @@ SQLITE_PRIVATE void sqlite3Pragma(
         int loopTop;
         int iDataCur, iIdxCur;
         int r1 = -1;
+        int bStrict;
 
-        if( pTab->tnum<1 ) continue;  /* Skip VIEWs or VIRTUAL TABLEs */
+        if( !IsOrdinaryTable(pTab) ) continue;
         if( pObjTab && pObjTab!=pTab ) continue;
         pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
         sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
@@ -127913,23 +131245,48 @@ SQLITE_PRIVATE void sqlite3Pragma(
           /* Sanity check on record header decoding */
           sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nNVCol-1,3);
           sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
+          VdbeComment((v, "(right-most column)"));
         }
-        /* Verify that all NOT NULL columns really are NOT NULL */
+        /* Verify that all NOT NULL columns really are NOT NULL.  At the
+        ** same time verify the type of the content of STRICT tables */
+        bStrict = (pTab->tabFlags & TF_Strict)!=0;
         for(j=0; j<pTab->nCol; j++){
           char *zErr;
-          int jmp2;
+          Column *pCol = pTab->aCol + j;
+          int doError, jmp2;
           if( j==pTab->iPKey ) continue;
-          if( pTab->aCol[j].notNull==0 ) continue;
+          if( pCol->notNull==0 && !bStrict ) continue;
+          doError = bStrict ? sqlite3VdbeMakeLabel(pParse) : 0;
           sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
           if( sqlite3VdbeGetOp(v,-1)->opcode==OP_Column ){
             sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
           }
-          jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
-          zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
-                              pTab->aCol[j].zName);
-          sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
-          integrityCheckResultRow(v);
-          sqlite3VdbeJumpHere(v, jmp2);
+          if( pCol->notNull ){
+            jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
+            zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
+                                pCol->zCnName);
+            sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
+            if( bStrict && pCol->eCType!=COLTYPE_ANY ){
+              sqlite3VdbeGoto(v, doError);
+            }else{
+              integrityCheckResultRow(v);
+            }
+            sqlite3VdbeJumpHere(v, jmp2);
+          }
+          if( (pTab->tabFlags & TF_Strict)!=0
+           && pCol->eCType!=COLTYPE_ANY
+          ){
+            jmp2 = sqlite3VdbeAddOp3(v, OP_IsNullOrType, 3, 0,
+                                     sqlite3StdTypeMap[pCol->eCType-1]);
+            VdbeCoverage(v);
+            zErr = sqlite3MPrintf(db, "non-%s value in %s.%s",
+                                  sqlite3StdType[pCol->eCType-1],
+                                  pTab->zName, pTab->aCol[j].zCnName);
+            sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
+            sqlite3VdbeResolveLabel(v, doError);
+            integrityCheckResultRow(v);
+            sqlite3VdbeJumpHere(v, jmp2);
+          }
         }
         /* Verify CHECK constraints */
         if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
@@ -128214,7 +131571,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
   ** Checkpoint the database.
   */
   case PragTyp_WAL_CHECKPOINT: {
-    int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
+    int iBt = (pId2->z?iDb:SQLITE_MAX_DB);
     int eMode = SQLITE_CHECKPOINT_PASSIVE;
     if( zRight ){
       if( sqlite3StrICmp(zRight, "full")==0 ){
@@ -128463,12 +131820,12 @@ SQLITE_PRIVATE void sqlite3Pragma(
   case PragTyp_ANALYSIS_LIMIT: {
     sqlite3_int64 N;
     if( zRight
-     && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
+     && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */
      && N>=0
     ){
       db->nAnalysisLimit = (int)(N&0x7fffffff);
     }
-    returnSingleInt(v, db->nAnalysisLimit);
+    returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */
     break;
   }
 
@@ -128862,7 +132219,7 @@ SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName)
 */
 static void corruptSchema(
   InitData *pData,     /* Initialization context */
-  const char *zObj,    /* Object being parsed at the point of error */
+  char **azObj,        /* Type and name of object being parsed */
   const char *zExtra   /* Error information */
 ){
   sqlite3 *db = pData->db;
@@ -128870,14 +132227,23 @@ static void corruptSchema(
     pData->rc = SQLITE_NOMEM_BKPT;
   }else if( pData->pzErrMsg[0]!=0 ){
     /* A error message has already been generated.  Do not overwrite it */
-  }else if( pData->mInitFlags & INITFLAG_AlterTable ){
-    *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
+  }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){
+    static const char *azAlterType[] = {
+       "rename",
+       "drop column",
+       "add column"
+    };
+    *pData->pzErrMsg = sqlite3MPrintf(db,
+        "error in %s %s after %s: %s", azObj[0], azObj[1],
+        azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1],
+        zExtra
+    );
     pData->rc = SQLITE_ERROR;
   }else if( db->flags & SQLITE_WriteSchema ){
     pData->rc = SQLITE_CORRUPT_BKPT;
   }else{
     char *z;
-    if( zObj==0 ) zObj = "?";
+    const char *zObj = azObj[1] ? azObj[1] : "?";
     z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
     if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
     *pData->pzErrMsg = z;
@@ -128933,21 +132299,28 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
   UNUSED_PARAMETER2(NotUsed, argc);
   assert( sqlite3_mutex_held(db->mutex) );
   db->mDbFlags |= DBFLAG_EncodingFixed;
+  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
   pData->nInitRow++;
   if( db->mallocFailed ){
-    corruptSchema(pData, argv[1], 0);
+    corruptSchema(pData, argv, 0);
     return 1;
   }
 
   assert( iDb>=0 && iDb<db->nDb );
-  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
   if( argv[3]==0 ){
-    corruptSchema(pData, argv[1], 0);
-  }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){
+    corruptSchema(pData, argv, 0);
+  }else if( argv[4]
+         && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]]
+         && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){
     /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
     ** But because db->init.busy is set to 1, no VDBE code is generated
     ** or executed.  All the parser does is build the internal data
     ** structures that describe the table, index, or view.
+    **
+    ** No other valid SQL statement, other than the variable CREATE statements,
+    ** can begin with the letters "C" and "R".  Thus, it is not possible run
+    ** any other kind of statement while parsing the schema, even a corrupt
+    ** schema.
     */
     int rc;
     u8 saved_iDb = db->init.iDb;
@@ -128960,11 +132333,11 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
      || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
     ){
       if( sqlite3Config.bExtraSchemaChecks ){
-        corruptSchema(pData, argv[1], "invalid rootpage");
+        corruptSchema(pData, argv, "invalid rootpage");
       }
     }
     db->init.orphanTrigger = 0;
-    db->init.azInit = argv;
+    db->init.azInit = (const char**)argv;
     pStmt = 0;
     TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
     rc = db->errCode;
@@ -128979,13 +132352,14 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
         if( rc==SQLITE_NOMEM ){
           sqlite3OomFault(db);
         }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
-          corruptSchema(pData, argv[1], sqlite3_errmsg(db));
+          corruptSchema(pData, argv, sqlite3_errmsg(db));
         }
       }
     }
+    db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
     sqlite3_finalize(pStmt);
   }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){
-    corruptSchema(pData, argv[1], 0);
+    corruptSchema(pData, argv, 0);
   }else{
     /* If the SQL column is blank it means this is an index that
     ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
@@ -128996,7 +132370,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
     Index *pIndex;
     pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
     if( pIndex==0 ){
-      corruptSchema(pData, argv[1], "orphan index");
+      corruptSchema(pData, argv, "orphan index");
     }else
     if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
      || pIndex->tnum<2
@@ -129004,7 +132378,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
      || sqlite3IndexHasDuplicateRootPage(pIndex)
     ){
       if( sqlite3Config.bExtraSchemaChecks ){
-        corruptSchema(pData, argv[1], "invalid rootpage");
+        corruptSchema(pData, argv, "invalid rootpage");
       }
     }
   }
@@ -129207,18 +132581,22 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
     }
 #endif
   }
+  assert( pDb == &(db->aDb[iDb]) );
   if( db->mallocFailed ){
     rc = SQLITE_NOMEM_BKPT;
     sqlite3ResetAllSchemasOfConnection(db);
-  }
+    pDb = &db->aDb[iDb];
+  }else
   if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){
-    /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider
-    ** the schema loaded, even if errors occurred. In this situation the
-    ** current sqlite3_prepare() operation will fail, but the following one
-    ** will attempt to compile the supplied statement against whatever subset
-    ** of the schema was loaded before the error occurred. The primary
-    ** purpose of this is to allow access to the sqlite_schema table
-    ** even when its contents have been corrupted.
+    /* Hack: If the SQLITE_NoSchemaError flag is set, then consider
+    ** the schema loaded, even if errors (other than OOM) occurred. In
+    ** this situation the current sqlite3_prepare() operation will fail,
+    ** but the following one will attempt to compile the supplied statement
+    ** against whatever subset of the schema was loaded before the error
+    ** occurred.
+    **
+    ** The primary purpose of this is to allow access to the sqlite_schema
+    ** table even when its contents have been corrupted.
     */
     DbSetProperty(db, iDb, DB_SchemaLoaded);
     rc = SQLITE_OK;
@@ -129328,6 +132706,7 @@ static void schemaIsValid(Parse *pParse){
       rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
         sqlite3OomFault(db);
+        pParse->rc = SQLITE_NOMEM;
       }
       if( rc!=SQLITE_OK ) return;
       openedTransaction = 1;
@@ -129384,28 +132763,21 @@ SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
   return i;
 }
 
-/*
-** Deallocate a single AggInfo object
-*/
-static void agginfoFree(sqlite3 *db, AggInfo *p){
-  sqlite3DbFree(db, p->aCol);
-  sqlite3DbFree(db, p->aFunc);
-  sqlite3DbFree(db, p);
-}
-
 /*
 ** Free all memory allocations in the pParse object
 */
 SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
   sqlite3 *db = pParse->db;
-  AggInfo *pThis = pParse->pAggList;
-  while( pThis ){
-    AggInfo *pNext = pThis->pNext;
-    agginfoFree(db, pThis);
-    pThis = pNext;
+  while( pParse->pCleanup ){
+    ParseCleanup *pCleanup = pParse->pCleanup;
+    pParse->pCleanup = pCleanup->pNext;
+    pCleanup->xCleanup(db, pCleanup->pPtr);
+    sqlite3DbFreeNN(db, pCleanup);
   }
   sqlite3DbFree(db, pParse->aLabel);
-  sqlite3ExprListDelete(db, pParse->pConstExpr);
+  if( pParse->pConstExpr ){
+    sqlite3ExprListDelete(db, pParse->pConstExpr);
+  }
   if( db ){
     assert( db->lookaside.bDisable >= pParse->disableLookaside );
     db->lookaside.bDisable -= pParse->disableLookaside;
@@ -129414,6 +132786,55 @@ SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
   pParse->disableLookaside = 0;
 }
 
+/*
+** Add a new cleanup operation to a Parser.  The cleanup should happen when
+** the parser object is destroyed.  But, beware: the cleanup might happen
+** immediately.
+**
+** Use this mechanism for uncommon cleanups.  There is a higher setup
+** cost for this mechansim (an extra malloc), so it should not be used
+** for common cleanups that happen on most calls.  But for less
+** common cleanups, we save a single NULL-pointer comparison in
+** sqlite3ParserReset(), which reduces the total CPU cycle count.
+**
+** If a memory allocation error occurs, then the cleanup happens immediately.
+** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the
+** pParse->earlyCleanup flag is set in that case.  Calling code show verify
+** that test cases exist for which this happens, to guard against possible
+** use-after-free errors following an OOM.  The preferred way to do this is
+** to immediately follow the call to this routine with:
+**
+**       testcase( pParse->earlyCleanup );
+**
+** This routine returns a copy of its pPtr input (the third parameter)
+** except if an early cleanup occurs, in which case it returns NULL.  So
+** another way to check for early cleanup is to check the return value.
+** Or, stop using the pPtr parameter with this call and use only its
+** return value thereafter.  Something like this:
+**
+**       pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj);
+*/
+SQLITE_PRIVATE void *sqlite3ParserAddCleanup(
+  Parse *pParse,                      /* Destroy when this Parser finishes */
+  void (*xCleanup)(sqlite3*,void*),   /* The cleanup routine */
+  void *pPtr                          /* Pointer to object to be cleaned up */
+){
+  ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
+  if( pCleanup ){
+    pCleanup->pNext = pParse->pCleanup;
+    pParse->pCleanup = pCleanup;
+    pCleanup->pPtr = pPtr;
+    pCleanup->xCleanup = xCleanup;
+  }else{
+    xCleanup(pParse->db, pPtr);
+    pPtr = 0;
+#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
+    pParse->earlyCleanup = 1;
+#endif
+  }
+  return pPtr;
+}
+
 /*
 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
 */
@@ -129512,12 +132933,6 @@ static int sqlite3Prepare(
   }
   assert( 0==sParse.nQueryLoop );
 
-  if( sParse.rc==SQLITE_DONE ){
-    sParse.rc = SQLITE_OK;
-  }
-  if( sParse.checkSchema ){
-    schemaIsValid(&sParse);
-  }
   if( pzTail ){
     *pzTail = sParse.zTail;
   }
@@ -129527,21 +132942,30 @@ static int sqlite3Prepare(
   }
   if( db->mallocFailed ){
     sParse.rc = SQLITE_NOMEM_BKPT;
+    sParse.checkSchema = 0;
   }
-  rc = sParse.rc;
-  if( rc!=SQLITE_OK ){
-    if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe);
-    assert(!(*ppStmt));
+  if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){
+    if( sParse.checkSchema ){
+      schemaIsValid(&sParse);
+    }
+    if( sParse.pVdbe ){
+      sqlite3VdbeFinalize(sParse.pVdbe);
+    }
+    assert( 0==(*ppStmt) );
+    rc = sParse.rc;
+    if( zErrMsg ){
+      sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg);
+      sqlite3DbFree(db, zErrMsg);
+    }else{
+      sqlite3Error(db, rc);
+    }
   }else{
+    assert( zErrMsg==0 );
     *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
+    rc = SQLITE_OK;
+    sqlite3ErrorClear(db);
   }
 
-  if( zErrMsg ){
-    sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg);
-    sqlite3DbFree(db, zErrMsg);
-  }else{
-    sqlite3Error(db, rc);
-  }
 
   /* Delete any TriggerPrg structures allocated while parsing this statement. */
   while( sParse.pTriggerPrg ){
@@ -129887,12 +133311,16 @@ static void clearSelect(sqlite3 *db, Select *p, int bFree){
     sqlite3ExprDelete(db, p->pHaving);
     sqlite3ExprListDelete(db, p->pOrderBy);
     sqlite3ExprDelete(db, p->pLimit);
+    if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
 #ifndef SQLITE_OMIT_WINDOWFUNC
     if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
       sqlite3WindowListDelete(db, p->pWinDefn);
     }
+    while( p->pWin ){
+      assert( p->pWin->ppThis==&p->pWin );
+      sqlite3WindowUnlinkFromSelect(p->pWin);
+    }
 #endif
-    if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
     if( bFree ) sqlite3DbFreeNN(db, p);
     p = pPrior;
     bFree = 1;
@@ -130064,12 +133492,12 @@ SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *p
 ** Return the index of a column in a table.  Return -1 if the column
 ** is not contained in the table.
 */
-static int columnIndex(Table *pTab, const char *zCol){
+SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){
   int i;
   u8 h = sqlite3StrIHash(zCol);
   Column *pCol;
   for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
-    if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i;
+    if( pCol->hName==h && sqlite3StrICmp(pCol->zCnName, zCol)==0 ) return i;
   }
   return -1;
 }
@@ -130096,7 +133524,7 @@ static int tableAndColumnIndex(
 
   assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
   for(i=0; i<N; i++){
-    iCol = columnIndex(pSrc->a[i].pTab, zCol);
+    iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
     if( iCol>=0
      && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
     ){
@@ -130145,11 +133573,14 @@ static void addWhereTerm(
   pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
 
   pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
+  assert( pE2!=0 || pEq==0 );  /* Due to db->mallocFailed test
+                               ** in sqlite3DbMallocRawNN() called from
+                               ** sqlite3PExpr(). */
   if( pEq && isOuterJoin ){
     ExprSetProperty(pEq, EP_FromJoin);
     assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
     ExprSetVVAProperty(pEq, EP_NoReduce);
-    pEq->iRightJoinTable = (i16)pE2->iTable;
+    pEq->iRightJoinTable = pE2->iTable;
   }
   *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq);
 }
@@ -130185,11 +133616,14 @@ SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){
     ExprSetProperty(p, EP_FromJoin);
     assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
     ExprSetVVAProperty(p, EP_NoReduce);
-    p->iRightJoinTable = (i16)iTable;
-    if( p->op==TK_FUNCTION && p->x.pList ){
-      int i;
-      for(i=0; i<p->x.pList->nExpr; i++){
-        sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
+    p->iRightJoinTable = iTable;
+    if( p->op==TK_FUNCTION ){
+      assert( ExprUseXList(p) );
+      if( p->x.pList ){
+        int i;
+        for(i=0; i<p->x.pList->nExpr; i++){
+          sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
+        }
       }
     }
     sqlite3SetJoinExpr(p->pLeft, iTable);
@@ -130209,10 +133643,16 @@ static void unsetJoinExpr(Expr *p, int iTable){
      && (iTable<0 || p->iRightJoinTable==iTable) ){
       ExprClearProperty(p, EP_FromJoin);
     }
-    if( p->op==TK_FUNCTION && p->x.pList ){
-      int i;
-      for(i=0; i<p->x.pList->nExpr; i++){
-        unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
+    if( p->op==TK_COLUMN && p->iTable==iTable ){
+      ExprClearProperty(p, EP_CanBeNull);
+    }
+    if( p->op==TK_FUNCTION ){
+      assert( ExprUseXList(p) );
+      if( p->x.pList ){
+        int i;
+        for(i=0; i<p->x.pList->nExpr; i++){
+          unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
+        }
       }
     }
     unsetJoinExpr(p->pLeft, iTable);
@@ -130237,8 +133677,8 @@ static void unsetJoinExpr(Expr *p, int iTable){
 static int sqliteProcessJoin(Parse *pParse, Select *p){
   SrcList *pSrc;                  /* All tables in the FROM clause */
   int i, j;                       /* Loop counters */
-  struct SrcList_item *pLeft;     /* Left table being joined */
-  struct SrcList_item *pRight;    /* Right table being joined */
+  SrcItem *pLeft;                 /* Left table being joined */
+  SrcItem *pRight;                /* Right table being joined */
 
   pSrc = p->pSrc;
   pLeft = &pSrc->a[0];
@@ -130265,7 +133705,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
         int iLeftCol;  /* Matching column in the left table */
 
         if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue;
-        zName = pRightTab->aCol[j].zName;
+        zName = pRightTab->aCol[j].zCnName;
         if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 1) ){
           addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
                 isOuter, &p->pWhere);
@@ -130306,7 +133746,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
         int iRightCol;   /* Column number of matching column on the right */
 
         zName = pList->a[j].zName;
-        iRightCol = columnIndex(pRightTab, zName);
+        iRightCol = sqlite3ColumnIndex(pRightTab, zName);
         if( iRightCol<0
          || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol, 0)
         ){
@@ -130536,31 +133976,157 @@ static void codeOffset(
 }
 
 /*
-** Add code that will check to make sure the N registers starting at iMem
-** form a distinct entry.  iTab is a sorting index that holds previously
-** seen combinations of the N values.  A new entry is made in iTab
-** if the current N values are new.
+** Add code that will check to make sure the array of registers starting at
+** iMem form a distinct entry. This is used by both "SELECT DISTINCT ..." and
+** distinct aggregates ("SELECT count(DISTINCT <expr>) ..."). Three strategies
+** are available. Which is used depends on the value of parameter eTnctType,
+** as follows:
 **
-** A jump to addrRepeat is made and the N+1 values are popped from the
-** stack if the top N elements are not distinct.
-*/
-static void codeDistinct(
+**   WHERE_DISTINCT_UNORDERED/WHERE_DISTINCT_NOOP:
+**     Build an ephemeral table that contains all entries seen before and
+**     skip entries which have been seen before.
+**
+**     Parameter iTab is the cursor number of an ephemeral table that must
+**     be opened before the VM code generated by this routine is executed.
+**     The ephemeral cursor table is queried for a record identical to the
+**     record formed by the current array of registers. If one is found,
+**     jump to VM address addrRepeat. Otherwise, insert a new record into
+**     the ephemeral cursor and proceed.
+**
+**     The returned value in this case is a copy of parameter iTab.
+**
+**   WHERE_DISTINCT_ORDERED:
+**     In this case rows are being delivered sorted order. The ephermal
+**     table is not required. Instead, the current set of values
+**     is compared against previous row. If they match, the new row
+**     is not distinct and control jumps to VM address addrRepeat. Otherwise,
+**     the VM program proceeds with processing the new row.
+**
+**     The returned value in this case is the register number of the first
+**     in an array of registers used to store the previous result row so that
+**     it can be compared to the next. The caller must ensure that this
+**     register is initialized to NULL.  (The fixDistinctOpenEph() routine
+**     will take care of this initialization.)
+**
+**   WHERE_DISTINCT_UNIQUE:
+**     In this case it has already been determined that the rows are distinct.
+**     No special action is required. The return value is zero.
+**
+** Parameter pEList is the list of expressions used to generated the
+** contents of each row. It is used by this routine to determine (a)
+** how many elements there are in the array of registers and (b) the
+** collation sequences that should be used for the comparisons if
+** eTnctType is WHERE_DISTINCT_ORDERED.
+*/
+static int codeDistinct(
   Parse *pParse,     /* Parsing and code generating context */
+  int eTnctType,     /* WHERE_DISTINCT_* value */
   int iTab,          /* A sorting index used to test for distinctness */
   int addrRepeat,    /* Jump to here if not distinct */
-  int N,             /* Number of elements */
-  int iMem           /* First element */
+  ExprList *pEList,  /* Expression for each element */
+  int regElem        /* First element */
 ){
-  Vdbe *v;
-  int r1;
+  int iRet = 0;
+  int nResultCol = pEList->nExpr;
+  Vdbe *v = pParse->pVdbe;
 
-  v = pParse->pVdbe;
-  r1 = sqlite3GetTempReg(pParse);
-  sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
-  sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
-  sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
-  sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
-  sqlite3ReleaseTempReg(pParse, r1);
+  switch( eTnctType ){
+    case WHERE_DISTINCT_ORDERED: {
+      int i;
+      int iJump;              /* Jump destination */
+      int regPrev;            /* Previous row content */
+
+      /* Allocate space for the previous row */
+      iRet = regPrev = pParse->nMem+1;
+      pParse->nMem += nResultCol;
+
+      iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
+      for(i=0; i<nResultCol; i++){
+        CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
+        if( i<nResultCol-1 ){
+          sqlite3VdbeAddOp3(v, OP_Ne, regElem+i, iJump, regPrev+i);
+          VdbeCoverage(v);
+        }else{
+          sqlite3VdbeAddOp3(v, OP_Eq, regElem+i, addrRepeat, regPrev+i);
+          VdbeCoverage(v);
+         }
+        sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
+        sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
+      }
+      assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
+      sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1);
+      break;
+    }
+
+    case WHERE_DISTINCT_UNIQUE: {
+      /* nothing to do */
+      break;
+    }
+
+    default: {
+      int r1 = sqlite3GetTempReg(pParse);
+      sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, regElem, nResultCol);
+      VdbeCoverage(v);
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, regElem, nResultCol, r1);
+      sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, regElem, nResultCol);
+      sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
+      sqlite3ReleaseTempReg(pParse, r1);
+      iRet = iTab;
+      break;
+    }
+  }
+
+  return iRet;
+}
+
+/*
+** This routine runs after codeDistinct().  It makes necessary
+** adjustments to the OP_OpenEphemeral opcode that the codeDistinct()
+** routine made use of.  This processing must be done separately since
+** sometimes codeDistinct is called before the OP_OpenEphemeral is actually
+** laid down.
+**
+** WHERE_DISTINCT_NOOP:
+** WHERE_DISTINCT_UNORDERED:
+**
+**     No adjustments necessary.  This function is a no-op.
+**
+** WHERE_DISTINCT_UNIQUE:
+**
+**     The ephemeral table is not needed.  So change the
+**     OP_OpenEphemeral opcode into an OP_Noop.
+**
+** WHERE_DISTINCT_ORDERED:
+**
+**     The ephemeral table is not needed.  But we do need register
+**     iVal to be initialized to NULL.  So change the OP_OpenEphemeral
+**     into an OP_Null on the iVal register.
+*/
+static void fixDistinctOpenEph(
+  Parse *pParse,     /* Parsing and code generating context */
+  int eTnctType,     /* WHERE_DISTINCT_* value */
+  int iVal,          /* Value returned by codeDistinct() */
+  int iOpenEphAddr   /* Address of OP_OpenEphemeral instruction for iTab */
+){
+  if( pParse->nErr==0
+   && (eTnctType==WHERE_DISTINCT_UNIQUE || eTnctType==WHERE_DISTINCT_ORDERED)
+  ){
+    Vdbe *v = pParse->pVdbe;
+    sqlite3VdbeChangeToNoop(v, iOpenEphAddr);
+    if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){
+      sqlite3VdbeChangeToNoop(v, iOpenEphAddr+1);
+    }
+    if( eTnctType==WHERE_DISTINCT_ORDERED ){
+      /* Change the OP_OpenEphemeral to an OP_Null that sets the MEM_Cleared
+      ** bit on the first register of the previous value.  This will cause the
+      ** OP_Ne added in codeDistinct() to always fail on the first iteration of
+      ** the loop even if the first row is all NULLs.  */
+      VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr);
+      pOp->opcode = OP_Null;
+      pOp->p1 = 1;
+      pOp->p2 = iVal;
+    }
+  }
 }
 
 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
@@ -130601,9 +134167,13 @@ static void selectExprDefer(
     struct ExprList_item *pItem = &pEList->a[i];
     if( pItem->u.x.iOrderByCol==0 ){
       Expr *pExpr = pItem->pExpr;
-      Table *pTab = pExpr->y.pTab;
-      if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
-       && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
+      Table *pTab;
+      if( pExpr->op==TK_COLUMN
+       && pExpr->iColumn>=0
+       && ALWAYS( ExprUseYTab(pExpr) )
+       && (pTab = pExpr->y.pTab)!=0
+       && IsOrdinaryTable(pTab)
+       && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
       ){
         int j;
         for(j=0; j<nDefer; j++){
@@ -130624,6 +134194,7 @@ static void selectExprDefer(
               Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
               if( pNew ){
                 pNew->iTable = pExpr->iTable;
+                assert( ExprUseYTab(pNew) );
                 pNew->y.pTab = pExpr->y.pTab;
                 pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
                 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
@@ -130808,59 +134379,11 @@ static void selectInnerLoop(
   ** part of the result.
   */
   if( hasDistinct ){
-    switch( pDistinct->eTnctType ){
-      case WHERE_DISTINCT_ORDERED: {
-        VdbeOp *pOp;            /* No longer required OpenEphemeral instr. */
-        int iJump;              /* Jump destination */
-        int regPrev;            /* Previous row content */
-
-        /* Allocate space for the previous row */
-        regPrev = pParse->nMem+1;
-        pParse->nMem += nResultCol;
-
-        /* Change the OP_OpenEphemeral coded earlier to an OP_Null
-        ** sets the MEM_Cleared bit on the first register of the
-        ** previous value.  This will cause the OP_Ne below to always
-        ** fail on the first iteration of the loop even if the first
-        ** row is all NULLs.
-        */
-        sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
-        pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);
-        pOp->opcode = OP_Null;
-        pOp->p1 = 1;
-        pOp->p2 = regPrev;
-        pOp = 0;  /* Ensure pOp is not used after sqlite3VdbeAddOp() */
-
-        iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
-        for(i=0; i<nResultCol; i++){
-          CollSeq *pColl = sqlite3ExprCollSeq(pParse, p->pEList->a[i].pExpr);
-          if( i<nResultCol-1 ){
-            sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
-            VdbeCoverage(v);
-          }else{
-            sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
-            VdbeCoverage(v);
-           }
-          sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
-          sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
-        }
-        assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
-        sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
-        break;
-      }
-
-      case WHERE_DISTINCT_UNIQUE: {
-        sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);
-        break;
-      }
-
-      default: {
-        assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
-        codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,
-                     regResult);
-        break;
-      }
-    }
+    int eType = pDistinct->eTnctType;
+    int iTab = pDistinct->tabTnct;
+    assert( nResultCol==p->pEList->nExpr );
+    iTab = codeDistinct(pParse, eType, iTab, iContinue, p->pEList, regResult);
+    fixDistinctOpenEph(pParse, eType, iTab, pDistinct->addrTnct);
     if( pSort==0 ){
       codeOffset(v, p->iOffset, iContinue);
     }
@@ -131185,7 +134708,7 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(
 /*
 ** Name of the connection operator, used for error messages.
 */
-static const char *selectOpName(int id){
+SQLITE_PRIVATE const char *sqlite3SelectOpName(int id){
   char *z;
   switch( id ){
     case TK_ALL:       z = "UNION ALL";   break;
@@ -131520,13 +135043,19 @@ static const char *columnTypeImpl(
         break;
       }
 
-      assert( pTab && pExpr->y.pTab==pTab );
+      assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab );
       if( pS ){
         /* The "table" is actually a sub-select or a view in the FROM clause
         ** of the SELECT statement. Return the declaration type and origin
         ** data for the result-set column of the sub-select.
         */
-        if( iCol>=0 && iCol<pS->pEList->nExpr ){
+        if( iCol<pS->pEList->nExpr
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+         && iCol>=0
+#else
+         && ALWAYS(iCol>=0)
+#endif
+        ){
           /* If iCol is less than zero, then the expression requests the
           ** rowid of the sub-select or view. This expression is legal (see
           ** test case misc2.2.2) - it always evaluates to NULL.
@@ -131548,7 +135077,7 @@ static const char *columnTypeImpl(
           zType = "INTEGER";
           zOrigCol = "rowid";
         }else{
-          zOrigCol = pTab->aCol[iCol].zName;
+          zOrigCol = pTab->aCol[iCol].zCnName;
           zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
         }
         zOrigTab = pTab->zName;
@@ -131574,9 +135103,11 @@ static const char *columnTypeImpl(
       ** statement.
       */
       NameContext sNC;
-      Select *pS = pExpr->x.pSelect;
-      Expr *p = pS->pEList->a[0].pExpr;
-      assert( ExprHasProperty(pExpr, EP_xIsSelect) );
+      Select *pS;
+      Expr *p;
+      assert( ExprUseXSelect(pExpr) );
+      pS = pExpr->x.pSelect;
+      p = pS->pEList->a[0].pExpr;
       sNC.pSrcList = pS->pSrc;
       sNC.pNext = pNC;
       sNC.pParse = pNC->pParse;
@@ -131668,7 +135199,7 @@ static void generateColumnTypes(
 **                              then the result column name with the table name
 **                              prefix, ex: TABLE.COLUMN.  Otherwise use zSpan.
 */
-static void generateColumnNames(
+SQLITE_PRIVATE void sqlite3GenerateColumnNames(
   Parse *pParse,      /* Parser context */
   Select *pSelect     /* Generate column names for this SELECT statement */
 ){
@@ -131705,7 +135236,8 @@ static void generateColumnNames(
 
     assert( p!=0 );
     assert( p->op!=TK_AGG_COLUMN );  /* Agg processing has not run yet */
-    assert( p->op!=TK_COLUMN || p->y.pTab!=0 ); /* Covering idx not yet coded */
+    assert( p->op!=TK_COLUMN
+        || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */
     if( pEList->a[i].zEName && pEList->a[i].eEName==ENAME_NAME ){
       /* An AS clause always takes first priority */
       char *zName = pEList->a[i].zEName;
@@ -131720,7 +135252,7 @@ static void generateColumnNames(
       if( iCol<0 ){
         zCol = "rowid";
       }else{
-        zCol = pTab->aCol[iCol].zName;
+        zCol = pTab->aCol[iCol].zCnName;
       }
       if( fullName ){
         char *zName = 0;
@@ -131758,7 +135290,7 @@ static void generateColumnNames(
 ** and will break if those assumptions changes.  Hence, use extreme caution
 ** when modifying this routine to avoid breaking legacy.
 **
-** See Also: generateColumnNames()
+** See Also: sqlite3GenerateColumnNames()
 */
 SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
   Parse *pParse,          /* Parsing context */
@@ -131781,7 +135313,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
     nCol = pEList->nExpr;
     aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
     testcase( aCol==0 );
-    if( nCol>32767 ) nCol = 32767;
+    if( NEVER(nCol>32767) ) nCol = 32767;
   }else{
     nCol = 0;
     aCol = 0;
@@ -131801,11 +135333,14 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
         pColExpr = pColExpr->pRight;
         assert( pColExpr!=0 );
       }
-      if( pColExpr->op==TK_COLUMN && (pTab = pColExpr->y.pTab)!=0 ){
+      if( pColExpr->op==TK_COLUMN
+       && ALWAYS( ExprUseYTab(pColExpr) )
+       && (pTab = pColExpr->y.pTab)!=0
+      ){
         /* For columns use the column name name */
         int iCol = pColExpr->iColumn;
         if( iCol<0 ) iCol = pTab->iPKey;
-        zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
+        zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
       }else if( pColExpr->op==TK_ID ){
         assert( !ExprHasProperty(pColExpr, EP_IntValue) );
         zName = pColExpr->u.zToken;
@@ -131833,7 +135368,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
       zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);
       if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);
     }
-    pCol->zName = zName;
+    pCol->zCnName = zName;
     pCol->hName = sqlite3StrIHash(zName);
     sqlite3ColumnPropertiesFromName(0, pCol);
     if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
@@ -131843,7 +135378,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
   sqlite3HashClear(&ht);
   if( db->mallocFailed ){
     for(j=0; j<i; j++){
-      sqlite3DbFree(db, aCol[j].zName);
+      sqlite3DbFree(db, aCol[j].zCnName);
     }
     sqlite3DbFree(db, aCol);
     *paCol = 0;
@@ -131887,24 +135422,29 @@ SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(
   a = pSelect->pEList->a;
   for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
     const char *zType;
-    int n, m;
+    i64 n, m;
+    pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);
     p = a[i].pExpr;
     zType = columnType(&sNC, p, 0, 0, 0);
     /* pCol->szEst = ... // Column size est for SELECT tables never used */
     pCol->affinity = sqlite3ExprAffinity(p);
     if( zType ){
       m = sqlite3Strlen30(zType);
-      n = sqlite3Strlen30(pCol->zName);
-      pCol->zName = sqlite3DbReallocOrFree(db, pCol->zName, n+m+2);
-      if( pCol->zName ){
-        memcpy(&pCol->zName[n+1], zType, m+1);
+      n = sqlite3Strlen30(pCol->zCnName);
+      pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2);
+      if( pCol->zCnName ){
+        memcpy(&pCol->zCnName[n+1], zType, m+1);
         pCol->colFlags |= COLFLAG_HASTYPE;
+      }else{
+        testcase( pCol->colFlags & COLFLAG_HASTYPE );
+        pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL);
       }
     }
     if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff;
     pColl = sqlite3ExprCollSeq(pParse, p);
-    if( pColl && pCol->zColl==0 ){
-      pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
+    if( pColl ){
+      assert( pTab->pIndex==0 );
+      sqlite3ColumnSetColl(db, pCol, pColl->zName);
     }
   }
   pTab->szTabRow = 1; /* Any non-zero value works */
@@ -132068,7 +135608,7 @@ static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
 */
 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
   ExprList *pOrderBy = p->pOrderBy;
-  int nOrderBy = p->pOrderBy->nExpr;
+  int nOrderBy = ALWAYS(pOrderBy!=0) ? pOrderBy->nExpr : 0;
   sqlite3 *db = pParse->db;
   KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
   if( pRet ){
@@ -132140,7 +135680,7 @@ static void generateWithRecursiveQuery(
   SrcList *pSrc = p->pSrc;      /* The FROM clause of the recursive query */
   int nCol = p->pEList->nExpr;  /* Number of columns in the recursive table */
   Vdbe *v = pParse->pVdbe;      /* The prepared statement under construction */
-  Select *pSetup = p->pPrior;   /* The setup query */
+  Select *pSetup;               /* The setup query */
   Select *pFirstRec;            /* Left-most recursive term */
   int addrTop;                  /* Top of the loop */
   int addrCont, addrBreak;      /* CONTINUE and BREAK addresses */
@@ -132224,7 +135764,6 @@ static void generateWithRecursiveQuery(
   ** iDistinct table.  pFirstRec is left pointing to the left-most
   ** recursive term of the CTE.
   */
-  pFirstRec = p;
   for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){
     if( pFirstRec->selFlags & SF_Aggregate ){
       sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
@@ -132403,12 +135942,8 @@ static int multiSelect(
   db = pParse->db;
   pPrior = p->pPrior;
   dest = *pDest;
-  if( pPrior->pOrderBy || pPrior->pLimit ){
-    sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
-      pPrior->pOrderBy!=0 ? "ORDER BY" : "LIMIT", selectOpName(p->op));
-    rc = 1;
-    goto multi_select_end;
-  }
+  assert( pPrior->pOrderBy==0 );
+  assert( pPrior->pLimit==0 );
 
   v = sqlite3GetVdbe(pParse);
   assert( v!=0 );  /* The VDBE already created by calling function */
@@ -132459,13 +135994,14 @@ static int multiSelect(
     switch( p->op ){
       case TK_ALL: {
         int addr = 0;
-        int nLimit;
+        int nLimit = 0;  /* Initialize to suppress harmless compiler warning */
         assert( !pPrior->pLimit );
         pPrior->iLimit = p->iLimit;
         pPrior->iOffset = p->iOffset;
         pPrior->pLimit = p->pLimit;
+        SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n"));
         rc = sqlite3Select(pParse, pPrior, &dest);
-        p->pLimit = 0;
+        pPrior->pLimit = 0;
         if( rc ){
           goto multi_select_end;
         }
@@ -132481,13 +136017,14 @@ static int multiSelect(
           }
         }
         ExplainQueryPlan((pParse, 1, "UNION ALL"));
+        SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n"));
         rc = sqlite3Select(pParse, p, &dest);
         testcase( rc!=SQLITE_OK );
         pDelete = p->pPrior;
         p->pPrior = pPrior;
         p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
-        if( pPrior->pLimit
-         && sqlite3ExprIsInteger(pPrior->pLimit->pLeft, &nLimit)
+        if( p->pLimit
+         && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit)
          && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
         ){
           p->nSelectRow = sqlite3LogEst((u64)nLimit);
@@ -132533,6 +136070,7 @@ static int multiSelect(
         */
         assert( !pPrior->pOrderBy );
         sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
+        SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));
         rc = sqlite3Select(pParse, pPrior, &uniondest);
         if( rc ){
           goto multi_select_end;
@@ -132551,7 +136089,8 @@ static int multiSelect(
         p->pLimit = 0;
         uniondest.eDest = op;
         ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
-                          selectOpName(p->op)));
+                          sqlite3SelectOpName(p->op)));
+        SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));
         rc = sqlite3Select(pParse, p, &uniondest);
         testcase( rc!=SQLITE_OK );
         assert( p->pOrderBy==0 );
@@ -132612,6 +136151,7 @@ static int multiSelect(
         /* Code the SELECTs to our left into temporary table "tab1".
         */
         sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
+        SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n"));
         rc = sqlite3Select(pParse, pPrior, &intersectdest);
         if( rc ){
           goto multi_select_end;
@@ -132627,7 +136167,8 @@ static int multiSelect(
         p->pLimit = 0;
         intersectdest.iSDParm = tab2;
         ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
-                          selectOpName(p->op)));
+                          sqlite3SelectOpName(p->op)));
+        SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n"));
         rc = sqlite3Select(pParse, p, &intersectdest);
         testcase( rc!=SQLITE_OK );
         pDelete = p->pPrior;
@@ -132688,6 +136229,7 @@ static int multiSelect(
     int nCol;                     /* Number of columns in result set */
 
     assert( p->pNext==0 );
+    assert( p->pEList!=0 );
     nCol = p->pEList->nExpr;
     pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
     if( !pKeyInfo ){
@@ -132722,7 +136264,11 @@ static int multiSelect(
 multi_select_end:
   pDest->iSdst = dest.iSdst;
   pDest->nSdst = dest.nSdst;
-  sqlite3SelectDelete(db, pDelete);
+  if( pDelete ){
+    sqlite3ParserAddCleanup(pParse,
+        (void(*)(sqlite3*,void*))sqlite3SelectDelete,
+        pDelete);
+  }
   return rc;
 }
 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
@@ -132736,7 +136282,8 @@ SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
     sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
   }else{
     sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
-      " do not have the same number of result columns", selectOpName(p->op));
+      " do not have the same number of result columns",
+      sqlite3SelectOpName(p->op));
   }
 }
 
@@ -132833,10 +136380,8 @@ static int generateOutputSubroutine(
     ** if it is the RHS of a row-value IN operator.
     */
     case SRT_Mem: {
-      if( pParse->nErr==0 ){
-        testcase( pIn->nSdst>1 );
-        sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
-      }
+      testcase( pIn->nSdst>1 );
+      sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
       /* The LIMIT clause will jump out of the loop for us */
       break;
     }
@@ -133036,6 +136581,7 @@ static int multiSelectOrderBy(
     for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
       struct ExprList_item *pItem;
       for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
+        assert( pItem!=0 );
         assert( pItem->u.x.iOrderByCol>0 );
         if( pItem->u.x.iOrderByCol==i ) break;
       }
@@ -133062,6 +136608,7 @@ static int multiSelectOrderBy(
     struct ExprList_item *pItem;
     aPermute[0] = nOrderBy;
     for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
+      assert( pItem!=0 );
       assert( pItem->u.x.iOrderByCol>0 );
       assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
       aPermute[i] = pItem->u.x.iOrderByCol - 1;
@@ -133128,7 +136675,7 @@ static int multiSelectOrderBy(
   sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
   sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
 
-  ExplainQueryPlan((pParse, 1, "MERGE (%s)", selectOpName(p->op)));
+  ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op)));
 
   /* Generate a coroutine to evaluate the SELECT statement to the
   ** left of the compound operator - the "A" select.
@@ -133262,6 +136809,9 @@ static int multiSelectOrderBy(
   p->pPrior = pPrior;
   pPrior->pNext = p;
 
+  sqlite3ExprListDelete(db, pPrior->pOrderBy);
+  pPrior->pOrderBy = 0;
+
   /*** TBD:  Insert subroutine calls to close cursors on incomplete
   **** subqueries ****/
   ExplainQueryPlanPop(pParse);
@@ -133316,9 +136866,12 @@ static Expr *substExpr(
    && pExpr->iTable==pSubst->iTable
    && !ExprHasProperty(pExpr, EP_FixedCol)
   ){
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
     if( pExpr->iColumn<0 ){
       pExpr->op = TK_NULL;
-    }else{
+    }else
+#endif
+    {
       Expr *pNew;
       Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
       Expr ifNullRow;
@@ -133338,10 +136891,14 @@ static Expr *substExpr(
         }
         testcase( ExprHasProperty(pCopy, EP_Subquery) );
         pNew = sqlite3ExprDup(db, pCopy, 0);
-        if( pNew && pSubst->isLeftJoin ){
+        if( db->mallocFailed ){
+          sqlite3ExprDelete(db, pNew);
+          return pExpr;
+        }
+        if( pSubst->isLeftJoin ){
           ExprSetProperty(pNew, EP_CanBeNull);
         }
-        if( pNew && ExprHasProperty(pExpr,EP_FromJoin) ){
+        if( ExprHasProperty(pExpr,EP_FromJoin) ){
           sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable);
         }
         sqlite3ExprDelete(db, pExpr);
@@ -133349,15 +136906,13 @@ static Expr *substExpr(
 
         /* Ensure that the expression now has an implicit collation sequence,
         ** just as it did when it was a column of a view or sub-query. */
-        if( pExpr ){
-          if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
-            CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
-            pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
-                (pColl ? pColl->zName : "BINARY")
-            );
-          }
-          ExprClearProperty(pExpr, EP_Collate);
+        if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE ){
+          CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
+          pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
+              (pColl ? pColl->zName : "BINARY")
+          );
         }
+        ExprClearProperty(pExpr, EP_Collate);
       }
     }
   }else{
@@ -133366,7 +136921,7 @@ static Expr *substExpr(
     }
     pExpr->pLeft = substExpr(pSubst, pExpr->pLeft);
     pExpr->pRight = substExpr(pSubst, pExpr->pRight);
-    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+    if( ExprUseXSelect(pExpr) ){
       substSelect(pSubst, pExpr->x.pSelect, 1);
     }else{
       substExprList(pSubst, pExpr->x.pList);
@@ -133398,7 +136953,7 @@ static void substSelect(
   int doPrior           /* Do substitutes on p->pPrior too */
 ){
   SrcList *pSrc;
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   int i;
   if( !p ) return;
   do{
@@ -133428,7 +136983,7 @@ static void substSelect(
 ** pSrcItem->colUsed mask.
 */
 static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
   pItem = pWalker->u.pSrcItem;
   if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
@@ -133438,7 +136993,7 @@ static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
 }
 static void recomputeColumnsUsed(
   Select *pSelect,                 /* The complete SELECT statement */
-  struct SrcList_item *pSrcItem    /* Which FROM clause item to recompute */
+  SrcItem *pSrcItem                /* Which FROM clause item to recompute */
 ){
   Walker w;
   if( NEVER(pSrcItem->pTab==0) ) return;
@@ -133451,6 +137006,103 @@ static void recomputeColumnsUsed(
 }
 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
 
+#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
+/*
+** Assign new cursor numbers to each of the items in pSrc. For each
+** new cursor number assigned, set an entry in the aCsrMap[] array
+** to map the old cursor number to the new:
+**
+**     aCsrMap[iOld+1] = iNew;
+**
+** The array is guaranteed by the caller to be large enough for all
+** existing cursor numbers in pSrc.  aCsrMap[0] is the array size.
+**
+** If pSrc contains any sub-selects, call this routine recursively
+** on the FROM clause of each such sub-select, with iExcept set to -1.
+*/
+static void srclistRenumberCursors(
+  Parse *pParse,                  /* Parse context */
+  int *aCsrMap,                   /* Array to store cursor mappings in */
+  SrcList *pSrc,                  /* FROM clause to renumber */
+  int iExcept                     /* FROM clause item to skip */
+){
+  int i;
+  SrcItem *pItem;
+  for(i=0, pItem=pSrc->a; i<pSrc->nSrc; i++, pItem++){
+    if( i!=iExcept ){
+      Select *p;
+      assert( pItem->iCursor < aCsrMap[0] );
+      if( !pItem->fg.isRecursive || aCsrMap[pItem->iCursor+1]==0 ){
+        aCsrMap[pItem->iCursor+1] = pParse->nTab++;
+      }
+      pItem->iCursor = aCsrMap[pItem->iCursor+1];
+      for(p=pItem->pSelect; p; p=p->pPrior){
+        srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
+      }
+    }
+  }
+}
+
+/*
+** *piCursor is a cursor number.  Change it if it needs to be mapped.
+*/
+static void renumberCursorDoMapping(Walker *pWalker, int *piCursor){
+  int *aCsrMap = pWalker->u.aiCol;
+  int iCsr = *piCursor;
+  if( iCsr < aCsrMap[0] && aCsrMap[iCsr+1]>0 ){
+    *piCursor = aCsrMap[iCsr+1];
+  }
+}
+
+/*
+** Expression walker callback used by renumberCursors() to update
+** Expr objects to match newly assigned cursor numbers.
+*/
+static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
+  int op = pExpr->op;
+  if( op==TK_COLUMN || op==TK_IF_NULL_ROW ){
+    renumberCursorDoMapping(pWalker, &pExpr->iTable);
+  }
+  if( ExprHasProperty(pExpr, EP_FromJoin) ){
+    renumberCursorDoMapping(pWalker, &pExpr->iRightJoinTable);
+  }
+  return WRC_Continue;
+}
+
+/*
+** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc)
+** of the SELECT statement passed as the second argument, and to each
+** cursor in the FROM clause of any FROM clause sub-selects, recursively.
+** Except, do not assign a new cursor number to the iExcept'th element in
+** the FROM clause of (*p). Update all expressions and other references
+** to refer to the new cursor numbers.
+**
+** Argument aCsrMap is an array that may be used for temporary working
+** space. Two guarantees are made by the caller:
+**
+**   * the array is larger than the largest cursor number used within the
+**     select statement passed as an argument, and
+**
+**   * the array entries for all cursor numbers that do *not* appear in
+**     FROM clauses of the select statement as described above are
+**     initialized to zero.
+*/
+static void renumberCursors(
+  Parse *pParse,                  /* Parse context */
+  Select *p,                      /* Select to renumber cursors within */
+  int iExcept,                    /* FROM clause item to skip */
+  int *aCsrMap                    /* Working space */
+){
+  Walker w;
+  srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept);
+  memset(&w, 0, sizeof(w));
+  w.u.aiCol = aCsrMap;
+  w.xExprCallback = renumberCursorsCb;
+  w.xSelectCallback = sqlite3SelectWalkNoop;
+  sqlite3WalkSelect(&w, p);
+}
+#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
+
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
 /*
 ** This routine attempts to flatten subqueries as a performance optimization.
@@ -133545,9 +137197,9 @@ static void recomputeColumnsUsed(
 **        (17c) every term within the subquery compound must have a FROM clause
 **        (17d) the outer query may not be
 **              (17d1) aggregate, or
-**              (17d2) DISTINCT, or
-**              (17d3) a join.
-**        (17e) the subquery may not contain window functions
+**              (17d2) DISTINCT
+**        (17e) the subquery may not contain window functions, and
+**        (17f) the subquery must not be the RHS of a LEFT JOIN.
 **
 **        The parent and sub-query may contain WHERE clauses. Subject to
 **        rules (11), (13) and (14), they may also contain ORDER BY,
@@ -133563,8 +137215,8 @@ static void recomputeColumnsUsed(
 **        syntax error and return a detailed message.
 **
 **  (18)  If the sub-query is a compound select, then all terms of the
-**        ORDER BY clause of the parent must be simple references to
-**        columns of the sub-query.
+**        ORDER BY clause of the parent must be copies of a term returned
+**        by the parent query.
 **
 **  (19)  If the subquery uses LIMIT then the outer query may not
 **        have a WHERE clause.
@@ -133580,9 +137232,8 @@ static void recomputeColumnsUsed(
 **
 **  (22)  The subquery may not be a recursive CTE.
 **
-**  (**)  Subsumed into restriction (17d3).  Was: If the outer query is
-**        a recursive CTE, then the sub-query may not be a compound query.
-**        This restriction is because transforming the
+**  (23)  If the outer query is a recursive CTE, then the sub-query may not be
+**        a compound query.  This restriction is because transforming the
 **        parent to a compound query confuses the code that handles
 **        recursive queries in multiSelect().
 **
@@ -133624,9 +137275,10 @@ static int flattenSubquery(
   int isLeftJoin = 0; /* True if pSub is the right side of a LEFT JOIN */
   int i;              /* Loop counter */
   Expr *pWhere;                    /* The WHERE clause */
-  struct SrcList_item *pSubitem;   /* The subquery */
+  SrcItem *pSubitem;               /* The subquery */
   sqlite3 *db = pParse->db;
   Walker w;                        /* Walker to persist agginfo data */
+  int *aCsrMap = 0;
 
   /* Check to see if flattening is permitted.  Return 0 if not.
   */
@@ -133722,13 +137374,14 @@ static int flattenSubquery(
     if( pSub->pOrderBy ){
       return 0;  /* Restriction (20) */
     }
-    if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
-      return 0; /* (17d1), (17d2), or (17d3) */
+    if( isAgg || (p->selFlags & SF_Distinct)!=0 || isLeftJoin>0 ){
+      return 0; /* (17d1), (17d2), or (17f) */
     }
     for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
       testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
       testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
       assert( pSub->pSrc!=0 );
+      assert( (pSub->selFlags & SF_Recursive)==0 );
       assert( pSub->pEList->nExpr==pSub1->pEList->nExpr );
       if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0    /* (17b) */
        || (pSub1->pPrior && pSub1->op!=TK_ALL)                 /* (17a) */
@@ -133749,15 +137402,16 @@ static int flattenSubquery(
         if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
       }
     }
-  }
 
-  /* Ex-restriction (23):
-  ** The only way that the recursive part of a CTE can contain a compound
-  ** subquery is for the subquery to be one term of a join.  But if the
-  ** subquery is a join, then the flattening has already been stopped by
-  ** restriction (17d3)
-  */
-  assert( (p->selFlags & SF_Recursive)==0 || pSub->pPrior==0 );
+    /* Restriction (23) */
+    if( (p->selFlags & SF_Recursive) ) return 0;
+
+    if( pSrc->nSrc>1 ){
+      if( pParse->nSelect>500 ) return 0;
+      aCsrMap = sqlite3DbMallocZero(db, ((i64)pParse->nTab+1)*sizeof(int));
+      if( aCsrMap ) aCsrMap[0] = pParse->nTab;
+    }
+  }
 
   /***** If we reach this point, flattening is permitted. *****/
   SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
@@ -133769,6 +137423,17 @@ static int flattenSubquery(
   testcase( i==SQLITE_DENY );
   pParse->zAuthContext = zSavedAuthContext;
 
+  /* Delete the transient structures associated with thesubquery */
+  pSub1 = pSubitem->pSelect;
+  sqlite3DbFree(db, pSubitem->zDatabase);
+  sqlite3DbFree(db, pSubitem->zName);
+  sqlite3DbFree(db, pSubitem->zAlias);
+  pSubitem->zDatabase = 0;
+  pSubitem->zName = 0;
+  pSubitem->zAlias = 0;
+  pSubitem->pSelect = 0;
+  assert( pSubitem->pOn==0 );
+
   /* If the sub-query is a compound SELECT statement, then (by restrictions
   ** 17 and 18 above) it must be a UNION ALL and the parent query must
   ** be of the form:
@@ -133807,18 +137472,23 @@ static int flattenSubquery(
     ExprList *pOrderBy = p->pOrderBy;
     Expr *pLimit = p->pLimit;
     Select *pPrior = p->pPrior;
+    Table *pItemTab = pSubitem->pTab;
+    pSubitem->pTab = 0;
     p->pOrderBy = 0;
-    p->pSrc = 0;
     p->pPrior = 0;
     p->pLimit = 0;
     pNew = sqlite3SelectDup(db, p, 0);
     p->pLimit = pLimit;
     p->pOrderBy = pOrderBy;
-    p->pSrc = pSrc;
     p->op = TK_ALL;
+    pSubitem->pTab = pItemTab;
     if( pNew==0 ){
       p->pPrior = pPrior;
     }else{
+      pNew->selId = ++pParse->nSelect;
+      if( aCsrMap && ALWAYS(db->mallocFailed==0) ){
+        renumberCursors(pParse, pNew, iFrom, aCsrMap);
+      }
       pNew->pPrior = pPrior;
       if( pPrior ) pPrior->pNext = pNew;
       pNew->pNext = p;
@@ -133826,24 +137496,13 @@ static int flattenSubquery(
       SELECTTRACE(2,pParse,p,("compound-subquery flattener"
                               " creates %u as peer\n",pNew->selId));
     }
-    if( db->mallocFailed ) return 1;
+    assert( pSubitem->pSelect==0 );
+  }
+  sqlite3DbFree(db, aCsrMap);
+  if( db->mallocFailed ){
+    pSubitem->pSelect = pSub1;
+    return 1;
   }
-
-  /* Begin flattening the iFrom-th entry of the FROM clause
-  ** in the outer query.
-  */
-  pSub = pSub1 = pSubitem->pSelect;
-
-  /* Delete the transient table structure associated with the
-  ** subquery
-  */
-  sqlite3DbFree(db, pSubitem->zDatabase);
-  sqlite3DbFree(db, pSubitem->zName);
-  sqlite3DbFree(db, pSubitem->zAlias);
-  pSubitem->zDatabase = 0;
-  pSubitem->zName = 0;
-  pSubitem->zAlias = 0;
-  pSubitem->pSelect = 0;
 
   /* Defer deleting the Table object associated with the
   ** subquery until code generation is
@@ -133856,8 +137515,10 @@ static int flattenSubquery(
     Table *pTabToDel = pSubitem->pTab;
     if( pTabToDel->nTabRef==1 ){
       Parse *pToplevel = sqlite3ParseToplevel(pParse);
-      pTabToDel->pNextZombie = pToplevel->pZombieTab;
-      pToplevel->pZombieTab = pTabToDel;
+      sqlite3ParserAddCleanup(pToplevel,
+         (void(*)(sqlite3*,void*))sqlite3DeleteTable,
+         pTabToDel);
+      testcase( pToplevel->earlyCleanup );
     }else{
       pTabToDel->nTabRef--;
     }
@@ -133877,6 +137538,7 @@ static int flattenSubquery(
   ** those references with expressions that resolve to the subquery FROM
   ** elements we are now copying in.
   */
+  pSub = pSub1;
   for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
     int nSubSrc;
     u8 jointype = 0;
@@ -133885,14 +137547,8 @@ static int flattenSubquery(
     nSubSrc = pSubSrc->nSrc;  /* Number of terms in subquery FROM clause */
     pSrc = pParent->pSrc;     /* FROM clause of the outer query */
 
-    if( pSrc ){
-      assert( pParent==p );  /* First time through the loop */
-      jointype = pSubitem->fg.jointype;
-    }else{
-      assert( pParent!=p );  /* 2nd and subsequent times through the loop */
-      pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
-      if( pSrc==0 ) break;
-      pParent->pSrc = pSrc;
+    if( pParent==p ){
+      jointype = pSubitem->fg.jointype;     /* First time through the loop */
     }
 
     /* The subquery uses a single slot of the FROM clause of the outer
@@ -134012,7 +137668,7 @@ static int flattenSubquery(
   sqlite3SelectDelete(db, pSub1);
 
 #if SELECTTRACE_ENABLED
-  if( sqlite3_unsupported_selecttrace & 0x100 ){
+  if( sqlite3SelectTrace & 0x100 ){
     SELECTTRACE(0x100,pParse,p,("After flattening:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -134029,8 +137685,10 @@ static int flattenSubquery(
 typedef struct WhereConst WhereConst;
 struct WhereConst {
   Parse *pParse;   /* Parsing context */
+  u8 *pOomFault;   /* Pointer to pParse->db->mallocFailed */
   int nConst;      /* Number for COLUMN=CONSTANT terms */
   int nChng;       /* Number of times a constant is propagated */
+  int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */
   Expr **apExpr;   /* [i*2] is COLUMN and [i*2+1] is VALUE */
 };
 
@@ -134069,6 +137727,9 @@ static void constInsert(
       return;  /* Already present.  Return without doing anything. */
     }
   }
+  if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
+    pConst->bHasAffBlob = 1;
+  }
 
   pConst->nConst++;
   pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
@@ -134089,7 +137750,7 @@ static void constInsert(
 */
 static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
   Expr *pRight, *pLeft;
-  if( pExpr==0 ) return;
+  if( NEVER(pExpr==0) ) return;
   if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
   if( pExpr->op==TK_AND ){
     findConstInWhere(pConst, pExpr->pRight);
@@ -134110,37 +137771,83 @@ static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
 }
 
 /*
-** This is a Walker expression callback.  pExpr is a candidate expression
-** to be replaced by a value.  If pExpr is equivalent to one of the
-** columns named in pWalker->u.pConst, then overwrite it with its
-** corresponding value.
+** This is a helper function for Walker callback propagateConstantExprRewrite().
+**
+** Argument pExpr is a candidate expression to be replaced by a value. If
+** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
+** then overwrite it with the corresponding value. Except, do not do so
+** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
+** is SQLITE_AFF_BLOB.
 */
-static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
+static int propagateConstantExprRewriteOne(
+  WhereConst *pConst,
+  Expr *pExpr,
+  int bIgnoreAffBlob
+){
   int i;
-  WhereConst *pConst;
+  if( pConst->pOomFault[0] ) return WRC_Prune;
   if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
   if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
     testcase( ExprHasProperty(pExpr, EP_FixedCol) );
     testcase( ExprHasProperty(pExpr, EP_FromJoin) );
     return WRC_Continue;
   }
-  pConst = pWalker->u.pConst;
   for(i=0; i<pConst->nConst; i++){
     Expr *pColumn = pConst->apExpr[i*2];
     if( pColumn==pExpr ) continue;
     if( pColumn->iTable!=pExpr->iTable ) continue;
     if( pColumn->iColumn!=pExpr->iColumn ) continue;
+    if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
+      break;
+    }
     /* A match is found.  Add the EP_FixedCol property */
     pConst->nChng++;
     ExprClearProperty(pExpr, EP_Leaf);
     ExprSetProperty(pExpr, EP_FixedCol);
     assert( pExpr->pLeft==0 );
     pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
+    if( pConst->pParse->db->mallocFailed ) return WRC_Prune;
     break;
   }
   return WRC_Prune;
 }
 
+/*
+** This is a Walker expression callback. pExpr is a node from the WHERE
+** clause of a SELECT statement. This function examines pExpr to see if
+** any substitutions based on the contents of pWalker->u.pConst should
+** be made to pExpr or its immediate children.
+**
+** A substitution is made if:
+**
+**   + pExpr is a column with an affinity other than BLOB that matches
+**     one of the columns in pWalker->u.pConst, or
+**
+**   + pExpr is a binary comparison operator (=, <=, >=, <, >) that
+**     uses an affinity other than TEXT and one of its immediate
+**     children is a column that matches one of the columns in
+**     pWalker->u.pConst.
+*/
+static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
+  WhereConst *pConst = pWalker->u.pConst;
+  assert( TK_GT==TK_EQ+1 );
+  assert( TK_LE==TK_EQ+2 );
+  assert( TK_LT==TK_EQ+3 );
+  assert( TK_GE==TK_EQ+4 );
+  if( pConst->bHasAffBlob ){
+    if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
+     || pExpr->op==TK_IS
+    ){
+      propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
+      if( pConst->pOomFault[0] ) return WRC_Prune;
+      if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
+        propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
+      }
+    }
+  }
+  return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
+}
+
 /*
 ** The WHERE-clause constant propagation optimization.
 **
@@ -134176,6 +137883,21 @@ static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
 ** routines know to generate the constant "123" instead of looking up the
 ** column value.  Also, to avoid collation problems, this optimization is
 ** only attempted if the "a=123" term uses the default BINARY collation.
+**
+** 2021-05-25 forum post 6a06202608: Another troublesome case is...
+**
+**    CREATE TABLE t1(x);
+**    INSERT INTO t1 VALUES(10.0);
+**    SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10;
+**
+** The query should return no rows, because the t1.x value is '10.0' not '10'
+** and '10.0' is not LIKE '10'.  But if we are not careful, the first WHERE
+** term "x=10" will cause the second WHERE term to become "10 LIKE 10",
+** resulting in a false positive.  To avoid this, constant propagation for
+** columns with BLOB affinity is only allowed if the constant is used with
+** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
+** type conversions to occur.  See logic associated with the bHasAffBlob flag
+** for details.
 */
 static int propagateConstants(
   Parse *pParse,   /* The parsing context */
@@ -134185,10 +137907,12 @@ static int propagateConstants(
   Walker w;
   int nChng = 0;
   x.pParse = pParse;
+  x.pOomFault = &pParse->db->mallocFailed;
   do{
     x.nConst = 0;
     x.nChng = 0;
     x.apExpr = 0;
+    x.bHasAffBlob = 0;
     findConstInWhere(&x, p->pWhere);
     if( x.nConst ){
       memset(&w, 0, sizeof(w));
@@ -134206,6 +137930,35 @@ static int propagateConstants(
   return nChng;
 }
 
+#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
+# if !defined(SQLITE_OMIT_WINDOWFUNC)
+/*
+** This function is called to determine whether or not it is safe to
+** push WHERE clause expression pExpr down to FROM clause sub-query
+** pSubq, which contains at least one window function. Return 1
+** if it is safe and the expression should be pushed down, or 0
+** otherwise.
+**
+** It is only safe to push the expression down if it consists only
+** of constants and copies of expressions that appear in the PARTITION
+** BY clause of all window function used by the sub-query. It is safe
+** to filter out entire partitions, but not rows within partitions, as
+** this may change the results of the window functions.
+**
+** At the time this function is called it is guaranteed that
+**
+**   * the sub-query uses only one distinct window frame, and
+**   * that the window frame has a PARTITION BY clase.
+*/
+static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
+  assert( pSubq->pWin->pPartition );
+  assert( (pSubq->selFlags & SF_MultiPart)==0 );
+  assert( pSubq->pPrior==0 );
+  return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
+}
+# endif /* SQLITE_OMIT_WINDOWFUNC */
+#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
+
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
 /*
 ** Make copies of relevant WHERE clause terms of the outer query into
@@ -134253,9 +138006,24 @@ static int propagateConstants(
 **       But if the (b2=2) term were to be pushed down into the bb subquery,
 **       then the (1,1,NULL) row would be suppressed.
 **
-**   (6) The inner query features one or more window-functions (since
-**       changes to the WHERE clause of the inner query could change the
-**       window over which window functions are calculated).
+**   (6) Window functions make things tricky as changes to the WHERE clause
+**       of the inner query could change the window over which window
+**       functions are calculated. Therefore, do not attempt the optimization
+**       if:
+**
+**     (6a) The inner query uses multiple incompatible window partitions.
+**
+**     (6b) The inner query is a compound and uses window-functions.
+**
+**     (6c) The WHERE clause does not consist entirely of constants and
+**          copies of expressions found in the PARTITION BY clause of
+**          all window-functions used by the sub-query. It is safe to
+**          filter out entire partitions, as this does not change the
+**          window over which any window-function is calculated.
+**
+**   (7) The inner query is a Common Table Expression (CTE) that should
+**       be materialized.  (This restriction is implemented in the calling
+**       routine.)
 **
 ** Return 0 if no changes are made and non-zero if one or more WHERE clause
 ** terms are duplicated into the subquery.
@@ -134269,13 +138037,17 @@ static int pushDownWhereTerms(
 ){
   Expr *pNew;
   int nChng = 0;
-  Select *pSel;
   if( pWhere==0 ) return 0;
-  if( pSubq->selFlags & SF_Recursive ) return 0;  /* restriction (2) */
+  if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ) return 0;
 
 #ifndef SQLITE_OMIT_WINDOWFUNC
-  for(pSel=pSubq; pSel; pSel=pSel->pPrior){
-    if( pSel->pWin ) return 0;    /* restriction (6) */
+  if( pSubq->pPrior ){
+    Select *pSel;
+    for(pSel=pSubq; pSel; pSel=pSel->pPrior){
+      if( pSel->pWin ) return 0;    /* restriction (6b) */
+    }
+  }else{
+    if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0;
   }
 #endif
 
@@ -134311,6 +138083,7 @@ static int pushDownWhereTerms(
   }
   if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
     nChng++;
+    pSubq->selFlags |= SF_PushDown;
     while( pSubq ){
       SubstContext x;
       pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
@@ -134321,6 +138094,14 @@ static int pushDownWhereTerms(
       x.isLeftJoin = 0;
       x.pEList = pSubq->pEList;
       pNew = substExpr(&x, pNew);
+#ifndef SQLITE_OMIT_WINDOWFUNC
+      if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){
+        /* Restriction 6c has prevented push-down in this case */
+        sqlite3ExprDelete(pParse->db, pNew);
+        nChng--;
+        break;
+      }
+#endif
       if( pSubq->selFlags & SF_Aggregate ){
         pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
       }else{
@@ -134351,7 +138132,7 @@ static int pushDownWhereTerms(
 */
 static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
   int eRet = WHERE_ORDERBY_NORMAL;      /* Return value */
-  ExprList *pEList = pFunc->x.pList;    /* Arguments to agg function */
+  ExprList *pEList;                     /* Arguments to agg function */
   const char *zFunc;                    /* Name of aggregate function pFunc */
   ExprList *pOrderBy;
   u8 sortFlags = 0;
@@ -134359,9 +138140,16 @@ static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
   assert( *ppMinMax==0 );
   assert( pFunc->op==TK_AGG_FUNCTION );
   assert( !IsWindowFunc(pFunc) );
-  if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){
+  assert( ExprUseXList(pFunc) );
+  pEList = pFunc->x.pList;
+  if( pEList==0
+   || pEList->nExpr!=1
+   || ExprHasProperty(pFunc, EP_WinFunc)
+   || OptimizationDisabled(db, SQLITE_MinMaxOpt)
+  ){
     return eRet;
   }
+  assert( !ExprHasProperty(pFunc, EP_IntValue) );
   zFunc = pFunc->u.zToken;
   if( sqlite3StrICmp(zFunc, "min")==0 ){
     eRet = WHERE_ORDERBY_MIN;
@@ -134389,7 +138177,13 @@ static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
 **
 ** where table is a database table, not a sub-select or view. If the query
 ** does match this pattern, then a pointer to the Table object representing
-** <tbl> is returned. Otherwise, 0 is returned.
+** <tbl> is returned. Otherwise, NULL is returned.
+**
+** This routine checks to see if it is safe to use the count optimization.
+** A correct answer is still obtained (though perhaps more slowly) if
+** this routine returns NULL when it could have returned a table pointer.
+** But returning the pointer when NULL should have been returned can
+** result in incorrect answers and/or crashes.  So, when in doubt, return NULL.
 */
 static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
   Table *pTab;
@@ -134397,19 +138191,26 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
 
   assert( !p->pGroupBy );
 
-  if( p->pWhere || p->pEList->nExpr!=1
-   || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
+  if( p->pWhere
+   || p->pEList->nExpr!=1
+   || p->pSrc->nSrc!=1
+   || p->pSrc->a[0].pSelect
+   || pAggInfo->nFunc!=1
   ){
     return 0;
   }
   pTab = p->pSrc->a[0].pTab;
+  assert( pTab!=0 );
+  assert( !IsView(pTab) );
+  if( !IsOrdinaryTable(pTab) ) return 0;
   pExpr = p->pEList->a[0].pExpr;
-  assert( pTab && !pTab->pSelect && pExpr );
-
-  if( IsVirtual(pTab) ) return 0;
+  assert( pExpr!=0 );
   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
-  if( NEVER(pAggInfo->nFunc==0) ) return 0;
+  if( pExpr->pAggInfo!=pAggInfo ) return 0;
   if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0;
+  assert( pAggInfo->aFunc[0].pFExpr==pExpr );
+  testcase( ExprHasProperty(pExpr, EP_Distinct) );
+  testcase( ExprHasProperty(pExpr, EP_WinFunc) );
   if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0;
 
   return pTab;
@@ -134422,24 +138223,27 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
 ** pFrom->pIndex and return SQLITE_OK.
 */
-SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
-  if( pFrom->pTab && pFrom->fg.isIndexedBy ){
-    Table *pTab = pFrom->pTab;
-    char *zIndexedBy = pFrom->u1.zIndexedBy;
-    Index *pIdx;
-    for(pIdx=pTab->pIndex;
-        pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
-        pIdx=pIdx->pNext
-    );
-    if( !pIdx ){
-      sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
-      pParse->checkSchema = 1;
-      return SQLITE_ERROR;
-    }
-    pFrom->pIBIndex = pIdx;
+SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){
+  Table *pTab = pFrom->pTab;
+  char *zIndexedBy = pFrom->u1.zIndexedBy;
+  Index *pIdx;
+  assert( pTab!=0 );
+  assert( pFrom->fg.isIndexedBy!=0 );
+
+  for(pIdx=pTab->pIndex;
+      pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
+      pIdx=pIdx->pNext
+  );
+  if( !pIdx ){
+    sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
+    pParse->checkSchema = 1;
+    return SQLITE_ERROR;
   }
+  assert( pFrom->fg.isCte==0 );
+  pFrom->u2.pIBIndex = pIdx;
   return SQLITE_OK;
 }
+
 /*
 ** Detect compound SELECT statements that use an ORDER BY clause with
 ** an alternative collating sequence.
@@ -134526,7 +138330,7 @@ static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){
 ** arguments.  If it does, leave an error message in pParse and return
 ** non-zero, since pFrom is not allowed to be a table-valued function.
 */
-static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){
+static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){
   if( pFrom->fg.isTabFunc ){
     sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
     return 1;
@@ -134547,21 +138351,22 @@ static int cannotBeFunction(Parse *pParse, struct SrcList_item *pFrom){
 */
 static struct Cte *searchWith(
   With *pWith,                    /* Current innermost WITH clause */
-  struct SrcList_item *pItem,     /* FROM clause element to resolve */
+  SrcItem *pItem,                 /* FROM clause element to resolve */
   With **ppContext                /* OUT: WITH clause return value belongs to */
 ){
-  const char *zName;
-  if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
-    With *p;
-    for(p=pWith; p; p=p->pOuter){
-      int i;
-      for(i=0; i<p->nCte; i++){
-        if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
-          *ppContext = p;
-          return &p->a[i];
-        }
+  const char *zName = pItem->zName;
+  With *p;
+  assert( pItem->zDatabase==0 );
+  assert( zName!=0 );
+  for(p=pWith; p; p=p->pOuter){
+    int i;
+    for(i=0; i<p->nCte; i++){
+      if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
+        *ppContext = p;
+        return &p->a[i];
       }
     }
+    if( p->bView ) break;
   }
   return 0;
 }
@@ -134571,52 +138376,83 @@ static struct Cte *searchWith(
 **
 ** This routine pushes the WITH clause passed as the second argument
 ** onto the top of the stack. If argument bFree is true, then this
-** WITH clause will never be popped from the stack. In this case it
-** should be freed along with the Parse object. In other cases, when
+** WITH clause will never be popped from the stack but should instead
+** be freed along with the Parse object. In other cases, when
 ** bFree==0, the With object will be freed along with the SELECT
 ** statement with which it is associated.
+**
+** This routine returns a copy of pWith.  Or, if bFree is true and
+** the pWith object is destroyed immediately due to an OOM condition,
+** then this routine return NULL.
+**
+** If bFree is true, do not continue to use the pWith pointer after
+** calling this routine,  Instead, use only the return value.
 */
-SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
-  assert( bFree==0 || (pParse->pWith==0 && pParse->pWithToFree==0) );
+SQLITE_PRIVATE With *sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
   if( pWith ){
-    assert( pParse->pWith!=pWith );
-    pWith->pOuter = pParse->pWith;
-    pParse->pWith = pWith;
-    if( bFree ) pParse->pWithToFree = pWith;
+    if( bFree ){
+      pWith = (With*)sqlite3ParserAddCleanup(pParse,
+                      (void(*)(sqlite3*,void*))sqlite3WithDelete,
+                      pWith);
+      if( pWith==0 ) return 0;
+    }
+    if( pParse->nErr==0 ){
+      assert( pParse->pWith!=pWith );
+      pWith->pOuter = pParse->pWith;
+      pParse->pWith = pWith;
+    }
   }
+  return pWith;
 }
 
 /*
 ** This function checks if argument pFrom refers to a CTE declared by
-** a WITH clause on the stack currently maintained by the parser. And,
-** if currently processing a CTE expression, if it is a recursive
-** reference to the current CTE.
+** a WITH clause on the stack currently maintained by the parser (on the
+** pParse->pWith linked list).  And if currently processing a CTE
+** CTE expression, through routine checks to see if the reference is
+** a recursive reference to the CTE.
 **
-** If pFrom falls into either of the two categories above, pFrom->pTab
-** and other fields are populated accordingly. The caller should check
-** (pFrom->pTab!=0) to determine whether or not a successful match
-** was found.
+** If pFrom matches a CTE according to either of these two above, pFrom->pTab
+** and other fields are populated accordingly.
 **
-** Whether or not a match is found, SQLITE_OK is returned if no error
-** occurs. If an error does occur, an error message is stored in the
-** parser and some error code other than SQLITE_OK returned.
+** Return 0 if no match is found.
+** Return 1 if a match is found.
+** Return 2 if an error condition is detected.
 */
-static int withExpand(
-  Walker *pWalker,
-  struct SrcList_item *pFrom
+static int resolveFromTermToCte(
+  Parse *pParse,                  /* The parsing context */
+  Walker *pWalker,                /* Current tree walker */
+  SrcItem *pFrom                  /* The FROM clause term to check */
 ){
-  Parse *pParse = pWalker->pParse;
-  sqlite3 *db = pParse->db;
-  struct Cte *pCte;               /* Matched CTE (or NULL if no match) */
-  With *pWith;                    /* WITH clause that pCte belongs to */
+  Cte *pCte;               /* Matched CTE (or NULL if no match) */
+  With *pWith;             /* The matching WITH */
 
   assert( pFrom->pTab==0 );
+  if( pParse->pWith==0 ){
+    /* There are no WITH clauses in the stack.  No match is possible */
+    return 0;
+  }
   if( pParse->nErr ){
-    return SQLITE_ERROR;
+    /* Prior errors might have left pParse->pWith in a goofy state, so
+    ** go no further. */
+    return 0;
+  }
+  if( pFrom->zDatabase!=0 ){
+    /* The FROM term contains a schema qualifier (ex: main.t1) and so
+    ** it cannot possibly be a CTE reference. */
+    return 0;
+  }
+  if( pFrom->fg.notCte ){
+    /* The FROM term is specifically excluded from matching a CTE.
+    **   (1)  It is part of a trigger that used to have zDatabase but had
+    **        zDatabase removed by sqlite3FixTriggerStep().
+    **   (2)  This is the first term in the FROM clause of an UPDATE.
+    */
+    return 0;
   }
-
   pCte = searchWith(pParse->pWith, pFrom, &pWith);
   if( pCte ){
+    sqlite3 *db = pParse->db;
     Table *pTab;
     ExprList *pEList;
     Select *pSel;
@@ -134625,6 +138461,7 @@ static int withExpand(
     int bMayRecursive;            /* True if compound joined by UNION [ALL] */
     With *pSavedWith;             /* Initial value of pParse->pWith */
     int iRecTab = -1;             /* Cursor for recursive table */
+    CteUse *pCteUse;
 
     /* If pCte->zCteErr is non-NULL at this point, then this is an illegal
     ** recursive reference to CTE pCte. Leave an error in pParse and return
@@ -134632,21 +138469,44 @@ static int withExpand(
     ** In this case, proceed.  */
     if( pCte->zCteErr ){
       sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
-      return SQLITE_ERROR;
+      return 2;
     }
-    if( cannotBeFunction(pParse, pFrom) ) return SQLITE_ERROR;
+    if( cannotBeFunction(pParse, pFrom) ) return 2;
 
     assert( pFrom->pTab==0 );
-    pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
-    if( pTab==0 ) return WRC_Abort;
+    pTab = sqlite3DbMallocZero(db, sizeof(Table));
+    if( pTab==0 ) return 2;
+    pCteUse = pCte->pUse;
+    if( pCteUse==0 ){
+      pCte->pUse = pCteUse = sqlite3DbMallocZero(db, sizeof(pCteUse[0]));
+      if( pCteUse==0
+       || sqlite3ParserAddCleanup(pParse,sqlite3DbFree,pCteUse)==0
+      ){
+        sqlite3DbFree(db, pTab);
+        return 2;
+      }
+      pCteUse->eM10d = pCte->eM10d;
+    }
+    pFrom->pTab = pTab;
     pTab->nTabRef = 1;
     pTab->zName = sqlite3DbStrDup(db, pCte->zName);
     pTab->iPKey = -1;
     pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
     pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
     pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
-    if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;
+    if( db->mallocFailed ) return 2;
+    pFrom->pSelect->selFlags |= SF_CopyCte;
     assert( pFrom->pSelect );
+    if( pFrom->fg.isIndexedBy ){
+      sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
+      return 2;
+    }
+    pFrom->fg.isCte = 1;
+    pFrom->u2.pCteUse = pCteUse;
+    pCteUse->nUse++;
+    if( pCteUse->nUse>=2 && pCteUse->eM10d==M10d_Any ){
+      pCteUse->eM10d = M10d_Yes;
+    }
 
     /* Check if this is a recursive CTE. */
     pRecTerm = pSel = pFrom->pSelect;
@@ -134656,7 +138516,7 @@ static int withExpand(
       SrcList *pSrc = pRecTerm->pSrc;
       assert( pRecTerm->pPrior!=0 );
       for(i=0; i<pSrc->nSrc; i++){
-        struct SrcList_item *pItem = &pSrc->a[i];
+        SrcItem *pItem = &pSrc->a[i];
         if( pItem->zDatabase==0
          && pItem->zName!=0
          && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
@@ -134668,7 +138528,7 @@ static int withExpand(
             sqlite3ErrorMsg(pParse,
                "multiple references to recursive table: %s", pCte->zName
             );
-            return SQLITE_ERROR;
+            return 2;
           }
           pRecTerm->selFlags |= SF_Recursive;
           if( iRecTab<0 ) iRecTab = pParse->nTab++;
@@ -134683,16 +138543,24 @@ static int withExpand(
     pSavedWith = pParse->pWith;
     pParse->pWith = pWith;
     if( pSel->selFlags & SF_Recursive ){
+      int rc;
       assert( pRecTerm!=0 );
       assert( (pRecTerm->selFlags & SF_Recursive)==0 );
       assert( pRecTerm->pNext!=0 );
       assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 );
       assert( pRecTerm->pWith==0 );
       pRecTerm->pWith = pSel->pWith;
-      sqlite3WalkSelect(pWalker, pRecTerm);
+      rc = sqlite3WalkSelect(pWalker, pRecTerm);
       pRecTerm->pWith = 0;
+      if( rc ){
+        pParse->pWith = pSavedWith;
+        return 2;
+      }
     }else{
-      sqlite3WalkSelect(pWalker, pSel);
+      if( sqlite3WalkSelect(pWalker, pSel) ){
+        pParse->pWith = pSavedWith;
+        return 2;
+      }
     }
     pParse->pWith = pWith;
 
@@ -134704,7 +138572,7 @@ static int withExpand(
             pCte->zName, pEList->nExpr, pCte->pCols->nExpr
         );
         pParse->pWith = pSavedWith;
-        return SQLITE_ERROR;
+        return 2;
       }
       pEList = pCte->pCols;
     }
@@ -134720,9 +138588,9 @@ static int withExpand(
     }
     pCte->zCteErr = 0;
     pParse->pWith = pSavedWith;
+    return 1;  /* Success */
   }
-
-  return SQLITE_OK;
+  return 0;  /* No match */
 }
 #endif
 
@@ -134735,7 +138603,7 @@ static int withExpand(
 ** sqlite3SelectExpand() when walking a SELECT tree to resolve table
 ** names and other FROM clause elements.
 */
-static void selectPopWith(Walker *pWalker, Select *p){
+SQLITE_PRIVATE void sqlite3SelectPopWith(Walker *pWalker, Select *p){
   Parse *pParse = pWalker->pParse;
   if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
     With *pWith = findRightmost(p)->pWith;
@@ -134745,8 +138613,6 @@ static void selectPopWith(Walker *pWalker, Select *p){
     }
   }
 }
-#else
-#define selectPopWith 0
 #endif
 
 /*
@@ -134756,7 +138622,7 @@ static void selectPopWith(Walker *pWalker, Select *p){
 ** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
 ** SQLITE_NOMEM.
 */
-SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFrom){
+SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
   Select *pSel = pFrom->pSelect;
   Table *pTab;
 
@@ -134773,7 +138639,13 @@ SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFr
   sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
   pTab->iPKey = -1;
   pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
-  pTab->tabFlags |= TF_Ephemeral;
+#ifndef SQLITE_ALLOW_ROWID_IN_VIEW
+  /* The usual case - do not allow ROWID on a subquery */
+  pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
+#else
+  pTab->tabFlags |= TF_Ephemeral;  /* Legacy compatibility mode */
+#endif
+
 
   return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
 }
@@ -134804,10 +138676,10 @@ SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, struct SrcList_item *pFr
 */
 static int selectExpander(Walker *pWalker, Select *p){
   Parse *pParse = pWalker->pParse;
-  int i, j, k;
+  int i, j, k, rc;
   SrcList *pTabList;
   ExprList *pEList;
-  struct SrcList_item *pFrom;
+  SrcItem *pFrom;
   sqlite3 *db = pParse->db;
   Expr *pE, *pRight, *pExpr;
   u16 selFlags = p->selFlags;
@@ -134827,6 +138699,15 @@ static int selectExpander(Walker *pWalker, Select *p){
   }
   pTabList = p->pSrc;
   pEList = p->pEList;
+  if( pParse->pWith && (p->selFlags & SF_View) ){
+    if( p->pWith==0 ){
+      p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With));
+      if( p->pWith==0 ){
+        return WRC_Abort;
+      }
+    }
+    p->pWith->bView = 1;
+  }
   sqlite3WithPush(pParse, p->pWith, 0);
 
   /* Make sure cursor numbers have been assigned to all entries in
@@ -134843,10 +138724,6 @@ static int selectExpander(Walker *pWalker, Select *p){
     assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
     if( pFrom->pTab ) continue;
     assert( pFrom->fg.isRecursive==0 );
-#ifndef SQLITE_OMIT_CTE
-    if( withExpand(pWalker, pFrom) ) return WRC_Abort;
-    if( pFrom->pTab ) {} else
-#endif
     if( pFrom->zName==0 ){
 #ifndef SQLITE_OMIT_SUBQUERY
       Select *pSel = pFrom->pSelect;
@@ -134855,6 +138732,12 @@ static int selectExpander(Walker *pWalker, Select *p){
       assert( pFrom->pTab==0 );
       if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
       if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
+#endif
+#ifndef SQLITE_OMIT_CTE
+    }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
+      if( rc>1 ) return WRC_Abort;
+      pTab = pFrom->pTab;
+      assert( pTab!=0 );
 #endif
     }else{
       /* An ordinary table or view name in the FROM clause */
@@ -134872,26 +138755,31 @@ static int selectExpander(Walker *pWalker, Select *p){
         return WRC_Abort;
       }
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
-      if( IsVirtual(pTab) || pTab->pSelect ){
+      if( !IsOrdinaryTable(pTab) ){
         i16 nCol;
         u8 eCodeOrig = pWalker->eCode;
         if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
         assert( pFrom->pSelect==0 );
-        if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){
-          sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
-            pTab->zName);
+        if( IsView(pTab) ){
+          if( (db->flags & SQLITE_EnableView)==0
+           && pTab->pSchema!=db->aDb[1].pSchema
+          ){
+            sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
+              pTab->zName);
+          }
+          pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
         }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-        if( IsVirtual(pTab)
+        else if( ALWAYS(IsVirtual(pTab))
          && pFrom->fg.fromDDL
-         && ALWAYS(pTab->pVTable!=0)
-         && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
+         && ALWAYS(pTab->u.vtab.p!=0)
+         && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
         ){
           sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
                                   pTab->zName);
         }
+        assert( SQLITE_VTABRISK_Normal==1 && SQLITE_VTABRISK_High==2 );
 #endif
-        pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
         nCol = pTab->nCol;
         pTab->nCol = -1;
         pWalker->eCode = 1;  /* Turn on Select.selId renumbering */
@@ -134903,7 +138791,7 @@ static int selectExpander(Walker *pWalker, Select *p){
     }
 
     /* Locate the index named by the INDEXED BY clause, if any. */
-    if( sqlite3IndexedByLookup(pParse, pFrom) ){
+    if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){
       return WRC_Abort;
     }
   }
@@ -134991,7 +138879,7 @@ static int selectExpander(Walker *pWalker, Select *p){
             zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
           }
           for(j=0; j<pTab->nCol; j++){
-            char *zName = pTab->aCol[j].zName;
+            char *zName = pTab->aCol[j].zCnName;
             char *zColname;  /* The computed column name */
             char *zToFree;   /* Malloced string that needs to be freed */
             Token sColname;  /* Computed column name as a token */
@@ -135122,7 +139010,7 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
     sqlite3WalkSelect(&w, pSelect);
   }
   w.xSelectCallback = selectExpander;
-  w.xSelectCallback2 = selectPopWith;
+  w.xSelectCallback2 = sqlite3SelectPopWith;
   w.eCode = 0;
   sqlite3WalkSelect(&w, pSelect);
 }
@@ -135146,7 +139034,7 @@ static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
   Parse *pParse;
   int i;
   SrcList *pTabList;
-  struct SrcList_item *pFrom;
+  SrcItem *pFrom;
 
   assert( p->selFlags & SF_Resolved );
   if( p->selFlags & SF_HasTypeInfo ) return;
@@ -135248,15 +139136,17 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
   for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
     if( pFunc->iDistinct>=0 ){
       Expr *pE = pFunc->pFExpr;
-      assert( !ExprHasProperty(pE, EP_xIsSelect) );
+      assert( ExprUseXList(pE) );
       if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
         sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
            "argument");
         pFunc->iDistinct = -1;
       }else{
         KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
-        sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
-                          (char*)pKeyInfo, P4_KEYINFO);
+        pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
+            pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO);
+        ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
+                          pFunc->pFunc->zName));
       }
     }
   }
@@ -135271,8 +139161,9 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
   int i;
   struct AggInfo_func *pF;
   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
-    ExprList *pList = pF->pFExpr->x.pList;
-    assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
+    ExprList *pList;
+    assert( ExprUseXList(pF->pFExpr) );
+    pList = pF->pFExpr->x.pList;
     sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
     sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
   }
@@ -135288,7 +139179,12 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
 ** registers if register regAcc contains 0. The caller will take care
 ** of setting and clearing regAcc.
 */
-static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
+static void updateAccumulator(
+  Parse *pParse,
+  int regAcc,
+  AggInfo *pAggInfo,
+  int eDistinctType
+){
   Vdbe *v = pParse->pVdbe;
   int i;
   int regHit = 0;
@@ -135301,9 +139197,10 @@ static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
     int nArg;
     int addrNext = 0;
     int regAgg;
-    ExprList *pList = pF->pFExpr->x.pList;
-    assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
+    ExprList *pList;
+    assert( ExprUseXList(pF->pFExpr) );
     assert( !IsWindowFunc(pF->pFExpr) );
+    pList = pF->pFExpr->x.pList;
     if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){
       Expr *pFilter = pF->pFExpr->y.pWin->pFilter;
       if( pAggInfo->nAccumulator
@@ -135334,13 +139231,12 @@ static void updateAccumulator(Parse *pParse, int regAcc, AggInfo *pAggInfo){
       nArg = 0;
       regAgg = 0;
     }
-    if( pF->iDistinct>=0 ){
+    if( pF->iDistinct>=0 && pList ){
       if( addrNext==0 ){
         addrNext = sqlite3VdbeMakeLabel(pParse);
       }
-      testcase( nArg==0 );  /* Error condition */
-      testcase( nArg>1 );   /* Also an error */
-      codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
+      pF->iDistinct = codeDistinct(pParse, eDistinctType,
+          pF->iDistinct, addrNext, pList, regAgg);
     }
     if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
       CollSeq *pColl = 0;
@@ -135392,7 +139288,7 @@ static void explainSimpleCount(
 ){
   if( pParse->explain==2 ){
     int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
-    sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
+    sqlite3VdbeExplain(pParse, 0, "SCAN %s%s%s",
         pTab->zName,
         bCover ? " USING COVERING INDEX " : "",
         bCover ? pIdx->zName : ""
@@ -135417,7 +139313,17 @@ static void explainSimpleCount(
 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
   if( pExpr->op!=TK_AND ){
     Select *pS = pWalker->u.pSelect;
-    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
+    /* This routine is called before the HAVING clause of the current
+    ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
+    ** here, it indicates that the expression is a correlated reference to a
+    ** column from an outer aggregate query, or an aggregate function that
+    ** belongs to an outer query. Do not move the expression to the WHERE
+    ** clause in this obscure case, as doing so may corrupt the outer Select
+    ** statements AggInfo structure.  */
+    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
+     && ExprAlwaysFalse(pExpr)==0
+     && pExpr->pAggInfo==0
+    ){
       sqlite3 *db = pWalker->pParse->db;
       Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
       if( pNew ){
@@ -135456,7 +139362,7 @@ static void havingToWhere(Parse *pParse, Select *p){
   sWalker.u.pSelect = p;
   sqlite3WalkExpr(&sWalker, p->pHaving);
 #if SELECTTRACE_ENABLED
-  if( sWalker.eCode && (sqlite3_unsupported_selecttrace & 0x100)!=0 ){
+  if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
     SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -135468,11 +139374,13 @@ static void havingToWhere(Parse *pParse, Select *p){
 ** If it is, then return the SrcList_item for the prior view.  If it is not,
 ** then return 0.
 */
-static struct SrcList_item *isSelfJoinView(
+static SrcItem *isSelfJoinView(
   SrcList *pTabList,           /* Search for self-joins in this FROM clause */
-  struct SrcList_item *pThis   /* Search for prior reference to this subquery */
+  SrcItem *pThis               /* Search for prior reference to this subquery */
 ){
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
+  assert( pThis->pSelect!=0 );
+  if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
   for(pItem = pTabList->a; pItem<pThis; pItem++){
     Select *pS1;
     if( pItem->pSelect==0 ) continue;
@@ -135488,9 +139396,7 @@ static struct SrcList_item *isSelfJoinView(
       ** names in the same FROM clause. */
       continue;
     }
-    if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1)
-     || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1)
-    ){
+    if( pItem->pSelect->selFlags & SF_PushDown ){
       /* The view was modified by some other optimization such as
       ** pushDownWhereTerms() */
       continue;
@@ -135500,6 +139406,15 @@ static struct SrcList_item *isSelfJoinView(
   return 0;
 }
 
+/*
+** Deallocate a single AggInfo object
+*/
+static void agginfoFree(sqlite3 *db, AggInfo *p){
+  sqlite3DbFree(db, p->aCol);
+  sqlite3DbFree(db, p->aFunc);
+  sqlite3DbFreeNN(db, p);
+}
+
 #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
 /*
 ** Attempt to transform a query of the form
@@ -135531,7 +139446,9 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   if( p->pGroupBy ) return 0;
   pExpr = p->pEList->a[0].pExpr;
   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;        /* Result is an aggregate */
+  assert( ExprUseUToken(pExpr) );
   if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0;  /* Is count() */
+  assert( ExprUseXList(pExpr) );
   if( pExpr->x.pList!=0 ) return 0;                 /* Must be count(*) */
   if( p->pSrc->nSrc!=1 ) return 0;                  /* One table in FROM  */
   pSub = p->pSrc->a[0].pSelect;
@@ -135578,7 +139495,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   p->selFlags &= ~SF_Aggregate;
 
 #if SELECTTRACE_ENABLED
-  if( sqlite3_unsupported_selecttrace & 0x400 ){
+  if( sqlite3SelectTrace & 0x400 ){
     SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -135631,7 +139548,7 @@ SQLITE_PRIVATE int sqlite3Select(
   if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
 #if SELECTTRACE_ENABLED
   SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
-  if( sqlite3_unsupported_selecttrace & 0x100 ){
+  if( sqlite3SelectTrace & 0x100 ){
     sqlite3TreeViewSelect(0, p, 0);
   }
 #endif
@@ -135645,8 +139562,19 @@ SQLITE_PRIVATE int sqlite3Select(
            pDest->eDest==SRT_Except     || pDest->eDest==SRT_Discard ||
            pDest->eDest==SRT_DistQueue  || pDest->eDest==SRT_DistFifo );
     /* All of these destinations are also able to ignore the ORDER BY clause */
-    sqlite3ExprListDelete(db, p->pOrderBy);
-    p->pOrderBy = 0;
+    if( p->pOrderBy ){
+#if SELECTTRACE_ENABLED
+      SELECTTRACE(1,pParse,p, ("dropping superfluous ORDER BY:\n"));
+      if( sqlite3SelectTrace & 0x100 ){
+        sqlite3TreeViewExprList(0, p->pOrderBy, 0, "ORDERBY");
+      }
+#endif
+      sqlite3ParserAddCleanup(pParse,
+        (void(*)(sqlite3*,void*))sqlite3ExprListDelete,
+        p->pOrderBy);
+      testcase( pParse->earlyCleanup );
+      p->pOrderBy = 0;
+    }
     p->selFlags &= ~SF_Distinct;
     p->selFlags |= SF_NoopOrderBy;
   }
@@ -135656,20 +139584,25 @@ SQLITE_PRIVATE int sqlite3Select(
   }
   assert( p->pEList!=0 );
 #if SELECTTRACE_ENABLED
-  if( sqlite3_unsupported_selecttrace & 0x104 ){
+  if( sqlite3SelectTrace & 0x104 ){
     SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
 #endif
 
-  /* If the SF_UpdateFrom flag is set, then this function is being called
+  /* If the SF_UFSrcCheck flag is set, then this function is being called
   ** as part of populating the temp table for an UPDATE...FROM statement.
   ** In this case, it is an error if the target object (pSrc->a[0]) name
-  ** or alias is duplicated within FROM clause (pSrc->a[1..n]).  */
-  if( p->selFlags & SF_UpdateFrom ){
-    struct SrcList_item *p0 = &p->pSrc->a[0];
+  ** or alias is duplicated within FROM clause (pSrc->a[1..n]).
+  **
+  ** Postgres disallows this case too. The reason is that some other
+  ** systems handle this case differently, and not all the same way,
+  ** which is just confusing. To avoid this, we follow PG's lead and
+  ** disallow it altogether.  */
+  if( p->selFlags & SF_UFSrcCheck ){
+    SrcItem *p0 = &p->pSrc->a[0];
     for(i=1; i<p->pSrc->nSrc; i++){
-      struct SrcList_item *p1 = &p->pSrc->a[i];
+      SrcItem *p1 = &p->pSrc->a[i];
       if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){
         sqlite3ErrorMsg(pParse,
             "target object/alias may not appear in FROM clause: %s",
@@ -135678,20 +139611,25 @@ SQLITE_PRIVATE int sqlite3Select(
         goto select_end;
       }
     }
+
+    /* Clear the SF_UFSrcCheck flag. The check has already been performed,
+    ** and leaving this flag set can cause errors if a compound sub-query
+    ** in p->pSrc is flattened into this query and this function called
+    ** again as part of compound SELECT processing.  */
+    p->selFlags &= ~SF_UFSrcCheck;
   }
 
   if( pDest->eDest==SRT_Output ){
-    generateColumnNames(pParse, p);
+    sqlite3GenerateColumnNames(pParse, p);
   }
 
 #ifndef SQLITE_OMIT_WINDOWFUNC
-  rc = sqlite3WindowRewrite(pParse, p);
-  if( rc ){
+  if( sqlite3WindowRewrite(pParse, p) ){
     assert( db->mallocFailed || pParse->nErr>0 );
     goto select_end;
   }
 #if SELECTTRACE_ENABLED
-  if( p->pWin && (sqlite3_unsupported_selecttrace & 0x108)!=0 ){
+  if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){
     SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -135707,7 +139645,7 @@ SQLITE_PRIVATE int sqlite3Select(
   */
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
   for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
-    struct SrcList_item *pItem = &pTabList->a[i];
+    SrcItem *pItem = &pTabList->a[i];
     Select *pSub = pItem->pSelect;
     Table *pTab = pItem->pTab;
 
@@ -135750,6 +139688,39 @@ SQLITE_PRIVATE int sqlite3Select(
     if( (pSub->selFlags & SF_Aggregate)!=0 ) continue;
     assert( pSub->pGroupBy==0 );
 
+    /* If a FROM-clause subquery has an ORDER BY clause that is not
+    ** really doing anything, then delete it now so that it does not
+    ** interfere with query flattening.  See the discussion at
+    ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a
+    **
+    ** Beware of these cases where the ORDER BY clause may not be safely
+    ** omitted:
+    **
+    **    (1)   There is also a LIMIT clause
+    **    (2)   The subquery was added to help with window-function
+    **          processing
+    **    (3)   The subquery is in the FROM clause of an UPDATE
+    **    (4)   The outer query uses an aggregate function other than
+    **          the built-in count(), min(), or max().
+    **    (5)   The ORDER BY isn't going to accomplish anything because
+    **          one of:
+    **            (a)  The outer query has a different ORDER BY clause
+    **            (b)  The subquery is part of a join
+    **          See forum post 062d576715d277c8
+    */
+    if( pSub->pOrderBy!=0
+     && (p->pOrderBy!=0 || pTabList->nSrc>1)      /* Condition (5) */
+     && pSub->pLimit==0                           /* Condition (1) */
+     && (pSub->selFlags & SF_OrderByReqd)==0      /* Condition (2) */
+     && (p->selFlags & SF_OrderByReqd)==0         /* Condition (3) and (4) */
+     && OptimizationEnabled(db, SQLITE_OmitOrderBy)
+    ){
+      SELECTTRACE(0x100,pParse,p,
+                ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i+1));
+      sqlite3ExprListDelete(db, pSub->pOrderBy);
+      pSub->pOrderBy = 0;
+    }
+
     /* If the outer query contains a "complex" result set (that is,
     ** if the result set of the outer query uses functions or subqueries)
     ** and if the subquery contains an ORDER BY clause and if
@@ -135798,7 +139769,7 @@ SQLITE_PRIVATE int sqlite3Select(
     rc = multiSelect(pParse, p, pDest);
 #if SELECTTRACE_ENABLED
     SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
-    if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
+    if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
       sqlite3TreeViewSelect(0, p, 0);
     }
 #endif
@@ -135812,12 +139783,13 @@ SQLITE_PRIVATE int sqlite3Select(
   ** as the equivalent optimization will be handled by query planner in
   ** sqlite3WhereBegin().
   */
-  if( pTabList->nSrc>1
+  if( p->pWhere!=0
+   && p->pWhere->op==TK_AND
    && OptimizationEnabled(db, SQLITE_PropagateConst)
    && propagateConstants(pParse, p)
   ){
 #if SELECTTRACE_ENABLED
-    if( sqlite3_unsupported_selecttrace & 0x100 ){
+    if( sqlite3SelectTrace & 0x100 ){
       SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
       sqlite3TreeViewSelect(0, p, 0);
     }
@@ -135841,7 +139813,8 @@ SQLITE_PRIVATE int sqlite3Select(
   ** (2) Generate code for all sub-queries
   */
   for(i=0; i<pTabList->nSrc; i++){
-    struct SrcList_item *pItem = &pTabList->a[i];
+    SrcItem *pItem = &pTabList->a[i];
+    SrcItem *pPrior;
     SelectDest dest;
     Select *pSub;
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
@@ -135874,19 +139847,8 @@ SQLITE_PRIVATE int sqlite3Select(
     pSub = pItem->pSelect;
     if( pSub==0 ) continue;
 
-    /* The code for a subquery should only be generated once, though it is
-    ** technically harmless for it to be generated multiple times. The
-    ** following assert() will detect if something changes to cause
-    ** the same subquery to be coded multiple times, as a signal to the
-    ** developers to try to optimize the situation.
-    **
-    ** Update 2019-07-24:
-    ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
-    ** The dbsqlfuzz fuzzer found a case where the same subquery gets
-    ** coded twice.  So this assert() now becomes a testcase().  It should
-    ** be very rare, though.
-    */
-    testcase( pItem->addrFillSub!=0 );
+    /* The code for a subquery should only be generated once. */
+    assert( pItem->addrFillSub==0 );
 
     /* Increment Parse.nHeight by the height of the largest expression
     ** tree referred to by this, the parent select. The child select
@@ -135901,16 +139863,19 @@ SQLITE_PRIVATE int sqlite3Select(
     ** inside the subquery.  This can help the subquery to run more efficiently.
     */
     if( OptimizationEnabled(db, SQLITE_PushDown)
+     && (pItem->fg.isCte==0
+         || (pItem->u2.pCteUse->eM10d!=M10d_Yes && pItem->u2.pCteUse->nUse<2))
      && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
                            (pItem->fg.jointype & JT_OUTER)!=0)
     ){
 #if SELECTTRACE_ENABLED
-      if( sqlite3_unsupported_selecttrace & 0x100 ){
+      if( sqlite3SelectTrace & 0x100 ){
         SELECTTRACE(0x100,pParse,p,
             ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
         sqlite3TreeViewSelect(0, p, 0);
       }
 #endif
+      assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
     }else{
       SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
     }
@@ -135920,16 +139885,18 @@ SQLITE_PRIVATE int sqlite3Select(
 
     /* Generate code to implement the subquery
     **
-    ** The subquery is implemented as a co-routine if the subquery is
-    ** guaranteed to be the outer loop (so that it does not need to be
-    ** computed more than once)
+    ** The subquery is implemented as a co-routine if:
+    **    (1)  the subquery is guaranteed to be the outer loop (so that
+    **         it does not need to be computed more than once), and
+    **    (2)  the subquery is not a CTE that should be materialized
     **
-    ** TODO: Are there other reasons beside (1) to use a co-routine
+    ** TODO: Are there other reasons beside (1) and (2) to use a co-routine
     ** implementation?
     */
     if( i==0
      && (pTabList->nSrc==1
             || (pTabList->a[1].fg.jointype&(JT_LEFT|JT_CROSS))!=0)  /* (1) */
+     && (pItem->fg.isCte==0 || pItem->u2.pCteUse->eM10d!=M10d_Yes)  /* (2) */
     ){
       /* Implement a co-routine that will return a single row of the result
       ** set on each invocation.
@@ -135938,10 +139905,10 @@ SQLITE_PRIVATE int sqlite3Select(
 
       pItem->regReturn = ++pParse->nMem;
       sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
-      VdbeComment((v, "%s", pItem->pTab->zName));
+      VdbeComment((v, "%!S", pItem));
       pItem->addrFillSub = addrTop;
       sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
-      ExplainQueryPlan((pParse, 1, "CO-ROUTINE %u", pSub->selId));
+      ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
       sqlite3Select(pParse, pSub, &dest);
       pItem->pTab->nRowLogEst = pSub->nSelectRow;
       pItem->fg.viaCoroutine = 1;
@@ -135949,18 +139916,34 @@ SQLITE_PRIVATE int sqlite3Select(
       sqlite3VdbeEndCoroutine(v, pItem->regReturn);
       sqlite3VdbeJumpHere(v, addrTop-1);
       sqlite3ClearTempRegCache(pParse);
-    }else{
-      /* Generate a subroutine that will fill an ephemeral table with
-      ** the content of this subquery.  pItem->addrFillSub will point
-      ** to the address of the generated subroutine.  pItem->regReturn
-      ** is a register allocated to hold the subroutine return address
-      */
+    }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){
+      /* This is a CTE for which materialization code has already been
+      ** generated.  Invoke the subroutine to compute the materialization,
+      ** the make the pItem->iCursor be a copy of the ephemerial table that
+      ** holds the result of the materialization. */
+      CteUse *pCteUse = pItem->u2.pCteUse;
+      sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
+      if( pItem->iCursor!=pCteUse->iCur ){
+        sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
+        VdbeComment((v, "%!S", pItem));
+      }
+      pSub->nSelectRow = pCteUse->nRowEst;
+    }else if( (pPrior = isSelfJoinView(pTabList, pItem))!=0 ){
+      /* This view has already been materialized by a prior entry in
+      ** this same FROM clause.  Reuse it. */
+      if( pPrior->addrFillSub ){
+        sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
+      }
+      sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
+      pSub->nSelectRow = pPrior->pSelect->nSelectRow;
+    }else{
+      /* Materialize the view.  If the view is not correlated, generate a
+      ** subroutine to do the materialization so that subsequent uses of
+      ** the same view can reuse the materialization. */
       int topAddr;
       int onceAddr = 0;
       int retAddr;
-      struct SrcList_item *pPrior;
 
-      testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
       pItem->regReturn = ++pParse->nMem;
       topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
       pItem->addrFillSub = topAddr+1;
@@ -135969,26 +139952,26 @@ SQLITE_PRIVATE int sqlite3Select(
         ** a trigger, then we only need to compute the value of the subquery
         ** once. */
         onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-        VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
+        VdbeComment((v, "materialize %!S", pItem));
       }else{
-        VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
-      }
-      pPrior = isSelfJoinView(pTabList, pItem);
-      if( pPrior ){
-        sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
-        assert( pPrior->pSelect!=0 );
-        pSub->nSelectRow = pPrior->pSelect->nSelectRow;
-      }else{
-        sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
-        ExplainQueryPlan((pParse, 1, "MATERIALIZE %u", pSub->selId));
-        sqlite3Select(pParse, pSub, &dest);
+        VdbeNoopComment((v, "materialize %!S", pItem));
       }
+      sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
+      ExplainQueryPlan((pParse, 1, "MATERIALIZE %!S", pItem));
+      sqlite3Select(pParse, pSub, &dest);
       pItem->pTab->nRowLogEst = pSub->nSelectRow;
       if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
       retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
-      VdbeComment((v, "end %s", pItem->pTab->zName));
+      VdbeComment((v, "end %!S", pItem));
       sqlite3VdbeChangeP1(v, topAddr, retAddr);
       sqlite3ClearTempRegCache(pParse);
+      if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){
+        CteUse *pCteUse = pItem->u2.pCteUse;
+        pCteUse->addrM9e = pItem->addrFillSub;
+        pCteUse->regRtn = pItem->regReturn;
+        pCteUse->iCur = pItem->iCursor;
+        pCteUse->nRowEst = pSub->nSelectRow;
+      }
     }
     if( db->mallocFailed ) goto select_end;
     pParse->nHeight -= sqlite3SelectExprHeight(p);
@@ -136005,7 +139988,7 @@ SQLITE_PRIVATE int sqlite3Select(
   sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;
 
 #if SELECTTRACE_ENABLED
-  if( sqlite3_unsupported_selecttrace & 0x400 ){
+  if( sqlite3SelectTrace & 0x400 ){
     SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -136041,7 +140024,7 @@ SQLITE_PRIVATE int sqlite3Select(
     assert( sDistinct.isTnct );
 
 #if SELECTTRACE_ENABLED
-    if( sqlite3_unsupported_selecttrace & 0x400 ){
+    if( sqlite3SelectTrace & 0x400 ){
       SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
       sqlite3TreeViewSelect(0, p, 0);
     }
@@ -136133,6 +140116,7 @@ SQLITE_PRIVATE int sqlite3Select(
         sSort.pOrderBy = 0;
       }
     }
+    SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
 
     /* If sorting index that was created by a prior OP_OpenEphemeral
     ** instruction ended up not being needed, then change the OP_OpenEphemeral
@@ -136171,6 +140155,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
       /* End the database scan loop.
       */
+      SELECTTRACE(1,pParse,p,("WhereEnd\n"));
       sqlite3WhereEnd(pWInfo);
     }
   }else{
@@ -136241,11 +140226,14 @@ SQLITE_PRIVATE int sqlite3Select(
     ** SELECT statement.
     */
     pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) );
-    if( pAggInfo==0 ){
+    if( pAggInfo ){
+      sqlite3ParserAddCleanup(pParse,
+          (void(*)(sqlite3*,void*))agginfoFree, pAggInfo);
+      testcase( pParse->earlyCleanup );
+    }
+    if( db->mallocFailed ){
       goto select_end;
     }
-    pAggInfo->pNext = pParse->pAggList;
-    pParse->pAggList = pAggInfo;
     pAggInfo->selId = p->selId;
     memset(&sNC, 0, sizeof(sNC));
     sNC.pParse = pParse;
@@ -136275,7 +140263,7 @@ SQLITE_PRIVATE int sqlite3Select(
     }
     for(i=0; i<pAggInfo->nFunc; i++){
       Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
-      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
+      assert( ExprUseXList(pExpr) );
       sNC.ncFlags |= NC_InAggFunc;
       sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);
 #ifndef SQLITE_OMIT_WINDOWFUNC
@@ -136289,10 +140277,14 @@ SQLITE_PRIVATE int sqlite3Select(
     pAggInfo->mxReg = pParse->nMem;
     if( db->mallocFailed ) goto select_end;
 #if SELECTTRACE_ENABLED
-    if( sqlite3_unsupported_selecttrace & 0x400 ){
+    if( sqlite3SelectTrace & 0x400 ){
       int ii;
       SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo));
       sqlite3TreeViewSelect(0, p, 0);
+      if( minMaxFlag ){
+        sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag);
+        sqlite3TreeViewExprList(0, pMinMaxOrderBy, 0, "ORDERBY");
+      }
       for(ii=0; ii<pAggInfo->nColumn; ii++){
         sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
             ii, pAggInfo->aCol[ii].iMem);
@@ -136320,6 +140312,22 @@ SQLITE_PRIVATE int sqlite3Select(
       int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
       int addrReset;      /* Subroutine for resetting the accumulator */
       int regReset;       /* Return address register for reset subroutine */
+      ExprList *pDistinct = 0;
+      u16 distFlag = 0;
+      int eDist = WHERE_DISTINCT_NOOP;
+
+      if( pAggInfo->nFunc==1
+       && pAggInfo->aFunc[0].iDistinct>=0
+       && ALWAYS(pAggInfo->aFunc[0].pFExpr!=0)
+       && ALWAYS(ExprUseXList(pAggInfo->aFunc[0].pFExpr))
+       && pAggInfo->aFunc[0].pFExpr->x.pList!=0
+      ){
+        Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr;
+        pExpr = sqlite3ExprDup(db, pExpr, 0);
+        pDistinct = sqlite3ExprListDup(db, pGroupBy, 0);
+        pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
+        distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0;
+      }
 
       /* If there is a GROUP BY clause we might need a sorting index to
       ** implement it.  Allocate that sorting index now.  If it turns out
@@ -136356,10 +140364,15 @@ SQLITE_PRIVATE int sqlite3Select(
       */
       sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
       SELECTTRACE(1,pParse,p,("WhereBegin\n"));
-      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
-          WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0), 0
+      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct,
+          WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0
       );
-      if( pWInfo==0 ) goto select_end;
+      if( pWInfo==0 ){
+        sqlite3ExprListDelete(db, pDistinct);
+        goto select_end;
+      }
+      eDist = sqlite3WhereIsDistinct(pWInfo);
+      SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
       if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){
         /* The optimizer is able to deliver rows in group by order so
         ** we do not have to sort.  The OP_OpenEphemeral table will be
@@ -136408,6 +140421,7 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
         sqlite3ReleaseTempReg(pParse, regRecord);
         sqlite3ReleaseTempRange(pParse, regBase, nCol);
+        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
         sqlite3WhereEnd(pWInfo);
         pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
         sortOut = sqlite3GetTempReg(pParse);
@@ -136475,19 +140489,21 @@ SQLITE_PRIVATE int sqlite3Select(
       ** the current row
       */
       sqlite3VdbeJumpHere(v, addr1);
-      updateAccumulator(pParse, iUseFlag, pAggInfo);
+      updateAccumulator(pParse, iUseFlag, pAggInfo, eDist);
       sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
       VdbeComment((v, "indicate data in accumulator"));
 
       /* End of the loop
       */
       if( groupBySort ){
-        sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx, addrTopOfLoop);
+        sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
         VdbeCoverage(v);
       }else{
+        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
         sqlite3WhereEnd(pWInfo);
         sqlite3VdbeChangeToNoop(v, addrSortingIdx);
       }
+      sqlite3ExprListDelete(db, pDistinct);
 
       /* Output the final row of result
       */
@@ -136531,6 +140547,10 @@ SQLITE_PRIVATE int sqlite3Select(
       VdbeComment((v, "indicate accumulator empty"));
       sqlite3VdbeAddOp1(v, OP_Return, regReset);
 
+      if( eDist!=WHERE_DISTINCT_NOOP ){
+        struct AggInfo_func *pF = &pAggInfo->aFunc[0];
+        fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
+      }
     } /* endif pGroupBy.  Begin aggregate queries without GROUP BY: */
     else {
       Table *pTab;
@@ -136594,7 +140614,9 @@ SQLITE_PRIVATE int sqlite3Select(
         explainSimpleCount(pParse, pTab, pBest);
       }else{
         int regAcc = 0;           /* "populate accumulators" flag */
-        int addrSkip;
+        ExprList *pDistinct = 0;
+        u16 distFlag = 0;
+        int eDist;
 
         /* If there are accumulator registers but no min() or max() functions
         ** without FILTER clauses, allocate register regAcc. Register regAcc
@@ -136618,6 +140640,10 @@ SQLITE_PRIVATE int sqlite3Select(
             regAcc = ++pParse->nMem;
             sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
           }
+        }else if( pAggInfo->nFunc==1 && pAggInfo->aFunc[0].iDistinct>=0 ){
+          assert( ExprUseXList(pAggInfo->aFunc[0].pFExpr) );
+          pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList;
+          distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0;
         }
 
         /* This case runs if the aggregate has no GROUP BY clause.  The
@@ -136637,16 +140663,23 @@ SQLITE_PRIVATE int sqlite3Select(
 
         SELECTTRACE(1,pParse,p,("WhereBegin\n"));
         pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
-                                   0, minMaxFlag, 0);
+                                   pDistinct, minMaxFlag|distFlag, 0);
         if( pWInfo==0 ){
           goto select_end;
         }
-        updateAccumulator(pParse, regAcc, pAggInfo);
+        SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));
+        eDist = sqlite3WhereIsDistinct(pWInfo);
+        updateAccumulator(pParse, regAcc, pAggInfo, eDist);
+        if( eDist!=WHERE_DISTINCT_NOOP ){
+          struct AggInfo_func *pF = &pAggInfo->aFunc[0];
+          fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
+        }
+
         if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
-        addrSkip = sqlite3WhereOrderByLimitOptLabel(pWInfo);
-        if( addrSkip!=sqlite3WhereContinueLabel(pWInfo) ){
-          sqlite3VdbeGoto(v, addrSkip);
+        if( minMaxFlag ){
+          sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
         }
+        SELECTTRACE(1,pParse,p,("WhereEnd\n"));
         sqlite3WhereEnd(pWInfo);
         finalizeAggFunctions(pParse, pAggInfo);
       }
@@ -136686,20 +140719,20 @@ SQLITE_PRIVATE int sqlite3Select(
   ** successful coding of the SELECT.
   */
 select_end:
+  assert( db->mallocFailed==0 || db->mallocFailed==1 );
+  pParse->nErr += db->mallocFailed;
   sqlite3ExprListDelete(db, pMinMaxOrderBy);
 #ifdef SQLITE_DEBUG
   if( pAggInfo && !db->mallocFailed ){
     for(i=0; i<pAggInfo->nColumn; i++){
       Expr *pExpr = pAggInfo->aCol[i].pCExpr;
-      assert( pExpr!=0 || db->mallocFailed );
-      if( pExpr==0 ) continue;
+      assert( pExpr!=0 );
       assert( pExpr->pAggInfo==pAggInfo );
       assert( pExpr->iAgg==i );
     }
     for(i=0; i<pAggInfo->nFunc; i++){
       Expr *pExpr = pAggInfo->aFunc[i].pFExpr;
-      assert( pExpr!=0 || db->mallocFailed );
-      if( pExpr==0 ) continue;
+      assert( pExpr!=0 );
       assert( pExpr->pAggInfo==pAggInfo );
       assert( pExpr->iAgg==i );
     }
@@ -136708,7 +140741,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
 #if SELECTTRACE_ENABLED
   SELECTTRACE(0x1,pParse,p,("end processing\n"));
-  if( (sqlite3_unsupported_selecttrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
+  if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
     sqlite3TreeViewSelect(0, p, 0);
   }
 #endif
@@ -136969,28 +141002,51 @@ SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerS
 ** pTab as well as the triggers lised in pTab->pTrigger.
 */
 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
-  Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
-  Trigger *pList = 0;                  /* List of triggers to return */
+  Schema *pTmpSchema;       /* Schema of the pTab table */
+  Trigger *pList;           /* List of triggers to return */
+  HashElem *p;              /* Loop variable for TEMP triggers */
 
   if( pParse->disableTriggers ){
     return 0;
   }
-
-  if( pTmpSchema!=pTab->pSchema ){
-    HashElem *p;
-    assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
-    for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){
-      Trigger *pTrig = (Trigger *)sqliteHashData(p);
-      if( pTrig->pTabSchema==pTab->pSchema
-       && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
-      ){
-        pTrig->pNext = (pList ? pList : pTab->pTrigger);
-        pList = pTrig;
-      }
+  pTmpSchema = pParse->db->aDb[1].pSchema;
+  p = sqliteHashFirst(&pTmpSchema->trigHash);
+  pList = pTab->pTrigger;
+  while( p ){
+    Trigger *pTrig = (Trigger *)sqliteHashData(p);
+    if( pTrig->pTabSchema==pTab->pSchema
+     && pTrig->table
+     && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
+     && pTrig->pTabSchema!=pTmpSchema
+    ){
+      pTrig->pNext = pList;
+      pList = pTrig;
+    }else if( pTrig->op==TK_RETURNING
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+              && pParse->db->pVtabCtx==0
+#endif
+    ){
+      assert( pParse->bReturning );
+      assert( &(pParse->u1.pReturning->retTrig) == pTrig );
+      pTrig->table = pTab->zName;
+      pTrig->pTabSchema = pTab->pSchema;
+      pTrig->pNext = pList;
+      pList = pTrig;
     }
+    p = sqliteHashNext(p);
   }
-
-  return (pList ? pList : pTab->pTrigger);
+#if 0
+  if( pList ){
+    Trigger *pX;
+    printf("Triggers for %s:", pTab->zName);
+    for(pX=pList; pX; pX=pX->pNext){
+      printf(" %s", pX->zName);
+    }
+    printf("\n");
+    fflush(stdout);
+  }
+#endif
+  return pList;
 }
 
 /*
@@ -137117,14 +141173,14 @@ SQLITE_PRIVATE void sqlite3BeginTrigger(
   /* INSTEAD of triggers are only for views and views only support INSTEAD
   ** of triggers.
   */
-  if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
+  if( IsView(pTab) && tr_tm!=TK_INSTEAD ){
     sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
-        (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
+        (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName->a);
     goto trigger_orphan_error;
   }
-  if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
+  if( !IsView(pTab) && tr_tm==TK_INSTEAD ){
     sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
-        " trigger on table: %S", pTableName, 0);
+        " trigger on table: %S", pTableName->a);
     goto trigger_orphan_error;
   }
 
@@ -137259,14 +141315,14 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
     z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
     testcase( z==0 );
     sqlite3NestedParse(pParse,
-       "INSERT INTO %Q." DFLT_SCHEMA_TABLE
+       "INSERT INTO %Q." LEGACY_SCHEMA_TABLE
        " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
        db->aDb[iDb].zDbSName, zName,
        pTrig->table, z);
     sqlite3DbFree(db, z);
     sqlite3ChangeCookie(pParse, iDb);
     sqlite3VdbeAddParseSchemaOp(v, iDb,
-        sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
+        sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0);
   }
 
   if( db->init.busy ){
@@ -137479,7 +141535,7 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(
 ** Recursively delete a Trigger structure
 */
 SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
-  if( pTrigger==0 ) return;
+  if( pTrigger==0 || pTrigger->bReturning ) return;
   sqlite3DeleteTriggerStep(db, pTrigger->step_list);
   sqlite3DbFree(db, pTrigger->zName);
   sqlite3DbFree(db, pTrigger->table);
@@ -137521,7 +141577,7 @@ SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr)
   }
   if( !pTrigger ){
     if( !noErr ){
-      sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
+      sqlite3ErrorMsg(pParse, "no such trigger: %S", pName->a);
     }else{
       sqlite3CodeVerifyNamedSchema(pParse, zDb);
     }
@@ -137573,7 +141629,7 @@ SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
   */
   if( (v = sqlite3GetVdbe(pParse))!=0 ){
     sqlite3NestedParse(pParse,
-       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",
+       "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",
        db->aDb[iDb].zDbSName, pTrigger->zName
     );
     sqlite3ChangeCookie(pParse, iDb);
@@ -137644,15 +141700,53 @@ SQLITE_PRIVATE Trigger *sqlite3TriggersExist(
   Trigger *pList = 0;
   Trigger *p;
 
-  if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
-    pList = sqlite3TriggerList(pParse, pTab);
-  }
-  assert( pList==0 || IsVirtual(pTab)==0 );
-  for(p=pList; p; p=p->pNext){
-    if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
-      mask |= p->tr_tm;
+  pList = sqlite3TriggerList(pParse, pTab);
+  assert( pList==0 || IsVirtual(pTab)==0
+           || (pList->bReturning && pList->pNext==0) );
+  if( pList!=0 ){
+    p = pList;
+    if( (pParse->db->flags & SQLITE_EnableTrigger)==0
+     && pTab->pTrigger!=0
+    ){
+      /* The SQLITE_DBCONFIG_ENABLE_TRIGGER setting is off.  That means that
+      ** only TEMP triggers are allowed.  Truncate the pList so that it
+      ** includes only TEMP triggers */
+      if( pList==pTab->pTrigger ){
+        pList = 0;
+        goto exit_triggers_exist;
+      }
+      while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext;
+      p->pNext = 0;
+      p = pList;
     }
+    do{
+      if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
+        mask |= p->tr_tm;
+      }else if( p->op==TK_RETURNING ){
+        /* The first time a RETURNING trigger is seen, the "op" value tells
+        ** us what time of trigger it should be. */
+        assert( sqlite3IsToplevel(pParse) );
+        p->op = op;
+        if( IsVirtual(pTab) ){
+          if( op!=TK_INSERT ){
+            sqlite3ErrorMsg(pParse,
+              "%s RETURNING is not available on virtual tables",
+              op==TK_DELETE ? "DELETE" : "UPDATE");
+          }
+          p->tr_tm = TRIGGER_BEFORE;
+        }else{
+          p->tr_tm = TRIGGER_AFTER;
+        }
+        mask |= p->tr_tm;
+      }else if( p->bReturning && p->op==TK_INSERT && op==TK_UPDATE
+                && sqlite3IsToplevel(pParse) ){
+        /* Also fire a RETURNING trigger for an UPSERT */
+        mask |= p->tr_tm;
+      }
+      p = p->pNext;
+    }while( p );
   }
+exit_triggers_exist:
   if( pMask ){
     *pMask = mask;
   }
@@ -137695,6 +141789,138 @@ SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(
   return pSrc;
 }
 
+/*
+** Return true if the pExpr term from the RETURNING clause argument
+** list is of the form "*".  Raise an error if the terms if of the
+** form "table.*".
+*/
+static int isAsteriskTerm(
+  Parse *pParse,      /* Parsing context */
+  Expr *pTerm         /* A term in the RETURNING clause */
+){
+  assert( pTerm!=0 );
+  if( pTerm->op==TK_ASTERISK ) return 1;
+  if( pTerm->op!=TK_DOT ) return 0;
+  assert( pTerm->pRight!=0 );
+  assert( pTerm->pLeft!=0 );
+  if( pTerm->pRight->op!=TK_ASTERISK ) return 0;
+  sqlite3ErrorMsg(pParse, "RETURNING may not use \"TABLE.*\" wildcards");
+  return 1;
+}
+
+/* The input list pList is the list of result set terms from a RETURNING
+** clause.  The table that we are returning from is pTab.
+**
+** This routine makes a copy of the pList, and at the same time expands
+** any "*" wildcards to be the complete set of columns from pTab.
+*/
+static ExprList *sqlite3ExpandReturning(
+  Parse *pParse,        /* Parsing context */
+  ExprList *pList,      /* The arguments to RETURNING */
+  Table *pTab           /* The table being updated */
+){
+  ExprList *pNew = 0;
+  sqlite3 *db = pParse->db;
+  int i;
+
+  for(i=0; i<pList->nExpr; i++){
+    Expr *pOldExpr = pList->a[i].pExpr;
+    if( NEVER(pOldExpr==0) ) continue;
+    if( isAsteriskTerm(pParse, pOldExpr) ){
+      int jj;
+      for(jj=0; jj<pTab->nCol; jj++){
+        Expr *pNewExpr;
+        if( IsHiddenColumn(pTab->aCol+jj) ) continue;
+        pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName);
+        pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
+        if( !db->mallocFailed ){
+          struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
+          pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName);
+          pItem->eEName = ENAME_NAME;
+        }
+      }
+    }else{
+      Expr *pNewExpr = sqlite3ExprDup(db, pOldExpr, 0);
+      pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
+      if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){
+        struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
+        pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
+        pItem->eEName = pList->a[i].eEName;
+      }
+    }
+  }
+  return pNew;
+}
+
+/*
+** Generate code for the RETURNING trigger.  Unlike other triggers
+** that invoke a subprogram in the bytecode, the code for RETURNING
+** is generated in-line.
+*/
+static void codeReturningTrigger(
+  Parse *pParse,       /* Parse context */
+  Trigger *pTrigger,   /* The trigger step that defines the RETURNING */
+  Table *pTab,         /* The table to code triggers from */
+  int regIn            /* The first in an array of registers */
+){
+  Vdbe *v = pParse->pVdbe;
+  sqlite3 *db = pParse->db;
+  ExprList *pNew;
+  Returning *pReturning;
+  Select sSelect;
+  SrcList sFrom;
+
+  assert( v!=0 );
+  assert( pParse->bReturning );
+  pReturning = pParse->u1.pReturning;
+  assert( pTrigger == &(pReturning->retTrig) );
+  memset(&sSelect, 0, sizeof(sSelect));
+  memset(&sFrom, 0, sizeof(sFrom));
+  sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
+  sSelect.pSrc = &sFrom;
+  sFrom.nSrc = 1;
+  sFrom.a[0].pTab = pTab;
+  sFrom.a[0].iCursor = -1;
+  sqlite3SelectPrep(pParse, &sSelect, 0);
+  if( db->mallocFailed==0 && pParse->nErr==0 ){
+    sqlite3GenerateColumnNames(pParse, &sSelect);
+  }
+  sqlite3ExprListDelete(db, sSelect.pEList);
+  pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
+  if( pNew ){
+    NameContext sNC;
+    memset(&sNC, 0, sizeof(sNC));
+    if( pReturning->nRetCol==0 ){
+      pReturning->nRetCol = pNew->nExpr;
+      pReturning->iRetCur = pParse->nTab++;
+    }
+    sNC.pParse = pParse;
+    sNC.uNC.iBaseReg = regIn;
+    sNC.ncFlags = NC_UBaseReg;
+    pParse->eTriggerOp = pTrigger->op;
+    pParse->pTriggerTab = pTab;
+    if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK ){
+      int i;
+      int nCol = pNew->nExpr;
+      int reg = pParse->nMem+1;
+      pParse->nMem += nCol+2;
+      pReturning->iRetReg = reg;
+      for(i=0; i<nCol; i++){
+        Expr *pCol = pNew->a[i].pExpr;
+        sqlite3ExprCodeFactorable(pParse, pCol, reg+i);
+      }
+      sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
+      sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
+      sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
+    }
+    sqlite3ExprListDelete(db, pNew);
+    pParse->eTriggerOp = 0;
+    pParse->pTriggerTab = 0;
+  }
+}
+
+
+
 /*
 ** Generate VDBE code for the statements inside the body of a single
 ** trigger.
@@ -137744,6 +141970,7 @@ static int codeTriggerProgram(
           sqlite3ExprDup(db, pStep->pWhere, 0),
           pParse->eOrconf, 0, 0, 0
         );
+        sqlite3VdbeAddOp0(v, OP_ResetCount);
         break;
       }
       case TK_INSERT: {
@@ -137754,6 +141981,7 @@ static int codeTriggerProgram(
           pParse->eOrconf,
           sqlite3UpsertDup(db, pStep->pUpsert)
         );
+        sqlite3VdbeAddOp0(v, OP_ResetCount);
         break;
       }
       case TK_DELETE: {
@@ -137761,6 +141989,7 @@ static int codeTriggerProgram(
           sqlite3TriggerStepSrc(pParse, pStep),
           sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0
         );
+        sqlite3VdbeAddOp0(v, OP_ResetCount);
         break;
       }
       default: assert( pStep->op==TK_SELECT ); {
@@ -137772,9 +142001,6 @@ static int codeTriggerProgram(
         break;
       }
     }
-    if( pStep->op!=TK_SELECT ){
-      sqlite3VdbeAddOp0(v, OP_ResetCount);
-    }
   }
 
   return 0;
@@ -137890,8 +142116,8 @@ static TriggerPrg *codeRowTrigger(
     ** OP_Halt inserted at the end of the program.  */
     if( pTrigger->pWhen ){
       pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
-      if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
-       && db->mallocFailed==0
+      if( db->mallocFailed==0
+       && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
       ){
         iEndTrigger = sqlite3VdbeMakeLabel(pSubParse);
         sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
@@ -137921,7 +142147,6 @@ static TriggerPrg *codeRowTrigger(
     sqlite3VdbeDelete(v);
   }
 
-  assert( !pSubParse->pAinc       && !pSubParse->pZombieTab );
   assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
   sqlite3ParserReset(pSubParse);
   sqlite3StackFree(db, pSubParse);
@@ -138023,7 +142248,7 @@ SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(
 **   ...            ...
 **   reg+N          OLD.* value of right-most column of pTab
 **   reg+N+1        NEW.rowid
-**   reg+N+2        OLD.* value of left-most column of pTab
+**   reg+N+2        NEW.* value of left-most column of pTab
 **   ...            ...
 **   reg+N+N+1      NEW.* value of right-most column of pTab
 **
@@ -138068,12 +142293,20 @@ SQLITE_PRIVATE void sqlite3CodeRowTrigger(
     assert( p->pSchema==p->pTabSchema
          || p->pSchema==pParse->db->aDb[1].pSchema );
 
-    /* Determine whether we should code this trigger */
-    if( p->op==op
+    /* Determine whether we should code this trigger.  One of two choices:
+    **   1. The trigger is an exact match to the current DML statement
+    **   2. This is a RETURNING trigger for INSERT but we are currently
+    **      doing the UPDATE part of an UPSERT.
+    */
+    if( (p->op==op || (p->bReturning && p->op==TK_INSERT && op==TK_UPDATE))
      && p->tr_tm==tr_tm
      && checkColumnOverlap(p->pColumns, pChanges)
     ){
-      sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
+      if( !p->bReturning ){
+        sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
+      }else if( sqlite3IsToplevel(pParse) ){
+        codeReturningTrigger(pParse, p, pTab, reg);
+      }
     }
   }
 }
@@ -138118,13 +142351,18 @@ SQLITE_PRIVATE u32 sqlite3TriggerColmask(
 
   assert( isNew==1 || isNew==0 );
   for(p=pTrigger; p; p=p->pNext){
-    if( p->op==op && (tr_tm&p->tr_tm)
+    if( p->op==op
+     && (tr_tm&p->tr_tm)
      && checkColumnOverlap(p->pColumns,pChanges)
     ){
-      TriggerPrg *pPrg;
-      pPrg = getRowTrigger(pParse, p, pTab, orconf);
-      if( pPrg ){
-        mask |= pPrg->aColmask[isNew];
+      if( p->bReturning ){
+        mask = 0xffffffff;
+      }else{
+        TriggerPrg *pPrg;
+        pPrg = getRowTrigger(pParse, p, pTab, orconf);
+        if( pPrg ){
+          mask |= pPrg->aColmask[isNew];
+        }
       }
     }
   }
@@ -138198,13 +142436,14 @@ static void updateVirtualTable(
 */
 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
   assert( pTab!=0 );
-  if( !pTab->pSelect ){
+  if( !IsView(pTab) ){
     sqlite3_value *pValue = 0;
     u8 enc = ENC(sqlite3VdbeDb(v));
     Column *pCol = &pTab->aCol[i];
-    VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
+    VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
     assert( i<pTab->nCol );
-    sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
+    sqlite3ValueFromExpr(sqlite3VdbeDb(v),
+                         sqlite3ColumnExpr(pTab,pCol), enc,
                          pCol->affinity, &pValue);
     if( pValue ){
       sqlite3VdbeAppendP4(v, pValue, P4_MEM);
@@ -138358,6 +142597,7 @@ static void updateFromSelect(
 
   assert( pTabList->nSrc>1 );
   if( pSrc ){
+    pSrc->a[0].fg.notCte = 1;
     pSrc->a[0].iCursor = -1;
     pSrc->a[0].pTab->nTabRef--;
     pSrc->a[0].pTab = 0;
@@ -138373,7 +142613,7 @@ static void updateFromSelect(
       pList = sqlite3ExprListAppend(pParse, pList, pNew);
     }
     eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom;
-  }else if( pTab->pSelect ){
+  }else if( IsView(pTab) ){
     for(i=0; i<pTab->nCol; i++){
       pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
     }
@@ -138387,7 +142627,8 @@ static void updateFromSelect(
     }
 #endif
   }
-  if( ALWAYS(pChanges) ){
+  assert( pChanges!=0 || pParse->db->mallocFailed );
+  if( pChanges ){
     for(i=0; i<pChanges->nExpr; i++){
       pList = sqlite3ExprListAppend(pParse, pList,
           sqlite3ExprDup(db, pChanges->a[i].pExpr, 0)
@@ -138395,8 +142636,9 @@ static void updateFromSelect(
     }
   }
   pSelect = sqlite3SelectNew(pParse, pList,
-      pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UpdateFrom|SF_IncludeHidden, pLimit2
+      pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2
   );
+  if( pSelect ) pSelect->selFlags |= SF_OrderByReqd;
   sqlite3SelectDestInit(&dest, eDest, iEph);
   dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1);
   sqlite3Select(pParse, pSelect, &dest);
@@ -138496,7 +142738,7 @@ SQLITE_PRIVATE void sqlite3Update(
   */
 #ifndef SQLITE_OMIT_TRIGGER
   pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
-  isView = pTab->pSelect!=0;
+  isView = IsView(pTab);
   assert( pTrigger || tmask==0 );
 #else
 # define pTrigger 0
@@ -138585,13 +142827,16 @@ SQLITE_PRIVATE void sqlite3Update(
   */
   chngRowid = chngPk = 0;
   for(i=0; i<pChanges->nExpr; i++){
+    u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName);
     /* If this is an UPDATE with a FROM clause, do not resolve expressions
     ** here. The call to sqlite3Select() below will do that. */
     if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
       goto update_cleanup;
     }
     for(j=0; j<pTab->nCol; j++){
-      if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){
+      if( pTab->aCol[j].hName==hCol
+       && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0
+      ){
         if( j==pTab->iPKey ){
           chngRowid = 1;
           pRowidExpr = pChanges->a[i].pExpr;
@@ -138605,7 +142850,7 @@ SQLITE_PRIVATE void sqlite3Update(
           testcase( pTab->aCol[j].colFlags & COLFLAG_STORED );
           sqlite3ErrorMsg(pParse,
              "cannot UPDATE generated column \"%s\"",
-             pTab->aCol[j].zName);
+             pTab->aCol[j].zCnName);
           goto update_cleanup;
         }
 #endif
@@ -138629,7 +142874,7 @@ SQLITE_PRIVATE void sqlite3Update(
     {
       int rc;
       rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
-                            j<0 ? "ROWID" : pTab->aCol[j].zName,
+                            j<0 ? "ROWID" : pTab->aCol[j].zCnName,
                             db->aDb[iDb].zDbSName);
       if( rc==SQLITE_DENY ){
         goto update_cleanup;
@@ -138661,8 +142906,10 @@ SQLITE_PRIVATE void sqlite3Update(
       for(i=0; i<pTab->nCol; i++){
         if( aXRef[i]>=0 ) continue;
         if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue;
-        if( sqlite3ExprReferencesUpdatedColumn(pTab->aCol[i].pDflt,
-                                               aXRef, chngRowid) ){
+        if( sqlite3ExprReferencesUpdatedColumn(
+                sqlite3ColumnExpr(pTab, &pTab->aCol[i]),
+                 aXRef, chngRowid)
+        ){
           aXRef[i] = 99999;
           bProgress = 1;
         }
@@ -138781,6 +143028,7 @@ SQLITE_PRIVATE void sqlite3Update(
   if( (db->flags&SQLITE_CountRows)!=0
    && !pParse->pTriggerTab
    && !pParse->nested
+   && !pParse->bReturning
    && pUpsert==0
   ){
     regRowCount = ++pParse->nMem;
@@ -138936,7 +143184,12 @@ SQLITE_PRIVATE void sqlite3Update(
 
     /* Top of the update loop */
     if( eOnePass!=ONEPASS_OFF ){
-      if( !isView && aiCurOnePass[0]!=iDataCur && aiCurOnePass[1]!=iDataCur ){
+      if( aiCurOnePass[0]!=iDataCur
+       && aiCurOnePass[1]!=iDataCur
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+       && !isView
+#endif
+      ){
         assert( pPk );
         sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
         VdbeCoverage(v);
@@ -139244,7 +143497,7 @@ SQLITE_PRIVATE void sqlite3Update(
   ** that information.
   */
   if( regRowCount ){
-    sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
+    sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
   }
@@ -139479,16 +143732,23 @@ static void updateVirtualTable(
 /*
 ** Free a list of Upsert objects
 */
-SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
-  if( p ){
+static void SQLITE_NOINLINE upsertDelete(sqlite3 *db, Upsert *p){
+  do{
+    Upsert *pNext = p->pNextUpsert;
     sqlite3ExprListDelete(db, p->pUpsertTarget);
     sqlite3ExprDelete(db, p->pUpsertTargetWhere);
     sqlite3ExprListDelete(db, p->pUpsertSet);
     sqlite3ExprDelete(db, p->pUpsertWhere);
+    sqlite3DbFree(db, p->pToFree);
     sqlite3DbFree(db, p);
-  }
+    p = pNext;
+  }while( p );
+}
+SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
+  if( p ) upsertDelete(db, p);
 }
 
+
 /*
 ** Duplicate an Upsert object.
 */
@@ -139498,7 +143758,8 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){
            sqlite3ExprListDup(db, p->pUpsertTarget, 0),
            sqlite3ExprDup(db, p->pUpsertTargetWhere, 0),
            sqlite3ExprListDup(db, p->pUpsertSet, 0),
-           sqlite3ExprDup(db, p->pUpsertWhere, 0)
+           sqlite3ExprDup(db, p->pUpsertWhere, 0),
+           sqlite3UpsertDup(db, p->pNextUpsert)
          );
 }
 
@@ -139510,22 +143771,25 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertNew(
   ExprList *pTarget,     /* Target argument to ON CONFLICT, or NULL */
   Expr *pTargetWhere,    /* Optional WHERE clause on the target */
   ExprList *pSet,        /* UPDATE columns, or NULL for a DO NOTHING */
-  Expr *pWhere           /* WHERE clause for the ON CONFLICT UPDATE */
+  Expr *pWhere,          /* WHERE clause for the ON CONFLICT UPDATE */
+  Upsert *pNext          /* Next ON CONFLICT clause in the list */
 ){
   Upsert *pNew;
-  pNew = sqlite3DbMallocRaw(db, sizeof(Upsert));
+  pNew = sqlite3DbMallocZero(db, sizeof(Upsert));
   if( pNew==0 ){
     sqlite3ExprListDelete(db, pTarget);
     sqlite3ExprDelete(db, pTargetWhere);
     sqlite3ExprListDelete(db, pSet);
     sqlite3ExprDelete(db, pWhere);
+    sqlite3UpsertDelete(db, pNext);
     return 0;
   }else{
     pNew->pUpsertTarget = pTarget;
     pNew->pUpsertTargetWhere = pTargetWhere;
     pNew->pUpsertSet = pSet;
     pNew->pUpsertWhere = pWhere;
-    pNew->pUpsertIdx = 0;
+    pNew->isDoUpdate = pSet!=0;
+    pNew->pNextUpsert = pNext;
   }
   return pNew;
 }
@@ -139550,6 +143814,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
   Expr *pTerm;            /* One term of the conflict-target clause */
   NameContext sNC;        /* Context for resolving symbolic names */
   Expr sCol[2];           /* Index column converted into an Expr */
+  int nClause = 0;        /* Counter of ON CONFLICT clauses */
 
   assert( pTabList->nSrc==1 );
   assert( pTabList->a[0].pTab!=0 );
@@ -139563,87 +143828,131 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
   memset(&sNC, 0, sizeof(sNC));
   sNC.pParse = pParse;
   sNC.pSrcList = pTabList;
-  rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
-  if( rc ) return rc;
-  rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
-  if( rc ) return rc;
+  for(; pUpsert && pUpsert->pUpsertTarget;
+        pUpsert=pUpsert->pNextUpsert, nClause++){
+    rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
+    if( rc ) return rc;
+    rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
+    if( rc ) return rc;
 
-  /* Check to see if the conflict target matches the rowid. */
-  pTab = pTabList->a[0].pTab;
-  pTarget = pUpsert->pUpsertTarget;
-  iCursor = pTabList->a[0].iCursor;
-  if( HasRowid(pTab)
-   && pTarget->nExpr==1
-   && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
-   && pTerm->iColumn==XN_ROWID
-  ){
-    /* The conflict-target is the rowid of the primary table */
-    assert( pUpsert->pUpsertIdx==0 );
-    return SQLITE_OK;
-  }
+    /* Check to see if the conflict target matches the rowid. */
+    pTab = pTabList->a[0].pTab;
+    pTarget = pUpsert->pUpsertTarget;
+    iCursor = pTabList->a[0].iCursor;
+    if( HasRowid(pTab)
+     && pTarget->nExpr==1
+     && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
+     && pTerm->iColumn==XN_ROWID
+    ){
+      /* The conflict-target is the rowid of the primary table */
+      assert( pUpsert->pUpsertIdx==0 );
+      continue;
+    }
 
-  /* Initialize sCol[0..1] to be an expression parse tree for a
-  ** single column of an index.  The sCol[0] node will be the TK_COLLATE
-  ** operator and sCol[1] will be the TK_COLUMN operator.  Code below
-  ** will populate the specific collation and column number values
-  ** prior to comparing against the conflict-target expression.
-  */
-  memset(sCol, 0, sizeof(sCol));
-  sCol[0].op = TK_COLLATE;
-  sCol[0].pLeft = &sCol[1];
-  sCol[1].op = TK_COLUMN;
-  sCol[1].iTable = pTabList->a[0].iCursor;
+    /* Initialize sCol[0..1] to be an expression parse tree for a
+    ** single column of an index.  The sCol[0] node will be the TK_COLLATE
+    ** operator and sCol[1] will be the TK_COLUMN operator.  Code below
+    ** will populate the specific collation and column number values
+    ** prior to comparing against the conflict-target expression.
+    */
+    memset(sCol, 0, sizeof(sCol));
+    sCol[0].op = TK_COLLATE;
+    sCol[0].pLeft = &sCol[1];
+    sCol[1].op = TK_COLUMN;
+    sCol[1].iTable = pTabList->a[0].iCursor;
 
-  /* Check for matches against other indexes */
-  for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
-    int ii, jj, nn;
-    if( !IsUniqueIndex(pIdx) ) continue;
-    if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
-    if( pIdx->pPartIdxWhere ){
-      if( pUpsert->pUpsertTargetWhere==0 ) continue;
-      if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
-                             pIdx->pPartIdxWhere, iCursor)!=0 ){
-        continue;
+    /* Check for matches against other indexes */
+    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
+      int ii, jj, nn;
+      if( !IsUniqueIndex(pIdx) ) continue;
+      if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
+      if( pIdx->pPartIdxWhere ){
+        if( pUpsert->pUpsertTargetWhere==0 ) continue;
+        if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
+                               pIdx->pPartIdxWhere, iCursor)!=0 ){
+          continue;
+        }
       }
-    }
-    nn = pIdx->nKeyCol;
-    for(ii=0; ii<nn; ii++){
-      Expr *pExpr;
-      sCol[0].u.zToken = (char*)pIdx->azColl[ii];
-      if( pIdx->aiColumn[ii]==XN_EXPR ){
-        assert( pIdx->aColExpr!=0 );
-        assert( pIdx->aColExpr->nExpr>ii );
-        pExpr = pIdx->aColExpr->a[ii].pExpr;
-        if( pExpr->op!=TK_COLLATE ){
-          sCol[0].pLeft = pExpr;
+      nn = pIdx->nKeyCol;
+      for(ii=0; ii<nn; ii++){
+        Expr *pExpr;
+        sCol[0].u.zToken = (char*)pIdx->azColl[ii];
+        if( pIdx->aiColumn[ii]==XN_EXPR ){
+          assert( pIdx->aColExpr!=0 );
+          assert( pIdx->aColExpr->nExpr>ii );
+          pExpr = pIdx->aColExpr->a[ii].pExpr;
+          if( pExpr->op!=TK_COLLATE ){
+            sCol[0].pLeft = pExpr;
+            pExpr = &sCol[0];
+          }
+        }else{
+          sCol[0].pLeft = &sCol[1];
+          sCol[1].iColumn = pIdx->aiColumn[ii];
           pExpr = &sCol[0];
         }
-      }else{
-        sCol[0].pLeft = &sCol[1];
-        sCol[1].iColumn = pIdx->aiColumn[ii];
-        pExpr = &sCol[0];
-      }
-      for(jj=0; jj<nn; jj++){
-        if( sqlite3ExprCompare(pParse, pTarget->a[jj].pExpr, pExpr,iCursor)<2 ){
-          break;  /* Column ii of the index matches column jj of target */
+        for(jj=0; jj<nn; jj++){
+          if( sqlite3ExprCompare(pParse,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
+            break;  /* Column ii of the index matches column jj of target */
+          }
+        }
+        if( jj>=nn ){
+          /* The target contains no match for column jj of the index */
+          break;
         }
       }
-      if( jj>=nn ){
-        /* The target contains no match for column jj of the index */
-        break;
+      if( ii<nn ){
+        /* Column ii of the index did not match any term of the conflict target.
+        ** Continue the search with the next index. */
+        continue;
       }
+      pUpsert->pUpsertIdx = pIdx;
+      break;
     }
-    if( ii<nn ){
-      /* Column ii of the index did not match any term of the conflict target.
-      ** Continue the search with the next index. */
-      continue;
+    if( pUpsert->pUpsertIdx==0 ){
+      char zWhich[16];
+      if( nClause==0 && pUpsert->pNextUpsert==0 ){
+        zWhich[0] = 0;
+      }else{
+        sqlite3_snprintf(sizeof(zWhich),zWhich,"%r ", nClause+1);
+      }
+      sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any "
+                              "PRIMARY KEY or UNIQUE constraint", zWhich);
+      return SQLITE_ERROR;
     }
-    pUpsert->pUpsertIdx = pIdx;
-    return SQLITE_OK;
   }
-  sqlite3ErrorMsg(pParse, "ON CONFLICT clause does not match any "
-                          "PRIMARY KEY or UNIQUE constraint");
-  return SQLITE_ERROR;
+  return SQLITE_OK;
+}
+
+/*
+** Return true if pUpsert is the last ON CONFLICT clause with a
+** conflict target, or if pUpsert is followed by another ON CONFLICT
+** clause that targets the INTEGER PRIMARY KEY.
+*/
+SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert *pUpsert){
+  Upsert *pNext;
+  if( NEVER(pUpsert==0) ) return 0;
+  pNext = pUpsert->pNextUpsert;
+  if( pNext==0 ) return 1;
+  if( pNext->pUpsertTarget==0 ) return 1;
+  if( pNext->pUpsertIdx==0 ) return 1;
+  return 0;
+}
+
+/*
+** Given the list of ON CONFLICT clauses described by pUpsert, and
+** a particular index pIdx, return a pointer to the particular ON CONFLICT
+** clause that applies to the index.  Or, if the index is not subject to
+** any ON CONFLICT clause, return NULL.
+*/
+SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){
+  while(
+      pUpsert
+   && pUpsert->pUpsertTarget!=0
+   && pUpsert->pUpsertIdx!=pIdx
+  ){
+     pUpsert = pUpsert->pNextUpsert;
+  }
+  return pUpsert;
 }
 
 /*
@@ -139667,11 +143976,13 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
   SrcList *pSrc;            /* FROM clause for the UPDATE */
   int iDataCur;
   int i;
+  Upsert *pTop = pUpsert;
 
   assert( v!=0 );
   assert( pUpsert!=0 );
-  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
   iDataCur = pUpsert->iDataCur;
+  pUpsert = sqlite3UpsertOfIndex(pTop, pIdx);
+  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
   if( pIdx && iCur!=iDataCur ){
     if( HasRowid(pTab) ){
       int regRowid = sqlite3GetTempReg(pParse);
@@ -139690,7 +144001,7 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
         k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
         sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
         VdbeComment((v, "%s.%s", pIdx->zName,
-                    pTab->aCol[pPk->aiColumn[i]].zName));
+                    pTab->aCol[pPk->aiColumn[i]].zCnName));
       }
       sqlite3VdbeVerifyAbortable(v, OE_Abort);
       i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
@@ -139701,19 +144012,17 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
       sqlite3VdbeJumpHere(v, i);
     }
   }
-  /* pUpsert does not own pUpsertSrc - the outer INSERT statement does.  So
-  ** we have to make a copy before passing it down into sqlite3Update() */
-  pSrc = sqlite3SrcListDup(db, pUpsert->pUpsertSrc, 0);
+  /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does.
+  ** So we have to make a copy before passing it down into sqlite3Update() */
+  pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0);
   /* excluded.* columns of type REAL need to be converted to a hard real */
   for(i=0; i<pTab->nCol; i++){
     if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
-      sqlite3VdbeAddOp1(v, OP_RealAffinity, pUpsert->regData+i);
+      sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i);
     }
   }
-  sqlite3Update(pParse, pSrc, pUpsert->pUpsertSet,
-      pUpsert->pUpsertWhere, OE_Abort, 0, 0, pUpsert);
-  pUpsert->pUpsertSet = 0;    /* Will have been deleted by sqlite3Update() */
-  pUpsert->pUpsertWhere = 0;  /* Will have been deleted by sqlite3Update() */
+  sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0),
+      sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert);
   VdbeNoopComment((v, "End DO UPDATE of UPSERT"));
 }
 
@@ -139874,8 +144183,8 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   Btree *pTemp;           /* The temporary database we vacuum into */
   u32 saved_mDbFlags;     /* Saved value of db->mDbFlags */
   u64 saved_flags;        /* Saved value of db->flags */
-  int saved_nChange;      /* Saved value of db->nChange */
-  int saved_nTotalChange; /* Saved value of db->nTotalChange */
+  i64 saved_nChange;      /* Saved value of db->nChange */
+  i64 saved_nTotalChange; /* Saved value of db->nTotalChange */
   u32 saved_openFlags;    /* Saved value of db->openFlags */
   u8 saved_mTrace;        /* Saved trace settings */
   Db *pDb = 0;            /* Database to detach at end of vacuum */
@@ -139973,7 +144282,9 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
 
   /* Do not attempt to change the page size for a WAL database */
   if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain))
-                                               ==PAGER_JOURNALMODE_WAL ){
+                                               ==PAGER_JOURNALMODE_WAL
+   && pOut==0
+  ){
     db->nextPagesize = 0;
   }
 
@@ -140322,7 +144633,7 @@ SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){
 SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
   VTable *pVtab;
   assert( IsVirtual(pTab) );
-  for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
+  for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
   return pVtab;
 }
 
@@ -140335,7 +144646,8 @@ SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
 
   assert( db );
   assert( pVTab->nRef>0 );
-  assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );
+  assert( db->eOpenState==SQLITE_STATE_OPEN
+       || db->eOpenState==SQLITE_STATE_ZOMBIE );
 
   pVTab->nRef--;
   if( pVTab->nRef==0 ){
@@ -140350,21 +144662,24 @@ SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
 
 /*
 ** Table p is a virtual table. This function moves all elements in the
-** p->pVTable list to the sqlite3.pDisconnect lists of their associated
+** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated
 ** database connections to be disconnected at the next opportunity.
 ** Except, if argument db is not NULL, then the entry associated with
-** connection db is left in the p->pVTable list.
+** connection db is left in the p->u.vtab.p list.
 */
 static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
   VTable *pRet = 0;
-  VTable *pVTable = p->pVTable;
-  p->pVTable = 0;
+  VTable *pVTable;
+
+  assert( IsVirtual(p) );
+  pVTable = p->u.vtab.p;
+  p->u.vtab.p = 0;
 
   /* Assert that the mutex (if any) associated with the BtShared database
   ** that contains table p is held by the caller. See header comments
   ** above function sqlite3VtabUnlockList() for an explanation of why
   ** this makes it safe to access the sqlite3.pDisconnect list of any
-  ** database connection that may have an entry in the p->pVTable list.
+  ** database connection that may have an entry in the p->u.vtab.p list.
   */
   assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
 
@@ -140374,7 +144689,7 @@ static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
     assert( db2 );
     if( db2==db ){
       pRet = pVTable;
-      p->pVTable = pRet;
+      p->u.vtab.p = pRet;
       pRet->pNext = 0;
     }else{
       pVTable->pNext = db2->pDisconnect;
@@ -140402,7 +144717,7 @@ SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
   assert( sqlite3BtreeHoldsAllMutexes(db) );
   assert( sqlite3_mutex_held(db->mutex) );
 
-  for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){
+  for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){
     if( (*ppVTab)->db==db  ){
       VTable *pVTab = *ppVTab;
       *ppVTab = pVTab->pNext;
@@ -140465,37 +144780,41 @@ SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
 ** database connection.
 */
 SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
+  assert( IsVirtual(p) );
   if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
-  if( p->azModuleArg ){
+  if( p->u.vtab.azArg ){
     int i;
-    for(i=0; i<p->nModuleArg; i++){
-      if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]);
+    for(i=0; i<p->u.vtab.nArg; i++){
+      if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]);
     }
-    sqlite3DbFree(db, p->azModuleArg);
+    sqlite3DbFree(db, p->u.vtab.azArg);
   }
 }
 
 /*
-** Add a new module argument to pTable->azModuleArg[].
+** Add a new module argument to pTable->u.vtab.azArg[].
 ** The string is not copied - the pointer is stored.  The
 ** string will be freed automatically when the table is
 ** deleted.
 */
 static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
-  sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg);
+  sqlite3_int64 nBytes;
   char **azModuleArg;
   sqlite3 *db = pParse->db;
-  if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
+
+  assert( IsVirtual(pTable) );
+  nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg);
+  if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
     sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
   }
-  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
+  azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes);
   if( azModuleArg==0 ){
     sqlite3DbFree(db, zArg);
   }else{
-    int i = pTable->nModuleArg++;
+    int i = pTable->u.vtab.nArg++;
     azModuleArg[i] = zArg;
     azModuleArg[i+1] = 0;
-    pTable->azModuleArg = azModuleArg;
+    pTable->u.vtab.azArg = azModuleArg;
   }
 }
 
@@ -140518,10 +144837,11 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse(
   pTable = pParse->pNewTable;
   if( pTable==0 ) return;
   assert( 0==pTable->pIndex );
+  pTable->eTabType = TABTYP_VTAB;
 
   db = pParse->db;
 
-  assert( pTable->nModuleArg==0 );
+  assert( pTable->u.vtab.nArg==0 );
   addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));
   addModuleArgument(pParse, pTable, 0);
   addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
@@ -140538,11 +144858,11 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse(
   ** sqlite_schema table, has already been made by sqlite3StartTable().
   ** The second call, to obtain permission to create the table, is made now.
   */
-  if( pTable->azModuleArg ){
+  if( pTable->u.vtab.azArg ){
     int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
     assert( iDb>=0 ); /* The database the table is being created in */
     sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
-            pTable->azModuleArg[0], pParse->db->aDb[iDb].zDbSName);
+            pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
   }
 #endif
 }
@@ -140570,9 +144890,10 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
   sqlite3 *db = pParse->db;         /* The database connection */
 
   if( pTab==0 ) return;
+  assert( IsVirtual(pTab) );
   addArgumentToVtab(pParse);
   pParse->sArg.z = 0;
-  if( pTab->nModuleArg<1 ) return;
+  if( pTab->u.vtab.nArg<1 ) return;
 
   /* If the CREATE VIRTUAL TABLE statement is being entered for the
   ** first time (in other words if the virtual table is actually being
@@ -140605,7 +144926,7 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
     */
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     sqlite3NestedParse(pParse,
-      "UPDATE %Q." DFLT_SCHEMA_TABLE " "
+      "UPDATE %Q." LEGACY_SCHEMA_TABLE " "
          "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
        "WHERE rowid=#%d",
       db->aDb[iDb].zDbSName,
@@ -140619,24 +144940,20 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
 
     sqlite3VdbeAddOp0(v, OP_Expire);
     zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt);
-    sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
+    sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
     sqlite3DbFree(db, zStmt);
 
     iReg = ++pParse->nMem;
     sqlite3VdbeLoadString(v, iReg, pTab->zName);
     sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
-  }
-
-  /* If we are rereading the sqlite_schema table create the in-memory
-  ** record of the table. The xConnect() method is not called until
-  ** the first time the virtual table is used in an SQL statement. This
-  ** allows a schema that contains virtual tables to be loaded before
-  ** the required virtual table implementations are registered.  */
-  else {
+  }else{
+    /* If we are rereading the sqlite_schema table create the in-memory
+    ** record of the table. */
     Table *pOld;
     Schema *pSchema = pTab->pSchema;
     const char *zName = pTab->zName;
-    assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
+    assert( zName!=0 );
+    sqlite3MarkAllShadowTablesOf(db, pTab);
     pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
     if( pOld ){
       sqlite3OomFault(db);
@@ -140687,13 +145004,16 @@ static int vtabCallConstructor(
   VtabCtx sCtx;
   VTable *pVTable;
   int rc;
-  const char *const*azArg = (const char *const*)pTab->azModuleArg;
-  int nArg = pTab->nModuleArg;
+  const char *const*azArg;
+  int nArg = pTab->u.vtab.nArg;
   char *zErr = 0;
   char *zModuleName;
   int iDb;
   VtabCtx *pCtx;
 
+  assert( IsVirtual(pTab) );
+  azArg = (const char *const*)pTab->u.vtab.azArg;
+
   /* Check that the virtual-table is not already being initialized */
   for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
     if( pCtx->pTab==pTab ){
@@ -140720,7 +145040,7 @@ static int vtabCallConstructor(
   pVTable->eVtabRisk = SQLITE_VTABRISK_Normal;
 
   iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-  pTab->azModuleArg[1] = db->aDb[iDb].zDbSName;
+  pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName;
 
   /* Invoke the virtual table constructor */
   assert( &db->pVtabCtx );
@@ -140759,12 +145079,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. Then loop through the
+      ** into the linked list headed by pTab->u.vtab.p. 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;
+      pVTable->pNext = pTab->u.vtab.p;
+      pTab->u.vtab.p = pVTable;
 
       for(iCol=0; iCol<pTab->nCol; iCol++){
         char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
@@ -140790,6 +145110,7 @@ static int vtabCallConstructor(
             zType[i-1] = '\0';
           }
           pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
+          pTab->tabFlags |= TF_HasHidden;
           oooHidden = TF_OOOHidden;
         }else{
           pTab->tabFlags |= oooHidden;
@@ -140816,16 +145137,17 @@ SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
   int rc;
 
   assert( pTab );
-  if( !IsVirtual(pTab) || sqlite3GetVTable(db, pTab) ){
+  assert( IsVirtual(pTab) );
+  if( sqlite3GetVTable(db, pTab) ){
     return SQLITE_OK;
   }
 
   /* Locate the required virtual table module */
-  zMod = pTab->azModuleArg[0];
+  zMod = pTab->u.vtab.azArg[0];
   pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 
   if( !pMod ){
-    const char *zModule = pTab->azModuleArg[0];
+    const char *zModule = pTab->u.vtab.azArg[0];
     sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
     rc = SQLITE_ERROR;
   }else{
@@ -140888,10 +145210,10 @@ SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab,
   const char *zMod;
 
   pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
-  assert( pTab && IsVirtual(pTab) && !pTab->pVTable );
+  assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p );
 
   /* Locate the required virtual table module */
-  zMod = pTab->azModuleArg[0];
+  zMod = pTab->u.vtab.azArg[0];
   pMod = (Module*)sqlite3HashFind(&db->aModule, zMod);
 
   /* If the module has been registered and includes a Create method,
@@ -140928,6 +145250,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   Table *pTab;
   char *zErr = 0;
   Parse sParse;
+  int initBusy;
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
@@ -140947,18 +145270,24 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   memset(&sParse, 0, sizeof(sParse));
   sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
   sParse.db = db;
+  /* We should never be able to reach this point while loading the
+  ** schema.  Nevertheless, defend against that (turn off db->init.busy)
+  ** in case a bug arises. */
+  assert( db->init.busy==0 );
+  initBusy = db->init.busy;
+  db->init.busy = 0;
   sParse.nQueryLoop = 1;
   if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr)
    && sParse.pNewTable
    && !db->mallocFailed
-   && !sParse.pNewTable->pSelect
-   && !IsVirtual(sParse.pNewTable)
+   && IsOrdinaryTable(sParse.pNewTable)
   ){
     if( !pTab->aCol ){
       Table *pNew = sParse.pNewTable;
       Index *pIdx;
       pTab->aCol = pNew->aCol;
-      pTab->nCol = pNew->nCol;
+      sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
+      pTab->nNVCol = pTab->nCol = pNew->nCol;
       pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
       pNew->nCol = 0;
       pNew->aCol = 0;
@@ -140993,6 +145322,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   }
   sqlite3DeleteTable(db, sParse.pNewTable);
   sqlite3ParserReset(&sParse);
+  db->init.busy = initBusy;
 
   assert( (rc&0xff)==rc );
   rc = sqlite3ApiExit(db, rc);
@@ -141012,10 +145342,13 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab
   Table *pTab;
 
   pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
-  if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){
+  if( ALWAYS(pTab!=0)
+   && ALWAYS(IsVirtual(pTab))
+   && ALWAYS(pTab->u.vtab.p!=0)
+  ){
     VTable *p;
     int (*xDestroy)(sqlite3_vtab *);
-    for(p=pTab->pVTable; p; p=p->pNext){
+    for(p=pTab->u.vtab.p; p; p=p->pNext){
       assert( p->pVtab );
       if( p->pVtab->nRef>0 ){
         return SQLITE_LOCKED;
@@ -141029,9 +145362,9 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab
     rc = xDestroy(p->pVtab);
     /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
     if( rc==SQLITE_OK ){
-      assert( pTab->pVTable==p && p->pNext==0 );
+      assert( pTab->u.vtab.p==p && p->pNext==0 );
       p->pVtab = 0;
-      pTab->pVTable = 0;
+      pTab->u.vtab.p = 0;
       sqlite3VtabUnlock(p);
     }
     sqlite3DeleteTable(db, pTab);
@@ -141245,6 +145578,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
   /* Check to see the left operand is a column in a virtual table */
   if( NEVER(pExpr==0) ) return pDef;
   if( pExpr->op!=TK_COLUMN ) return pDef;
+  assert( ExprUseYTab(pExpr) );
   pTab = pExpr->y.pTab;
   if( pTab==0 ) return pDef;
   if( !IsVirtual(pTab) ) return pDef;
@@ -141319,8 +145653,9 @@ SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
 /*
 ** Check to see if virtual table module pMod can be have an eponymous
 ** virtual table instance.  If it can, create one if one does not already
-** exist. Return non-zero if the eponymous virtual table instance exists
-** when this routine returns, and return zero if it does not exist.
+** exist. Return non-zero if either the eponymous virtual table instance
+** exists when this routine returns or if an attempt to create it failed
+** and an error message was left in pParse.
 **
 ** An eponymous virtual table instance is one that is named after its
 ** module, and more importantly, does not require a CREATE VIRTUAL TABLE
@@ -141347,9 +145682,11 @@ SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
   }
   pMod->pEpoTab = pTab;
   pTab->nTabRef = 1;
+  pTab->eTabType = TABTYP_VTAB;
   pTab->pSchema = db->aDb[0].pSchema;
-  assert( pTab->nModuleArg==0 );
+  assert( pTab->u.vtab.nArg==0 );
   pTab->iPKey = -1;
+  pTab->tabFlags |= TF_Eponymous;
   addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
   addModuleArgument(pParse, pTab, 0);
   addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
@@ -141358,7 +145695,6 @@ SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
     sqlite3ErrorMsg(pParse, "%s", zErr);
     sqlite3DbFree(db, zErr);
     sqlite3VtabEponymousTableClear(db, pMod);
-    return 0;
   }
   return 1;
 }
@@ -141490,19 +145826,6 @@ SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){
 #ifndef SQLITE_WHEREINT_H
 #define SQLITE_WHEREINT_H
 
-/*
-** Trace output macros
-*/
-#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
-/***/ extern int sqlite3WhereTrace;
-#endif
-#if defined(SQLITE_DEBUG) \
-    && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE))
-# define WHERETRACE(K,X)  if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X
-# define WHERETRACE_ENABLED 1
-#else
-# define WHERETRACE(K,X)
-#endif
 
 /* Forward references
 */
@@ -141564,7 +145887,7 @@ struct WhereLevel {
         u8 eEndLoopOp;         /* IN Loop terminator. OP_Next or OP_Prev */
       } *aInLoop;           /* Information about each nested IN operator */
     } in;                 /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */
-    Index *pCovidx;       /* Possible covering index for WHERE_MULTI_OR */
+    Index *pCoveringIdx;  /* Possible covering index for WHERE_MULTI_OR */
   } u;
   struct WhereLoop *pWLoop;  /* The selected WhereLoop object */
   Bitmask notReady;          /* FROM entries not usable at this level */
@@ -141756,11 +146079,7 @@ struct WhereTerm {
 #define TERM_ORINFO     0x0010 /* Need to free the WhereTerm.u.pOrInfo object */
 #define TERM_ANDINFO    0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */
 #define TERM_OR_OK      0x0040 /* Used during OR-clause processing */
-#ifdef SQLITE_ENABLE_STAT4
-#  define TERM_VNULL    0x0080 /* Manufactured x>NULL or x<=NULL term */
-#else
-#  define TERM_VNULL    0x0000 /* Disabled if not using stat4 */
-#endif
+#define TERM_VNULL      0x0080 /* Manufactured x>NULL or x<=NULL term */
 #define TERM_LIKEOPT    0x0100 /* Virtual terms from the LIKE optimization */
 #define TERM_LIKECOND   0x0200 /* Conditionally this LIKE operator term */
 #define TERM_LIKE       0x0400 /* The original LIKE operator */
@@ -141783,8 +146102,8 @@ struct WhereScan {
   const char *zCollName;     /* Required collating sequence, if not NULL */
   Expr *pIdxExpr;            /* Search for this index expression */
   char idxaff;               /* Must match this affinity, if zCollName!=NULL */
-  unsigned char nEquiv;      /* Number of entries in aEquiv[] */
-  unsigned char iEquiv;      /* Next unused slot in aEquiv[] */
+  unsigned char nEquiv;      /* Number of entries in aiCur[] and aiColumn[] */
+  unsigned char iEquiv;      /* Next unused slot in aiCur[] and aiColumn[] */
   u32 opMask;                /* Acceptable operators */
   int k;                     /* Resume scanning at this->pWC->a[this->k] */
   int aiCur[11];             /* Cursors in the equivalence class */
@@ -142030,7 +146349,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*);
 SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*);
 SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*);
 SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*);
-SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*);
+SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
 
 
 
@@ -142093,6 +146412,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereC
 #define WHERE_IN_EARLYOUT  0x00040000  /* Perhaps quit IN loops early */
 #define WHERE_BIGNULL_SORT 0x00080000  /* Column nEq of index is BIGNULL */
 #define WHERE_IN_SEEKSCAN  0x00100000  /* Seek-scan optimization for IN */
+#define WHERE_TRANSCONS    0x00200000  /* Uses a transitive constraint */
 
 #endif /* !defined(SQLITE_WHEREINT_H) */
 
@@ -142108,7 +146428,7 @@ static const char *explainIndexColumnName(Index *pIdx, int i){
   i = pIdx->aiColumn[i];
   if( i==XN_EXPR ) return "<expr>";
   if( i==XN_ROWID ) return "rowid";
-  return pIdx->pTable->aCol[i].zName;
+  return pIdx->pTable->aCol[i].zCnName;
 }
 
 /*
@@ -142208,7 +146528,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
   if( sqlite3ParseToplevel(pParse)->explain==2 )
 #endif
   {
-    struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
+    SrcItem *pItem = &pTabList->a[pLevel->iFrom];
     Vdbe *v = pParse->pVdbe;      /* VM being constructed */
     sqlite3 *db = pParse->db;     /* Database handle */
     int isSearch;                 /* True for a SEARCH. False for SCAN. */
@@ -142227,16 +146547,8 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
             || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX));
 
     sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH);
-    sqlite3_str_appendall(&str, isSearch ? "SEARCH" : "SCAN");
-    if( pItem->pSelect ){
-      sqlite3_str_appendf(&str, " SUBQUERY %u", pItem->pSelect->selId);
-    }else{
-      sqlite3_str_appendf(&str, " TABLE %s", pItem->zName);
-    }
-
-    if( pItem->zAlias ){
-      sqlite3_str_appendf(&str, " AS %s", pItem->zAlias);
-    }
+    str.printfFlags = SQLITE_PRINTF_INTERNAL;
+    sqlite3_str_appendf(&str, "%s %S", isSearch ? "SEARCH" : "SCAN", pItem);
     if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){
       const char *zFmt = 0;
       Index *pIdx;
@@ -142384,6 +146696,12 @@ static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
     }else{
       pTerm->wtFlags |= TERM_CODED;
     }
+#ifdef WHERETRACE_ENABLED
+    if( sqlite3WhereTrace & 0x20000 ){
+      sqlite3DebugPrintf("DISABLE-");
+      sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a)));
+    }
+#endif
     if( pTerm->iParent<0 ) break;
     pTerm = &pTerm->pWC->a[pTerm->iParent];
     assert( pTerm!=0 );
@@ -142497,16 +146815,23 @@ static Expr *removeUnindexableInClauseTerms(
   Expr *pNew;
   pNew = sqlite3ExprDup(db, pX, 0);
   if( db->mallocFailed==0 ){
-    ExprList *pOrigRhs = pNew->x.pSelect->pEList;  /* Original unmodified RHS */
-    ExprList *pOrigLhs = pNew->pLeft->x.pList;     /* Original unmodified LHS */
+    ExprList *pOrigRhs;         /* Original unmodified RHS */
+    ExprList *pOrigLhs;         /* Original unmodified LHS */
     ExprList *pRhs = 0;         /* New RHS after modifications */
     ExprList *pLhs = 0;         /* New LHS after mods */
     int i;                      /* Loop counter */
     Select *pSelect;            /* Pointer to the SELECT on the RHS */
 
+    assert( ExprUseXSelect(pNew) );
+    pOrigRhs = pNew->x.pSelect->pEList;
+    assert( pNew->pLeft!=0 );
+    assert( ExprUseXList(pNew->pLeft) );
+    pOrigLhs = pNew->pLeft->x.pList;
     for(i=iEq; i<pLoop->nLTerm; i++){
       if( pLoop->aLTerm[i]->pExpr==pX ){
-        int iField = pLoop->aLTerm[i]->u.x.iField - 1;
+        int iField;
+        assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );
+        iField = pLoop->aLTerm[i]->u.x.iField - 1;
         if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
         pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
         pOrigRhs->a[iField].pExpr = 0;
@@ -142621,7 +146946,7 @@ static int codeEqualityTerm(
     }
 
     iTab = 0;
-    if( (pX->flags & EP_xIsSelect)==0 || pX->x.pSelect->pEList->nExpr==1 ){
+    if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
       eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
     }else{
       sqlite3 *db = pParse->db;
@@ -142643,8 +146968,8 @@ static int codeEqualityTerm(
     sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
     VdbeCoverageIf(v, bRev);
     VdbeCoverageIf(v, !bRev);
-    assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
 
+    assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
     pLoop->wsFlags |= WHERE_IN_ABLE;
     if( pLevel->u.in.nIn==0 ){
       pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
@@ -142701,7 +147026,22 @@ static int codeEqualityTerm(
     sqlite3DbFree(pParse->db, aiMap);
 #endif
   }
-  disableTerm(pLevel, pTerm);
+
+  /* As an optimization, try to disable the WHERE clause term that is
+  ** driving the index as it will always be true.  The correct answer is
+  ** obtained regardless, but we might get the answer with fewer CPU cycles
+  ** by omitting the term.
+  **
+  ** But do not disable the term unless we are certain that the term is
+  ** not a transitive constraint.  For an example of where that does not
+  ** work, see https://sqlite.org/forum/forumpost/eb8613976a (2021-05-04)
+  */
+  if( (pLevel->pWLoop->wsFlags & WHERE_TRANSCONS)==0
+   || (pTerm->eOperator & WO_EQUIV)==0
+  ){
+    disableTerm(pLevel, pTerm);
+  }
+
   return iReg;
 }
 
@@ -142787,6 +147127,7 @@ static int codeAllEqualityTerms(
 
   if( nSkip ){
     int iIdxCur = pLevel->iIdxCur;
+    sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1);
     sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur);
     VdbeCoverageIf(v, bRev==0);
     VdbeCoverageIf(v, bRev!=0);
@@ -142821,7 +147162,7 @@ static int codeAllEqualityTerms(
         sqlite3ReleaseTempReg(pParse, regBase);
         regBase = r1;
       }else{
-        sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
+        sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
       }
     }
     if( pTerm->eOperator & WO_IN ){
@@ -142838,7 +147179,7 @@ static int codeAllEqualityTerms(
         sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
         VdbeCoverage(v);
       }
-      if( zAff ){
+      if( pParse->db->mallocFailed==0 && pParse->nErr==0 ){
         if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
           zAff[j] = SQLITE_AFF_BLOB;
         }
@@ -143001,7 +147342,7 @@ static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
 ** Insert an OP_CursorHint instruction if it is appropriate to do so.
 */
 static void codeCursorHint(
-  struct SrcList_item *pTabItem,  /* FROM clause item */
+  SrcItem *pTabItem,  /* FROM clause item */
   WhereInfo *pWInfo,    /* The where clause */
   WhereLevel *pLevel,   /* Which loop to provide hints for */
   WhereTerm *pEndRange  /* Hint this end-of-scan boundary term if not NULL */
@@ -143170,7 +147511,7 @@ static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
   assert( nReg>0 );
   if( p && sqlite3ExprIsVector(p) ){
 #ifndef SQLITE_OMIT_SUBQUERY
-    if( (p->flags & EP_xIsSelect) ){
+    if( ExprUseXSelect(p) ){
       Vdbe *v = pParse->pVdbe;
       int iSelect;
       assert( p->op==TK_SELECT );
@@ -143180,14 +147521,16 @@ static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
 #endif
     {
       int i;
-      ExprList *pList = p->x.pList;
+      const ExprList *pList;
+      assert( ExprUseXList(p) );
+      pList = p->x.pList;
       assert( nReg<=pList->nExpr );
       for(i=0; i<nReg; i++){
         sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
       }
     }
   }else{
-    assert( nReg==1 );
+    assert( nReg==1 || pParse->nErr );
     sqlite3ExprCode(pParse, p, iReg);
   }
 }
@@ -143233,10 +147576,10 @@ static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
     pExpr->op = TK_COLUMN;
     pExpr->iTable = pX->iIdxCur;
     pExpr->iColumn = pX->iIdxCol;
-    pExpr->y.pTab = 0;
     testcase( ExprHasProperty(pExpr, EP_Skip) );
     testcase( ExprHasProperty(pExpr, EP_Unlikely) );
-    ExprClearProperty(pExpr, EP_Skip|EP_Unlikely);
+    ExprClearProperty(pExpr, EP_Skip|EP_Unlikely|EP_WinFunc|EP_Subrtn);
+    pExpr->y.pTab = 0;
     return WRC_Prune;
   }else{
     return WRC_Continue;
@@ -143251,7 +147594,7 @@ static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){
   if( pExpr->op==TK_COLUMN ){
     IdxExprTrans *pX = p->u.pIdxTrans;
     if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
-      assert( pExpr->y.pTab!=0 );
+      assert( ExprUseYTab(pExpr) && pExpr->y.pTab!=0 );
       preserveExpr(pX, pExpr);
       pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
       pExpr->iTable = pX->iIdxCur;
@@ -143299,15 +147642,16 @@ static void whereIndexExprTrans(
   for(iIdxCol=0; iIdxCol<pIdx->nColumn; iIdxCol++){
     i16 iRef = pIdx->aiColumn[iIdxCol];
     if( iRef==XN_EXPR ){
-      assert( aColExpr->a[iIdxCol].pExpr!=0 );
+      assert( aColExpr!=0 && aColExpr->a[iIdxCol].pExpr!=0 );
       x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
       if( sqlite3ExprIsConstant(x.pIdxExpr) ) continue;
       w.xExprCallback = whereIndexExprTransNode;
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
     }else if( iRef>=0
        && (pTab->aCol[iRef].colFlags & COLFLAG_VIRTUAL)!=0
-       && (pTab->aCol[iRef].zColl==0
-           || sqlite3StrICmp(pTab->aCol[iRef].zColl, sqlite3StrBINARY)==0)
+       && ((pTab->aCol[iRef].colFlags & COLFLAG_HASCOLL)==0
+           || sqlite3StrICmp(sqlite3ColumnColl(&pTab->aCol[iRef]),
+                                               sqlite3StrBINARY)==0)
     ){
       /* Check to see if there are direct references to generated columns
       ** that are contained in the index.  Pulling the generated column
@@ -143376,7 +147720,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   WhereClause *pWC;    /* Decomposition of the entire WHERE clause */
   WhereTerm *pTerm;               /* A WHERE clause term */
   sqlite3 *db;                    /* Database connection */
-  struct SrcList_item *pTabItem;  /* FROM clause term being coded */
+  SrcItem *pTabItem;              /* FROM clause term being coded */
   int addrBrk;                    /* Jump here to break out of the loop */
   int addrHalt;                   /* addrBrk for the outermost loop */
   int addrCont;                   /* Jump here to continue with next cycle */
@@ -143487,7 +147831,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     pLevel->p1 = iCur;
     pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext;
     pLevel->p2 = sqlite3VdbeCurrentAddr(v);
-    iIn = pLevel->u.in.nIn;
+    assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
+    if( pLoop->wsFlags & WHERE_IN_ABLE ){
+      iIn = pLevel->u.in.nIn;
+    }else{
+      iIn = 0;
+    }
     for(j=nConstraint-1; j>=0; j--){
       pTerm = pLoop->aLTerm[j];
       if( (pTerm->eOperator & WO_IN)!=0 ) iIn--;
@@ -143564,9 +147913,6 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg);
     VdbeCoverage(v);
     pLevel->op = OP_Noop;
-    if( (pTerm->prereqAll & pLevel->notReady)==0 ){
-      pTerm->wtFlags |= TERM_CODED;
-    }
   }else if( (pLoop->wsFlags & WHERE_IPK)!=0
          && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0
   ){
@@ -143814,14 +148160,18 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     ** a forward order scan on a descending index, interchange the
     ** start and end terms (pRangeStart and pRangeEnd).
     */
-    if( (nEq<pIdx->nKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC))
-     || (bRev && pIdx->nKeyCol==nEq)
-    ){
+    if( (nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) ){
       SWAP(WhereTerm *, pRangeEnd, pRangeStart);
       SWAP(u8, bSeekPastNull, bStopAtNull);
       SWAP(u8, nBtm, nTop);
     }
 
+    if( iLevel>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 ){
+      /* In case OP_SeekScan is used, ensure that the index cursor does not
+      ** point to a valid row for the first iteration of this loop. */
+      sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
+    }
+
     /* Generate code to evaluate all constraint terms using == or IN
     ** and store the values of those terms in an array of registers
     ** starting at regBase.
@@ -143933,8 +148283,19 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     ** range (if any).
     */
     nConstraint = nEq;
+    assert( pLevel->p2==0 );
     if( pRangeEnd ){
       Expr *pRight = pRangeEnd->pExpr->pRight;
+      if( addrSeekScan ){
+        /* For a seek-scan that has a range on the lowest term of the index,
+        ** we have to make the top of the loop be code that sets the end
+        ** condition of the range.  Otherwise, the OP_SeekScan might jump
+        ** over that initialization, leaving the range-end value set to the
+        ** range-start value, resulting in a wrong answer.
+        ** See ticket 5981a8c041a3c2f3 (2021-11-02).
+        */
+        pLevel->p2 = sqlite3VdbeCurrentAddr(v);
+      }
       codeExprOrVector(pParse, pRight, regBase+nEq, nTop);
       whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
       if( (pRangeEnd->wtFlags & TERM_VNULL)==0
@@ -143968,7 +148329,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     sqlite3DbFree(db, zEndAff);
 
     /* Top of the loop body */
-    pLevel->p2 = sqlite3VdbeCurrentAddr(v);
+    if( pLevel->p2==0 ) pLevel->p2 = sqlite3VdbeCurrentAddr(v);
 
     /* Check if the index cursor is past the end of the range. */
     if( nConstraint ){
@@ -144158,7 +148519,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     */
     if( pWInfo->nLevel>1 ){
       int nNotReady;                 /* The number of notReady tables */
-      struct SrcList_item *origSrc;     /* Original list of tables */
+      SrcItem *origSrc;              /* Original list of tables */
       nNotReady = pWInfo->nLevel - iLevel - 1;
       pOrTab = sqlite3StackAllocRaw(db,
                             sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
@@ -144231,7 +148592,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         /* The extra 0x10000 bit on the opcode is masked off and does not
         ** become part of the new Expr.op.  However, it does make the
         ** op==TK_AND comparison inside of sqlite3PExpr() false, and this
-        ** prevents sqlite3PExpr() from implementing AND short-circuit
+        ** prevents sqlite3PExpr() from applying the AND short-circuit
         ** optimization, which we do not want here. */
         pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr);
       }
@@ -144247,10 +148608,16 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
       if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){
         WhereInfo *pSubWInfo;           /* Info for single OR-term scan */
         Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */
+        Expr *pDelete;                  /* Local copy of OR clause term */
         int jmp1 = 0;                   /* Address of jump operation */
         testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
                && !ExprHasProperty(pOrExpr, EP_FromJoin)
         ); /* See TH3 vtab25.400 and ticket 614b25314c766238 */
+        pDelete = pOrExpr = sqlite3ExprDup(db, pOrExpr, 0);
+        if( db->mallocFailed ){
+          sqlite3ExprDelete(db, pDelete);
+          continue;
+        }
         if( pAndExpr ){
           pAndExpr->pLeft = pOrExpr;
           pOrExpr = pAndExpr;
@@ -144365,10 +148732,14 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
           sqlite3WhereEnd(pSubWInfo);
           ExplainQueryPlanPop(pParse);
         }
+        sqlite3ExprDelete(db, pDelete);
       }
     }
     ExplainQueryPlanPop(pParse);
-    pLevel->u.pCovidx = pCov;
+    assert( pLevel->pWLoop==pLoop );
+    assert( (pLoop->wsFlags & WHERE_MULTI_OR)!=0 );
+    assert( (pLoop->wsFlags & WHERE_IN_ABLE)==0 );
+    pLevel->u.pCoveringIdx = pCov;
     if( pCov ) pLevel->iIdxCur = iCovCur;
     if( pAndExpr ){
       pAndExpr->pLeft = 0;
@@ -144512,12 +148883,13 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
 #endif
     assert( !ExprHasProperty(pE, EP_FromJoin) );
     assert( (pTerm->prereqRight & pLevel->notReady)!=0 );
+    assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
     pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady,
                     WO_EQ|WO_IN|WO_IS, 0);
     if( pAlt==0 ) continue;
     if( pAlt->wtFlags & (TERM_CODED) ) continue;
     if( (pAlt->eOperator & WO_IN)
-     && (pAlt->pExpr->flags & EP_xIsSelect)
+     && ExprUseXSelect(pAlt->pExpr)
      && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
     ){
       continue;
@@ -144529,6 +148901,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     sEAlt = *pAlt->pExpr;
     sEAlt.pLeft = pE->pLeft;
     sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL);
+    pAlt->wtFlags |= TERM_CODED;
   }
 
   /* For a LEFT OUTER JOIN, generate code that will record the fact that
@@ -144765,6 +149138,7 @@ static int isLikeOrGlob(
 #ifdef SQLITE_EBCDIC
   if( *pnoCase ) return 0;
 #endif
+  assert( ExprUseXList(pExpr) );
   pList = pExpr->x.pList;
   pLeft = pList->a[1].pExpr;
 
@@ -144780,7 +149154,8 @@ static int isLikeOrGlob(
     sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
     assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
   }else if( op==TK_STRING ){
-    z = (u8*)pRight->u.zToken;
+    assert( !ExprHasProperty(pRight, EP_IntValue) );
+     z = (u8*)pRight->u.zToken;
   }
   if( z ){
 
@@ -144809,7 +149184,9 @@ static int isLikeOrGlob(
       pPrefix = sqlite3Expr(db, TK_STRING, (char*)z);
       if( pPrefix ){
         int iFrom, iTo;
-        char *zNew = pPrefix->u.zToken;
+        char *zNew;
+        assert( !ExprHasProperty(pPrefix, EP_IntValue) );
+        zNew = pPrefix->u.zToken;
         zNew[cnt] = 0;
         for(iFrom=iTo=0; iFrom<cnt; iFrom++){
           if( zNew[iFrom]==wc[3] ) iFrom++;
@@ -144833,7 +149210,9 @@ static int isLikeOrGlob(
         */
         if( pLeft->op!=TK_COLUMN
          || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
-         || IsVirtual(pLeft->y.pTab)  /* Value might be numeric */
+         || (ALWAYS( ExprUseYTab(pLeft) )
+             && pLeft->y.pTab
+             && IsVirtual(pLeft->y.pTab))  /* Might be numeric */
         ){
           int isNum;
           double rDummy;
@@ -144861,6 +149240,7 @@ static int isLikeOrGlob(
       if( op==TK_VARIABLE ){
         Vdbe *v = pParse->pVdbe;
         sqlite3VdbeSetVarmask(v, pRight->iColumn);
+        assert( !ExprHasProperty(pRight, EP_IntValue) );
         if( *pisComplete && pRight->u.zToken[1] ){
           /* If the rhs of the LIKE expression is a variable, and the current
           ** value of the variable means there is no need to invoke the LIKE
@@ -144934,6 +149314,7 @@ static int isAuxiliaryVtabOperator(
     Expr *pCol;                     /* Column reference */
     int i;
 
+    assert( ExprUseXList(pExpr) );
     pList = pExpr->x.pList;
     if( pList==0 || pList->nExpr!=2 ){
       return 0;
@@ -144947,9 +149328,11 @@ static int isAuxiliaryVtabOperator(
     **       MATCH(expression,vtab_column)
     */
     pCol = pList->a[1].pExpr;
+    assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) );
     testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
     if( ExprIsVtab(pCol) ){
       for(i=0; i<ArraySize(aOp); i++){
+        assert( !ExprHasProperty(pExpr, EP_IntValue) );
         if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
           *peOp2 = aOp[i].eOp2;
           *ppRight = pList->a[0].pExpr;
@@ -144970,6 +149353,7 @@ static int isAuxiliaryVtabOperator(
     ** with function names in an arbitrary case.
     */
     pCol = pList->a[0].pExpr;
+    assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) );
     testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
     if( ExprIsVtab(pCol) ){
       sqlite3_vtab *pVtab;
@@ -144979,7 +149363,8 @@ static int isAuxiliaryVtabOperator(
       pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
       assert( pVtab!=0 );
       assert( pVtab->pModule!=0 );
-      pMod = (sqlite3_module *)pVtab->pModule;
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
+       pMod = (sqlite3_module *)pVtab->pModule;
       if( pMod->xFindFunction!=0 ){
         i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
         if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){
@@ -144994,10 +149379,12 @@ static int isAuxiliaryVtabOperator(
     int res = 0;
     Expr *pLeft = pExpr->pLeft;
     Expr *pRight = pExpr->pRight;
+    assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) );
     testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 );
     if( ExprIsVtab(pLeft) ){
       res++;
     }
+    assert( pRight==0 || pRight->op!=TK_COLUMN || ExprUseYTab(pRight) );
     testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 );
     if( pRight && ExprIsVtab(pRight) ){
       res++;
@@ -145081,6 +149468,7 @@ static void whereCombineDisjuncts(
   int op;                /* Operator for the combined expression */
   int idxNew;            /* Index in pWC of the next virtual term */
 
+  if( (pOne->wtFlags | pTwo->wtFlags) & TERM_VNULL ) return;
   if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
   if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
   if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp
@@ -145249,6 +149637,7 @@ static void exprAnalyzeOrTerm(
         pOrTerm->u.pAndInfo = pAndInfo;
         pOrTerm->wtFlags |= TERM_ANDINFO;
         pOrTerm->eOperator = WO_AND;
+        pOrTerm->leftCursor = -1;
         pAndWC = &pAndInfo->wc;
         memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic));
         sqlite3WhereClauseInit(pAndWC, pWC->pWInfo);
@@ -145291,11 +149680,10 @@ static void exprAnalyzeOrTerm(
   ** empty.
   */
   pOrInfo->indexable = indexable;
+  pTerm->eOperator = WO_OR;
+  pTerm->leftCursor = -1;
   if( indexable ){
-    pTerm->eOperator = WO_OR;
     pWC->hasOr = 1;
-  }else{
-    pTerm->eOperator = WO_OR;
   }
 
   /* For a two-way OR, attempt to implementation case 2.
@@ -145368,6 +149756,7 @@ static void exprAnalyzeOrTerm(
           assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
           continue;
         }
+        assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
         iColumn = pOrTerm->u.x.leftColumn;
         iCursor = pOrTerm->leftCursor;
         pLeft = pOrTerm->pExpr->pLeft;
@@ -145388,6 +149777,7 @@ static void exprAnalyzeOrTerm(
       okToChngToIN = 1;
       for(; i>=0 && okToChngToIN; i--, pOrTerm++){
         assert( pOrTerm->eOperator & WO_EQ );
+        assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
         if( pOrTerm->leftCursor!=iCursor ){
           pOrTerm->wtFlags &= ~TERM_OR_OK;
         }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR
@@ -145424,6 +149814,7 @@ static void exprAnalyzeOrTerm(
       for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
         if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue;
         assert( pOrTerm->eOperator & WO_EQ );
+        assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
         assert( pOrTerm->leftCursor==iCursor );
         assert( pOrTerm->u.x.leftColumn==iColumn );
         pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
@@ -145436,12 +149827,12 @@ static void exprAnalyzeOrTerm(
       if( pNew ){
         int idxNew;
         transferJoinMarkings(pNew, pExpr);
-        assert( !ExprHasProperty(pNew, EP_xIsSelect) );
+        assert( ExprUseXList(pNew) );
         pNew->x.pList = pList;
         idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
         testcase( idxNew==0 );
         exprAnalyze(pSrc, pWC, idxNew);
-        /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where used again */
+        /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where reused */
         markTermAsChild(pWC, idxNew, idxTerm);
       }else{
         sqlite3ExprListDelete(db, pList);
@@ -145564,7 +149955,9 @@ static int exprMightBeIndexed(
   assert( TK_IS<TK_GE && TK_ISNULL<TK_GE && TK_IN<TK_GE );
   assert( op<=TK_GE );
   if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
+    assert( ExprUseXList(pExpr) );
     pExpr = pExpr->x.pList->a[0].pExpr;
+
   }
 
   if( pExpr->op==TK_COLUMN ){
@@ -145577,6 +149970,7 @@ static int exprMightBeIndexed(
   return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr);
 }
 
+
 /*
 ** The input to this routine is an WhereTerm structure with only the
 ** "pExpr" field filled in.  The job of this routine is to analyze the
@@ -145628,7 +150022,7 @@ static void exprAnalyze(
   if( op==TK_IN ){
     assert( pExpr->pRight==0 );
     if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
-    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+    if( ExprUseXSelect(pExpr) ){
       pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
     }else{
       pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
@@ -145664,17 +150058,20 @@ static void exprAnalyze(
     if( pTerm->u.x.iField>0 ){
       assert( op==TK_IN );
       assert( pLeft->op==TK_VECTOR );
+      assert( ExprUseXList(pLeft) );
       pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;
     }
 
     if( exprMightBeIndexed(pSrc, prereqLeft, aiCurCol, pLeft, op) ){
       pTerm->leftCursor = aiCurCol[0];
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
       pTerm->u.x.leftColumn = aiCurCol[1];
       pTerm->eOperator = operatorMask(op) & opMask;
     }
     if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
     if( pRight
      && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op)
+     && !ExprHasProperty(pRight, EP_FixedCol)
     ){
       WhereTerm *pNew;
       Expr *pDup;
@@ -145705,11 +150102,23 @@ static void exprAnalyze(
       }
       pNew->wtFlags |= exprCommute(pParse, pDup);
       pNew->leftCursor = aiCurCol[0];
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
       pNew->u.x.leftColumn = aiCurCol[1];
       testcase( (prereqLeft | extraRight) != prereqLeft );
       pNew->prereqRight = prereqLeft | extraRight;
       pNew->prereqAll = prereqAll;
       pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
+    }else
+    if( op==TK_ISNULL
+     && !ExprHasProperty(pExpr,EP_FromJoin)
+     && 0==sqlite3ExprCanBeNull(pLeft)
+    ){
+      assert( !ExprHasProperty(pExpr, EP_IntValue) );
+      pExpr->op = TK_TRUEFALSE;
+      pExpr->u.zToken = "false";
+      ExprSetProperty(pExpr, EP_IsFalse);
+      pTerm->prereqAll = 0;
+      pTerm->eOperator = 0;
     }
   }
 
@@ -145730,9 +150139,11 @@ static void exprAnalyze(
   ** BETWEEN term is skipped.
   */
   else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
-    ExprList *pList = pExpr->x.pList;
+    ExprList *pList;
     int i;
     static const u8 ops[] = {TK_GE, TK_LE};
+    assert( ExprUseXList(pExpr) );
+    pList = pExpr->x.pList;
     assert( pList!=0 );
     assert( pList->nExpr==2 );
     for(i=0; i<2; i++){
@@ -145761,6 +150172,42 @@ static void exprAnalyze(
     pTerm = &pWC->a[idxTerm];
   }
 #endif /* SQLITE_OMIT_OR_OPTIMIZATION */
+  /* The form "x IS NOT NULL" can sometimes be evaluated more efficiently
+  ** as "x>NULL" if x is not an INTEGER PRIMARY KEY.  So construct a
+  ** virtual term of that form.
+  **
+  ** The virtual term must be tagged with TERM_VNULL.
+  */
+  else if( pExpr->op==TK_NOTNULL ){
+    if( pExpr->pLeft->op==TK_COLUMN
+     && pExpr->pLeft->iColumn>=0
+     && !ExprHasProperty(pExpr, EP_FromJoin)
+    ){
+      Expr *pNewExpr;
+      Expr *pLeft = pExpr->pLeft;
+      int idxNew;
+      WhereTerm *pNewTerm;
+
+      pNewExpr = sqlite3PExpr(pParse, TK_GT,
+                              sqlite3ExprDup(db, pLeft, 0),
+                              sqlite3ExprAlloc(db, TK_NULL, 0, 0));
+
+      idxNew = whereClauseInsert(pWC, pNewExpr,
+                                TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
+      if( idxNew ){
+        pNewTerm = &pWC->a[idxNew];
+        pNewTerm->prereqRight = 0;
+        pNewTerm->leftCursor = pLeft->iTable;
+        pNewTerm->u.x.leftColumn = pLeft->iColumn;
+        pNewTerm->eOperator = WO_GT;
+        markTermAsChild(pWC, idxNew, idxTerm);
+        pTerm = &pWC->a[idxTerm];
+        pTerm->wtFlags |= TERM_COPIED;
+        pNewTerm->prereqAll = pTerm->prereqAll;
+      }
+    }
+  }
+
 
 #ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
   /* Add constraints to reduce the search space on a LIKE or GLOB
@@ -145776,7 +150223,8 @@ static void exprAnalyze(
   ** bound is made all lowercase so that the bounds also work when comparing
   ** BLOBs.
   */
-  if( pWC->op==TK_AND
+  else if( pExpr->op==TK_FUNCTION
+   && pWC->op==TK_AND
    && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
   ){
     Expr *pLeft;       /* LHS of LIKE/GLOB operator */
@@ -145788,8 +150236,12 @@ static void exprAnalyze(
     const char *zCollSeqName;     /* Name of collating sequence */
     const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC;
 
+    assert( ExprUseXList(pExpr) );
     pLeft = pExpr->x.pList->a[1].pExpr;
     pStr2 = sqlite3ExprDup(db, pStr1, 0);
+    assert( pStr1==0 || !ExprHasProperty(pStr1, EP_IntValue) );
+    assert( pStr2==0 || !ExprHasProperty(pStr2, EP_IntValue) );
+
 
     /* Convert the lower bound to upper-case and the upper bound to
     ** lower-case (upper-case is less than lower-case in ASCII) so that
@@ -145846,52 +150298,6 @@ static void exprAnalyze(
   }
 #endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
 
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  /* Add a WO_AUX auxiliary term to the constraint set if the
-  ** current expression is of the form "column OP expr" where OP
-  ** is an operator that gets passed into virtual tables but which is
-  ** not normally optimized for ordinary tables.  In other words, OP
-  ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL.
-  ** This information is used by the xBestIndex methods of
-  ** virtual tables.  The native query optimizer does not attempt
-  ** to do anything with MATCH functions.
-  */
-  if( pWC->op==TK_AND ){
-    Expr *pRight = 0, *pLeft = 0;
-    int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
-    while( res-- > 0 ){
-      int idxNew;
-      WhereTerm *pNewTerm;
-      Bitmask prereqColumn, prereqExpr;
-
-      prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight);
-      prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft);
-      if( (prereqExpr & prereqColumn)==0 ){
-        Expr *pNewExpr;
-        pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
-            0, sqlite3ExprDup(db, pRight, 0));
-        if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
-          ExprSetProperty(pNewExpr, EP_FromJoin);
-          pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
-        }
-        idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
-        testcase( idxNew==0 );
-        pNewTerm = &pWC->a[idxNew];
-        pNewTerm->prereqRight = prereqExpr;
-        pNewTerm->leftCursor = pLeft->iTable;
-        pNewTerm->u.x.leftColumn = pLeft->iColumn;
-        pNewTerm->eOperator = WO_AUX;
-        pNewTerm->eMatchOp = eOp2;
-        markTermAsChild(pWC, idxNew, idxTerm);
-        pTerm = &pWC->a[idxTerm];
-        pTerm->wtFlags |= TERM_COPIED;
-        pNewTerm->prereqAll = pTerm->prereqAll;
-      }
-      SWAP(Expr*, pLeft, pRight);
-    }
-  }
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
   /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create
   ** new terms for each component comparison - "a = ?" and "b = ?".  The
   ** new terms completely replace the original vector comparison, which is
@@ -145899,19 +150305,19 @@ static void exprAnalyze(
   **
   ** This is only required if at least one side of the comparison operation
   ** is not a sub-select.  */
-  if( pWC->op==TK_AND
-  && (pExpr->op==TK_EQ || pExpr->op==TK_IS)
-  && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
-  && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
-  && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
-    || (pExpr->pRight->flags & EP_xIsSelect)==0)
+  if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
+   && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
+   && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
+   && ( (pExpr->pLeft->flags & EP_xIsSelect)==0
+     || (pExpr->pRight->flags & EP_xIsSelect)==0)
+   && pWC->op==TK_AND
   ){
     int i;
     for(i=0; i<nLeft; i++){
       int idxNew;
       Expr *pNew;
-      Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i);
-      Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i);
+      Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
+      Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
 
       pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
       transferJoinMarkings(pNew, pExpr);
@@ -145932,12 +150338,15 @@ static void exprAnalyze(
   ** This only works if the RHS is a simple SELECT (not a compound) that does
   ** not use window functions.
   */
-  if( pWC->op==TK_AND && pExpr->op==TK_IN && pTerm->u.x.iField==0
+  else if( pExpr->op==TK_IN
+   && pTerm->u.x.iField==0
    && pExpr->pLeft->op==TK_VECTOR
+   && ALWAYS( ExprUseXSelect(pExpr) )
    && pExpr->x.pSelect->pPrior==0
 #ifndef SQLITE_OMIT_WINDOWFUNC
    && pExpr->x.pSelect->pWin==0
 #endif
+   && pWC->op==TK_AND
   ){
     int i;
     for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
@@ -145949,44 +150358,51 @@ static void exprAnalyze(
     }
   }
 
-#ifdef SQLITE_ENABLE_STAT4
-  /* When sqlite_stat4 histogram data is available an operator of the
-  ** form "x IS NOT NULL" can sometimes be evaluated more efficiently
-  ** as "x>NULL" if x is not an INTEGER PRIMARY KEY.  So construct a
-  ** virtual term of that form.
-  **
-  ** Note that the virtual term must be tagged with TERM_VNULL.
+#ifndef SQLITE_OMIT_VIRTUALTABLE
+  /* Add a WO_AUX auxiliary term to the constraint set if the
+  ** current expression is of the form "column OP expr" where OP
+  ** is an operator that gets passed into virtual tables but which is
+  ** not normally optimized for ordinary tables.  In other words, OP
+  ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL.
+  ** This information is used by the xBestIndex methods of
+  ** virtual tables.  The native query optimizer does not attempt
+  ** to do anything with MATCH functions.
   */
-  if( pExpr->op==TK_NOTNULL
-   && pExpr->pLeft->op==TK_COLUMN
-   && pExpr->pLeft->iColumn>=0
-   && !ExprHasProperty(pExpr, EP_FromJoin)
-   && OptimizationEnabled(db, SQLITE_Stat4)
-  ){
-    Expr *pNewExpr;
-    Expr *pLeft = pExpr->pLeft;
-    int idxNew;
-    WhereTerm *pNewTerm;
-
-    pNewExpr = sqlite3PExpr(pParse, TK_GT,
-                            sqlite3ExprDup(db, pLeft, 0),
-                            sqlite3ExprAlloc(db, TK_NULL, 0, 0));
-
-    idxNew = whereClauseInsert(pWC, pNewExpr,
-                              TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
-    if( idxNew ){
-      pNewTerm = &pWC->a[idxNew];
-      pNewTerm->prereqRight = 0;
-      pNewTerm->leftCursor = pLeft->iTable;
-      pNewTerm->u.x.leftColumn = pLeft->iColumn;
-      pNewTerm->eOperator = WO_GT;
-      markTermAsChild(pWC, idxNew, idxTerm);
-      pTerm = &pWC->a[idxTerm];
-      pTerm->wtFlags |= TERM_COPIED;
-      pNewTerm->prereqAll = pTerm->prereqAll;
+  else if( pWC->op==TK_AND ){
+    Expr *pRight = 0, *pLeft = 0;
+    int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight);
+    while( res-- > 0 ){
+      int idxNew;
+      WhereTerm *pNewTerm;
+      Bitmask prereqColumn, prereqExpr;
+
+      prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight);
+      prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft);
+      if( (prereqExpr & prereqColumn)==0 ){
+        Expr *pNewExpr;
+        pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
+            0, sqlite3ExprDup(db, pRight, 0));
+        if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
+          ExprSetProperty(pNewExpr, EP_FromJoin);
+          pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
+        }
+        idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
+        testcase( idxNew==0 );
+        pNewTerm = &pWC->a[idxNew];
+        pNewTerm->prereqRight = prereqExpr;
+        pNewTerm->leftCursor = pLeft->iTable;
+        pNewTerm->u.x.leftColumn = pLeft->iColumn;
+        pNewTerm->eOperator = WO_AUX;
+        pNewTerm->eMatchOp = eOp2;
+        markTermAsChild(pWC, idxNew, idxTerm);
+        pTerm = &pWC->a[idxTerm];
+        pTerm->wtFlags |= TERM_COPIED;
+        pNewTerm->prereqAll = pTerm->prereqAll;
+      }
+      SWAP(Expr*, pLeft, pRight);
     }
   }
-#endif /* SQLITE_ENABLE_STAT4 */
+#endif /* SQLITE_OMIT_VIRTUALTABLE */
 
   /* Prevent ON clause terms of a LEFT JOIN from being used to drive
   ** an index for tables to the left of the join.
@@ -146089,14 +150505,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){
   if( p->pRight ){
     mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
     assert( p->x.pList==0 );
-  }else if( ExprHasProperty(p, EP_xIsSelect) ){
+  }else if( ExprUseXSelect(p) ){
     if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1;
     mask |= exprSelectUsage(pMaskSet, p->x.pSelect);
   }else if( p->x.pList ){
     mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
   }
 #ifndef SQLITE_OMIT_WINDOWFUNC
-  if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && p->y.pWin ){
+  if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && ExprUseYWin(p) ){
+    assert( p->y.pWin!=0 );
     mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);
     mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy);
     mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter);
@@ -146146,7 +150563,7 @@ SQLITE_PRIVATE void sqlite3WhereExprAnalyze(
 */
 SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(
   Parse *pParse,                    /* Parsing context */
-  struct SrcList_item *pItem,       /* The FROM clause term to process */
+  SrcItem *pItem,                   /* The FROM clause term to process */
   WhereClause *pWC                  /* Xfer function arguments to here */
 ){
   Table *pTab;
@@ -146171,6 +150588,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(
     if( pColRef==0 ) return;
     pColRef->iTable = pItem->iCursor;
     pColRef->iColumn = k++;
+    assert( ExprUseYTab(pColRef) );
     pColRef->y.pTab = pTab;
     pRhs = sqlite3PExpr(pParse, TK_UPLUS,
         sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
@@ -146223,12 +150641,6 @@ struct HiddenIndexInfo {
 /* Forward declaration of methods */
 static int whereLoopResize(sqlite3*, WhereLoop*, int);
 
-/* Test variable that can be set to enable WHERE tracing */
-#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
-/***/ int sqlite3WhereTrace = 0;
-#endif
-
-
 /*
 ** Return the estimated number of output rows from a WHERE clause
 */
@@ -146291,6 +150703,32 @@ SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){
   return pInner->addrNxt;
 }
 
+/*
+** While generating code for the min/max optimization, after handling
+** the aggregate-step call to min() or max(), check to see if any
+** additional looping is required.  If the output order is such that
+** we are certain that the correct answer has already been found, then
+** code an OP_Goto to by pass subsequent processing.
+**
+** Any extra OP_Goto that is coded here is an optimization.  The
+** correct answer should be obtained regardless.  This OP_Goto just
+** makes the answer appear faster.
+*/
+SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe *v, WhereInfo *pWInfo){
+  WhereLevel *pInner;
+  int i;
+  if( !pWInfo->bOrderedInnerLoop ) return;
+  if( pWInfo->nOBSat==0 ) return;
+  for(i=pWInfo->nLevel-1; i>=0; i--){
+    pInner = &pWInfo->a[i];
+    if( (pInner->pWLoop->wsFlags & WHERE_COLUMN_IN)!=0 ){
+      sqlite3VdbeGoto(v, pInner->addrNxt);
+      return;
+    }
+  }
+  sqlite3VdbeGoto(v, pWInfo->iBreak);
+}
+
 /*
 ** Return the VDBE address or label to jump to in order to continue
 ** immediately with the next row of a WHERE clause.
@@ -146427,7 +150865,9 @@ static void createMask(WhereMaskSet *pMaskSet, int iCursor){
 */
 static Expr *whereRightSubexprIsColumn(Expr *p){
   p = sqlite3ExprSkipCollateAndLikely(p->pRight);
-  if( ALWAYS(p!=0) && p->op==TK_COLUMN ) return p;
+  if( ALWAYS(p!=0) && p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
+    return p;
+  }
   return 0;
 }
 
@@ -146450,8 +150890,10 @@ static WhereTerm *whereScanNext(WhereScan *pScan){
     iColumn = pScan->aiColumn[pScan->iEquiv-1];
     iCur = pScan->aiCur[pScan->iEquiv-1];
     assert( pWC!=0 );
+    assert( iCur>=0 );
     do{
       for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
+        assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 || pTerm->leftCursor<0 );
         if( pTerm->leftCursor==iCur
          && pTerm->u.x.leftColumn==iColumn
          && (iColumn!=XN_EXPR
@@ -146493,7 +150935,8 @@ static WhereTerm *whereScanNext(WhereScan *pScan){
               }
             }
             if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0
-             && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN
+             && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0))
+             && pX->op==TK_COLUMN
              && pX->iTable==pScan->aiCur[0]
              && pX->iColumn==pScan->aiColumn[0]
             ){
@@ -146502,6 +150945,18 @@ static WhereTerm *whereScanNext(WhereScan *pScan){
             }
             pScan->pWC = pWC;
             pScan->k = k+1;
+#ifdef WHERETRACE_ENABLED
+            if( sqlite3WhereTrace & 0x20000 ){
+              int ii;
+              sqlite3DebugPrintf("SCAN-TERM %p: nEquiv=%d",
+                 pTerm, pScan->nEquiv);
+              for(ii=0; ii<pScan->nEquiv; ii++){
+                sqlite3DebugPrintf(" {%d:%d}",
+                   pScan->aiCur[ii], pScan->aiColumn[ii]);
+              }
+              sqlite3DebugPrintf("\n");
+            }
+#endif
             return pTerm;
           }
         }
@@ -146658,7 +151113,7 @@ static int findIndexCol(
   for(i=0; i<pList->nExpr; i++){
     Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr);
     if( ALWAYS(p!=0)
-     && p->op==TK_COLUMN
+     && (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN)
      && p->iColumn==pIdx->aiColumn[iCol]
      && p->iTable==iBase
     ){
@@ -146723,7 +151178,8 @@ static int isDistinctRedundant(
   for(i=0; i<pDistinct->nExpr; i++){
     Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr);
     if( NEVER(p==0) ) continue;
-    if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
+    if( p->op!=TK_COLUMN && p->op!=TK_AGG_COLUMN ) continue;
+    if( p->iTable==iBase && p->iColumn<0 ) return 1;
   }
 
   /* Loop through all indices on the table, checking each to see if it makes
@@ -146741,6 +151197,7 @@ static int isDistinctRedundant(
   */
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
     if( !IsUniqueIndex(pIdx) ) continue;
+    if( pIdx->pPartIdxWhere ) continue;
     for(i=0; i<pIdx->nKeyCol; i++){
       if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){
         if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break;
@@ -146795,14 +151252,14 @@ static void translateColumnToCopy(
       pOp->p2 = pOp->p3;
       pOp->p3 = 0;
     }else if( pOp->opcode==OP_Rowid ){
-      if( iAutoidxCur ){
-        pOp->opcode = OP_Sequence;
-        pOp->p1 = iAutoidxCur;
-      }else{
+      pOp->opcode = OP_Sequence;
+      pOp->p1 = iAutoidxCur;
+#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
+      if( iAutoidxCur==0 ){
         pOp->opcode = OP_Null;
-        pOp->p1 = 0;
         pOp->p3 = 0;
       }
+#endif
     }
   }
 }
@@ -146860,7 +151317,7 @@ static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){
 */
 static int termCanDriveIndex(
   WhereTerm *pTerm,              /* WHERE clause term to check */
-  struct SrcList_item *pSrc,     /* Table we are trying to access */
+  SrcItem *pSrc,                 /* Table we are trying to access */
   Bitmask notReady               /* Tables in outer loops of the join */
 ){
   char aff;
@@ -146876,6 +151333,7 @@ static int termCanDriveIndex(
     return 0;
   }
   if( (pTerm->prereqRight & notReady)!=0 ) return 0;
+  assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
   if( pTerm->u.x.leftColumn<0 ) return 0;
   aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity;
   if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
@@ -146894,7 +151352,7 @@ static int termCanDriveIndex(
 static void constructAutomaticIndex(
   Parse *pParse,              /* The parsing context */
   WhereClause *pWC,           /* The WHERE clause */
-  struct SrcList_item *pSrc,  /* The FROM clause term to get the next index */
+  SrcItem *pSrc,              /* The FROM clause term to get the next index */
   Bitmask notReady,           /* Mask of cursors that are not available */
   WhereLevel *pLevel          /* Write new index here */
 ){
@@ -146918,7 +151376,7 @@ static void constructAutomaticIndex(
   u8 sentWarning = 0;         /* True if a warnning has been issued */
   Expr *pPartial = 0;         /* Partial Index Expression */
   int iContinue = 0;          /* Jump here to skip excluded rows */
-  struct SrcList_item *pTabItem;  /* FROM clause term being indexed */
+  SrcItem *pTabItem;          /* FROM clause term being indexed */
   int addrCounter = 0;        /* Address where integer counter is initialized */
   int regBase;                /* Array of registers where record is assembled */
 
@@ -146948,14 +151406,17 @@ static void constructAutomaticIndex(
                                 sqlite3ExprDup(pParse->db, pExpr, 0));
     }
     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
-      int iCol = pTerm->u.x.leftColumn;
-      Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
+      int iCol;
+      Bitmask cMask;
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
+      iCol = pTerm->u.x.leftColumn;
+      cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
       testcase( iCol==BMS );
       testcase( iCol==BMS-1 );
       if( !sentWarning ){
         sqlite3_log(SQLITE_WARNING_AUTOINDEX,
             "automatic index on %s(%s)", pTable->zName,
-            pTable->aCol[iCol].zName);
+            pTable->aCol[iCol].zCnName);
         sentWarning = 1;
       }
       if( (idxCols & cMask)==0 ){
@@ -146967,7 +151428,7 @@ static void constructAutomaticIndex(
       }
     }
   }
-  assert( nKeyCol>0 );
+  assert( nKeyCol>0 || pParse->db->mallocFailed );
   pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol;
   pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED
                      | WHERE_AUTO_INDEX;
@@ -147001,8 +151462,11 @@ static void constructAutomaticIndex(
   idxCols = 0;
   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
-      int iCol = pTerm->u.x.leftColumn;
-      Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
+      int iCol;
+      Bitmask cMask;
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
+      iCol = pTerm->u.x.leftColumn;
+      cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
       testcase( iCol==BMS-1 );
       testcase( iCol==BMS );
       if( (idxCols & cMask)==0 ){
@@ -147102,7 +151566,7 @@ static sqlite3_index_info *allocateIndexInfo(
   Parse *pParse,                  /* The parsing context */
   WhereClause *pWC,               /* The WHERE clause being analyzed */
   Bitmask mUnusable,              /* Ignore terms with these prereqs */
-  struct SrcList_item *pSrc,      /* The FROM clause term that is the vtab */
+  SrcItem *pSrc,                  /* The FROM clause term that is the vtab */
   ExprList *pOrderBy,             /* The ORDER BY clause */
   u16 *pmNoOmit                   /* Mask of terms not to omit */
 ){
@@ -147129,6 +151593,7 @@ static sqlite3_index_info *allocateIndexInfo(
     testcase( pTerm->eOperator & WO_ALL );
     if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
     if( pTerm->wtFlags & TERM_VNULL ) continue;
+    assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
     assert( pTerm->u.x.leftColumn>=(-1) );
     nTerm++;
   }
@@ -147189,6 +151654,7 @@ static sqlite3_index_info *allocateIndexInfo(
     ){
       continue;
     }
+    assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
     assert( pTerm->u.x.leftColumn>=(-1) );
     pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
     pIdxCons[j].iTermOffset = i;
@@ -147952,6 +152418,7 @@ SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){
     if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L';
     if( pTerm->wtFlags & TERM_CODED  ) zType[3] = 'C';
     if( pTerm->eOperator & WO_SINGLE ){
+      assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
       sqlite3_snprintf(sizeof(zLeft),zLeft,"left={%d:%d}",
                        pTerm->leftCursor, pTerm->u.x.leftColumn);
     }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){
@@ -147969,7 +152436,7 @@ SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){
       sqlite3DebugPrintf(" prob=%-3d prereq=%llx,%llx",
         pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight);
     }
-    if( pTerm->u.x.iField ){
+    if( (pTerm->eOperator & (WO_OR|WO_AND))==0 && pTerm->u.x.iField ){
       sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField);
     }
     if( pTerm->iParent>=0 ){
@@ -148000,7 +152467,7 @@ SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC){
 SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC){
   WhereInfo *pWInfo = pWC->pWInfo;
   int nb = 1+(pWInfo->pTabList->nSrc+3)/4;
-  struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab;
+  SrcItem *pItem = pWInfo->pTabList->a + p->iTab;
   Table *pTab = pItem->pTab;
   Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1;
   sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId,
@@ -148104,7 +152571,7 @@ static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
 static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){
   whereLoopClearUnion(db, pTo);
   if( whereLoopResize(db, pTo, pFrom->nLTerm) ){
-    memset(&pTo->u, 0, sizeof(pTo->u));
+    memset(pTo, 0, WHERE_LOOP_XFER_SZ);
     return SQLITE_NOMEM_BKPT;
   }
   memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
@@ -148133,7 +152600,8 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
   assert( pWInfo!=0 );
   for(i=0; i<pWInfo->nLevel; i++){
     WhereLevel *pLevel = &pWInfo->a[i];
-    if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){
+    if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE)!=0 ){
+      assert( (pLevel->pWLoop->wsFlags & WHERE_MULTI_OR)==0 );
       sqlite3DbFree(db, pLevel->u.in.aInLoop);
     }
   }
@@ -148147,10 +152615,22 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
   sqlite3DbFreeNN(db, pWInfo);
 }
 
+/* Undo all Expr node modifications
+*/
+static void whereUndoExprMods(WhereInfo *pWInfo){
+  while( pWInfo->pExprMods ){
+    WhereExprMod *p = pWInfo->pExprMods;
+    pWInfo->pExprMods = p->pNext;
+    memcpy(p->pExpr, &p->orig, sizeof(p->orig));
+    sqlite3DbFree(pWInfo->pParse->db, p);
+  }
+}
+
 /*
 ** Return TRUE if all of the following are true:
 **
-**   (1)  X has the same or lower cost that Y
+**   (1)  X has the same or lower cost, or returns the same or fewer rows,
+**        than Y.
 **   (2)  X uses fewer WHERE clause terms than Y
 **   (3)  Every WHERE clause term used by X is also used by Y
 **   (4)  X skips at least as many columns as Y
@@ -148173,11 +152653,8 @@ static int whereLoopCheaperProperSubset(
   if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
     return 0; /* X is not a subset of Y */
   }
+  if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0;
   if( pY->nSkip > pX->nSkip ) return 0;
-  if( pX->rRun >= pY->rRun ){
-    if( pX->rRun > pY->rRun ) return 0;    /* X costs more than Y */
-    if( pX->nOut > pY->nOut ) return 0;    /* X costs more than Y */
-  }
   for(i=pX->nLTerm-1; i>=0; i--){
     if( pX->aLTerm[i]==0 ) continue;
     for(j=pY->nLTerm-1; j>=0; j--){
@@ -148193,8 +152670,8 @@ static int whereLoopCheaperProperSubset(
 }
 
 /*
-** Try to adjust the cost of WhereLoop pTemplate upwards or downwards so
-** that:
+** Try to adjust the cost and number of output rows of WhereLoop pTemplate
+** upwards or downwards so that:
 **
 **   (1) pTemplate costs less than any other WhereLoops that are a proper
 **       subset of pTemplate
@@ -148215,16 +152692,20 @@ static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){
       /* Adjust pTemplate cost downward so that it is cheaper than its
       ** subset p. */
       WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",
-                       pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1));
-      pTemplate->rRun = p->rRun;
-      pTemplate->nOut = p->nOut - 1;
+                       pTemplate->rRun, pTemplate->nOut,
+                       MIN(p->rRun, pTemplate->rRun),
+                       MIN(p->nOut - 1, pTemplate->nOut)));
+      pTemplate->rRun = MIN(p->rRun, pTemplate->rRun);
+      pTemplate->nOut = MIN(p->nOut - 1, pTemplate->nOut);
     }else if( whereLoopCheaperProperSubset(pTemplate, p) ){
       /* Adjust pTemplate cost upward so that it is costlier than p since
       ** pTemplate is a proper subset of p */
       WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",
-                       pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1));
-      pTemplate->rRun = p->rRun;
-      pTemplate->nOut = p->nOut + 1;
+                       pTemplate->rRun, pTemplate->nOut,
+                       MAX(p->rRun, pTemplate->rRun),
+                       MAX(p->nOut + 1, pTemplate->nOut)));
+      pTemplate->rRun = MAX(p->rRun, pTemplate->rRun);
+      pTemplate->nOut = MAX(p->nOut + 1, pTemplate->nOut);
     }
   }
 }
@@ -148555,9 +153036,12 @@ static int whereRangeVectorLen(
     char aff;                     /* Comparison affinity */
     char idxaff = 0;              /* Indexed columns affinity */
     CollSeq *pColl;               /* Comparison collation sequence */
-    Expr *pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
-    Expr *pRhs = pTerm->pExpr->pRight;
-    if( pRhs->flags & EP_xIsSelect ){
+    Expr *pLhs, *pRhs;
+
+    assert( ExprUseXList(pTerm->pExpr->pLeft) );
+    pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr;
+    pRhs = pTerm->pExpr->pRight;
+    if( ExprUseXSelect(pRhs) ){
       pRhs = pRhs->x.pSelect->pEList->a[i].pExpr;
     }else{
       pRhs = pRhs->x.pList->a[i].pExpr;
@@ -148611,7 +153095,7 @@ static int whereRangeVectorLen(
 */
 static int whereLoopAddBtreeIndex(
   WhereLoopBuilder *pBuilder,     /* The WhereLoop factory */
-  struct SrcList_item *pSrc,      /* FROM clause term being analyzed */
+  SrcItem *pSrc,                  /* FROM clause term being analyzed */
   Index *pProbe,                  /* An index on pSrc */
   LogEst nInMul                   /* log(Number of iterations due to IN) */
 ){
@@ -148652,6 +153136,8 @@ static int whereLoopAddBtreeIndex(
   if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
 
   assert( pNew->u.btree.nEq<pProbe->nColumn );
+  assert( pNew->u.btree.nEq<pProbe->nKeyCol
+       || pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY );
 
   saved_nEq = pNew->u.btree.nEq;
   saved_nBtm = pNew->u.btree.nBtm;
@@ -148716,7 +153202,7 @@ static int whereLoopAddBtreeIndex(
 
     if( eOp & WO_IN ){
       Expr *pExpr = pTerm->pExpr;
-      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
+      if( ExprUseXSelect(pExpr) ){
         /* "x IN (SELECT ...)":  TUNING: the SELECT returns 25 rows */
         int i;
         nIn = 46;  assert( 46==sqlite3LogEst(25) );
@@ -148734,7 +153220,7 @@ static int whereLoopAddBtreeIndex(
         nIn = sqlite3LogEst(pExpr->x.pList->nExpr);
       }
       if( pProbe->hasStat1 && rLogSize>=10 ){
-        LogEst M, logK, safetyMargin;
+        LogEst M, logK, x;
         /* Let:
         **   N = the total number of rows in the table
         **   K = the number of entries on the RHS of the IN operator
@@ -148757,16 +153243,25 @@ static int whereLoopAddBtreeIndex(
         */
         M = pProbe->aiRowLogEst[saved_nEq];
         logK = estLog(nIn);
-        safetyMargin = 10;  /* TUNING: extra weight for indexed IN */
-        if( M + logK + safetyMargin < nIn + rLogSize ){
+        /* TUNING      v-----  10 to bias toward indexed IN */
+        x = M + logK + 10 - (nIn + rLogSize);
+        if( x>=0 ){
           WHERETRACE(0x40,
-            ("Scan preferred over IN operator on column %d of \"%s\" (%d<%d)\n",
-             saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
+            ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d) "
+             "prefers indexed lookup\n",
+             saved_nEq, M, logK, nIn, rLogSize, x));
+        }else if( nInMul<2 && OptimizationEnabled(db, SQLITE_SeekScan) ){
+          WHERETRACE(0x40,
+            ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d"
+             " nInMul=%d) prefers skip-scan\n",
+             saved_nEq, M, logK, nIn, rLogSize, x, nInMul));
           pNew->wsFlags |= WHERE_IN_SEEKSCAN;
         }else{
           WHERETRACE(0x40,
-            ("IN operator preferred on column %d of \"%s\" (%d>=%d)\n",
-             saved_nEq, pProbe->zName, M+logK+10, nIn+rLogSize));
+            ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d"
+             " nInMul=%d) prefers normal scan\n",
+             saved_nEq, M, logK, nIn, rLogSize, x, nInMul));
+          continue;
         }
       }
       pNew->wsFlags |= WHERE_COLUMN_IN;
@@ -148785,6 +153280,7 @@ static int whereLoopAddBtreeIndex(
           pNew->wsFlags |= WHERE_UNQ_WANTED;
         }
       }
+      if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS;
     }else if( eOp & WO_ISNULL ){
       pNew->wsFlags |= WHERE_COLUMN_NULL;
     }else if( eOp & (WO_GT|WO_GE) ){
@@ -148797,7 +153293,7 @@ static int whereLoopAddBtreeIndex(
       pBtm = pTerm;
       pTop = 0;
       if( pTerm->wtFlags & TERM_LIKEOPT ){
-        /* Range contraints that come from the LIKE optimization are
+        /* Range constraints that come from the LIKE optimization are
         ** always used in pairs. */
         pTop = &pTerm[1];
         assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
@@ -148846,8 +153342,8 @@ static int whereLoopAddBtreeIndex(
         tRowcnt nOut = 0;
         if( nInMul==0
          && pProbe->nSample
-         && pNew->u.btree.nEq<=pProbe->nSampleCol
-         && ((eOp & WO_IN)==0 || !ExprHasProperty(pTerm->pExpr, EP_xIsSelect))
+         && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol)
+         && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr))
          && OptimizationEnabled(db, SQLITE_Stat4)
         ){
           Expr *pExpr = pTerm->pExpr;
@@ -148928,6 +153424,8 @@ static int whereLoopAddBtreeIndex(
 
     if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
      && pNew->u.btree.nEq<pProbe->nColumn
+     && (pNew->u.btree.nEq<pProbe->nKeyCol ||
+           pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY)
     ){
       whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn);
     }
@@ -149049,6 +153547,7 @@ static int whereUsablePartialIndex(
     if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
      && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
      && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
+     && (pTerm->wtFlags & TERM_VNULL)==0
     ){
       return 1;
     }
@@ -149102,13 +153601,12 @@ static int whereLoopAddBtree(
   LogEst aiRowEstPk[2];       /* The aiRowLogEst[] value for the sPk index */
   i16 aiColumnPk = -1;        /* The aColumn[] value for the sPk index */
   SrcList *pTabList;          /* The FROM clause */
-  struct SrcList_item *pSrc;  /* The FROM clause btree term to add */
+  SrcItem *pSrc;              /* The FROM clause btree term to add */
   WhereLoop *pNew;            /* Template WhereLoop object */
   int rc = SQLITE_OK;         /* Return code */
   int iSortIdx = 1;           /* Index number */
   int b;                      /* A boolean value */
   LogEst rSize;               /* number of rows in the table */
-  LogEst rLogSize;            /* Logarithm of the number of rows in the table */
   WhereClause *pWC;           /* The parsed WHERE clause */
   Table *pTab;                /* Table being queried */
 
@@ -149120,9 +153618,10 @@ static int whereLoopAddBtree(
   pWC = pBuilder->pWC;
   assert( !IsVirtual(pSrc->pTab) );
 
-  if( pSrc->pIBIndex ){
+  if( pSrc->fg.isIndexedBy ){
+    assert( pSrc->fg.isCte==0 );
     /* An INDEXED BY clause specifies a particular index to use */
-    pProbe = pSrc->pIBIndex;
+    pProbe = pSrc->u2.pIBIndex;
   }else if( !HasRowid(pTab) ){
     pProbe = pTab->pIndex;
   }else{
@@ -149151,22 +153650,23 @@ static int whereLoopAddBtree(
     pProbe = &sPk;
   }
   rSize = pTab->nRowLogEst;
-  rLogSize = estLog(rSize);
 
 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
   /* Automatic indexes */
   if( !pBuilder->pOrSet      /* Not part of an OR optimization */
    && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
    && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
-   && pSrc->pIBIndex==0      /* Has no INDEXED BY clause */
+   && !pSrc->fg.isIndexedBy  /* Has no INDEXED BY clause */
    && !pSrc->fg.notIndexed   /* Has no NOT INDEXED clause */
    && HasRowid(pTab)         /* Not WITHOUT ROWID table. (FIXME: Why not?) */
    && !pSrc->fg.isCorrelated /* Not a correlated subquery */
    && !pSrc->fg.isRecursive  /* Not a recursive common table expression. */
   ){
     /* Generate auto-index WhereLoops */
+    LogEst rLogSize;         /* Logarithm of the number of rows in the table */
     WhereTerm *pTerm;
     WhereTerm *pWCEnd = pWC->a + pWC->nTerm;
+    rLogSize = estLog(rSize);
     for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){
       if( pTerm->prereqRight & pNew->maskSelf ) continue;
       if( termCanDriveIndex(pTerm, pSrc, 0) ){
@@ -149184,7 +153684,7 @@ static int whereLoopAddBtree(
         ** those objects, since there is no opportunity to add schema
         ** indexes on subqueries and views. */
         pNew->rSetup = rLogSize + rSize;
-        if( pTab->pSelect==0 && (pTab->tabFlags & TF_Ephemeral)==0 ){
+        if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
           pNew->rSetup += 28;
         }else{
           pNew->rSetup -= 10;
@@ -149208,7 +153708,7 @@ static int whereLoopAddBtree(
   /* Loop over all indices. If there was an INDEXED BY clause, then only
   ** consider index pProbe.  */
   for(; rc==SQLITE_OK && pProbe;
-      pProbe=(pSrc->pIBIndex ? 0 : pProbe->pNext), iSortIdx++
+      pProbe=(pSrc->fg.isIndexedBy ? 0 : pProbe->pNext), iSortIdx++
   ){
     int isLeft = (pSrc->fg.jointype & JT_OUTER)!=0;
     if( pProbe->pPartIdxWhere!=0
@@ -149383,7 +153883,7 @@ static int whereLoopAddVirtualOne(
   int rc = SQLITE_OK;
   WhereLoop *pNew = pBuilder->pNew;
   Parse *pParse = pBuilder->pWInfo->pParse;
-  struct SrcList_item *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
+  SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab];
   int nConstraint = pIdxInfo->nConstraint;
 
   assert( (mUsable & mPrereq)==mPrereq );
@@ -149575,7 +154075,7 @@ static int whereLoopAddVirtual(
   WhereInfo *pWInfo;           /* WHERE analysis context */
   Parse *pParse;               /* The parsing context */
   WhereClause *pWC;            /* The WHERE clause */
-  struct SrcList_item *pSrc;   /* The FROM clause term to search */
+  SrcItem *pSrc;               /* The FROM clause term to search */
   sqlite3_index_info *p;       /* Object to pass to xBestIndex() */
   int nConstraint;             /* Number of constraints in p */
   int bIn;                     /* True if plan uses IN(...) operator */
@@ -149703,7 +154203,7 @@ static int whereLoopAddOr(
   WhereClause tempWC;
   WhereLoopBuilder sSubBuild;
   WhereOrSet sSum, sCur;
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
 
   pWC = pBuilder->pWC;
   pWCEnd = pWC->a + pWC->nTerm;
@@ -149759,7 +154259,9 @@ static int whereLoopAddOr(
         if( rc==SQLITE_OK ){
           rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable);
         }
-        assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0 );
+        assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0
+                || rc==SQLITE_NOMEM );
+        testcase( rc==SQLITE_NOMEM && sCur.n>0 );
         testcase( rc==SQLITE_DONE );
         if( sCur.n==0 ){
           sSum.n = 0;
@@ -149819,8 +154321,8 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
   Bitmask mPrior = 0;
   int iTab;
   SrcList *pTabList = pWInfo->pTabList;
-  struct SrcList_item *pItem;
-  struct SrcList_item *pEnd = &pTabList->a[pWInfo->nLevel];
+  SrcItem *pItem;
+  SrcItem *pEnd = &pTabList->a[pWInfo->nLevel];
   sqlite3 *db = pWInfo->pParse->db;
   int rc = SQLITE_OK;
   WhereLoop *pNew;
@@ -149843,7 +154345,7 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     if( IsVirtual(pItem->pTab) ){
-      struct SrcList_item *p;
+      SrcItem *p;
       for(p=&pItem[1]; p<pEnd; p++){
         if( mUnusable || (p->fg.jointype & (JT_LEFT|JT_CROSS)) ){
           mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor);
@@ -149988,7 +154490,7 @@ static i8 wherePathSatisfiesOrderBy(
       if( MASKBIT(i) & obSat ) continue;
       pOBExpr = sqlite3ExprSkipCollateAndLikely(pOrderBy->a[i].pExpr);
       if( NEVER(pOBExpr==0) ) continue;
-      if( pOBExpr->op!=TK_COLUMN ) continue;
+      if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue;
       if( pOBExpr->iTable!=iCur ) continue;
       pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
                        ~ready, eqOpMask, 0);
@@ -150028,6 +154530,10 @@ static i8 wherePathSatisfiesOrderBy(
         assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
         assert( pIndex->aiColumn[nColumn-1]==XN_ROWID
                           || !HasRowid(pIndex->pTable));
+        /* All relevant terms of the index must also be non-NULL in order
+        ** for isOrderDistinct to be true.  So the isOrderDistint value
+        ** computed here might be a false positive.  Corrections will be
+        ** made at tag-20210426-1 below */
         isOrderDistinct = IsUniqueIndex(pIndex)
                           && (pLoop->wsFlags & WHERE_SKIPSCAN)==0;
       }
@@ -150095,14 +154601,18 @@ static i8 wherePathSatisfiesOrderBy(
         }
 
         /* An unconstrained column that might be NULL means that this
-        ** WhereLoop is not well-ordered
+        ** WhereLoop is not well-ordered.  tag-20210426-1
         */
-        if( isOrderDistinct
-         && iColumn>=0
-         && j>=pLoop->u.btree.nEq
-         && pIndex->pTable->aCol[iColumn].notNull==0
-        ){
-          isOrderDistinct = 0;
+        if( isOrderDistinct ){
+          if( iColumn>=0
+           && j>=pLoop->u.btree.nEq
+           && pIndex->pTable->aCol[iColumn].notNull==0
+          ){
+            isOrderDistinct = 0;
+          }
+          if( iColumn==XN_EXPR ){
+            isOrderDistinct = 0;
+          }
         }
 
         /* Find the ORDER BY term that corresponds to the j-th column
@@ -150117,7 +154627,7 @@ static i8 wherePathSatisfiesOrderBy(
           if( NEVER(pOBExpr==0) ) continue;
           if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0;
           if( iColumn>=XN_ROWID ){
-            if( pOBExpr->op!=TK_COLUMN ) continue;
+            if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue;
             if( pOBExpr->iTable!=iCur ) continue;
             if( pOBExpr->iColumn!=iColumn ) continue;
           }else{
@@ -150196,7 +154706,7 @@ static i8 wherePathSatisfiesOrderBy(
   if( obSat==obDone ) return (i8)nOrderBy;
   if( !isOrderDistinct ){
     for(i=nOrderBy-1; i>0; i--){
-      Bitmask m = MASKBIT(i) - 1;
+      Bitmask m = ALWAYS(i<BMS) ? MASKBIT(i) - 1 : 0;
       if( (obSat&m)==m ) return i;
     }
     return 0;
@@ -150286,7 +154796,7 @@ static LogEst whereSortingCost(
   }else if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT) ){
     /* TUNING: In the sort for a DISTINCT operator, assume that the DISTINCT
     ** reduces the number of output rows by a factor of 2 */
-    if( nRow>10 ) nRow -= 10;  assert( 10==sqlite3LogEst(2) );
+    if( nRow>10 ){ nRow -= 10;  assert( 10==sqlite3LogEst(2) ); }
   }
   rSortCost += estLog(nRow);
   return rSortCost;
@@ -150698,7 +155208,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
 */
 static int whereShortCut(WhereLoopBuilder *pBuilder){
   WhereInfo *pWInfo;
-  struct SrcList_item *pItem;
+  SrcItem *pItem;
   WhereClause *pWC;
   WhereTerm *pTerm;
   WhereLoop *pLoop;
@@ -150706,6 +155216,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
   int j;
   Table *pTab;
   Index *pIdx;
+  WhereScan scan;
 
   pWInfo = pBuilder->pWInfo;
   if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0;
@@ -150719,7 +155230,8 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
   pLoop = pBuilder->pNew;
   pLoop->wsFlags = 0;
   pLoop->nSkip = 0;
-  pTerm = sqlite3WhereFindTerm(pWC, iCur, -1, 0, WO_EQ|WO_IS, 0);
+  pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0);
+  while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
   if( pTerm ){
     testcase( pTerm->eOperator & WO_IS );
     pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW;
@@ -150738,7 +155250,8 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
       ) continue;
       opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ;
       for(j=0; j<pIdx->nKeyCol; j++){
-        pTerm = sqlite3WhereFindTerm(pWC, iCur, j, 0, opMask, pIdx);
+        pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx);
+        while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan);
         if( pTerm==0 ) break;
         testcase( pTerm->eOperator & WO_IS );
         pLoop->aLTerm[j] = pTerm;
@@ -150767,8 +155280,14 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
     if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){
       pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
     }
+    if( scan.iEquiv>1 ) pLoop->wsFlags |= WHERE_TRANSCONS;
 #ifdef SQLITE_DEBUG
     pLoop->cId = '0';
+#endif
+#ifdef WHERETRACE_ENABLED
+    if( sqlite3WhereTrace ){
+      sqlite3DebugPrintf("whereShortCut() used to compute solution\n");
+    }
 #endif
     return 1;
   }
@@ -151157,7 +155676,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
      pWInfo->revMask = ALLBITS;
   }
-  if( pParse->nErr || NEVER(db->mallocFailed) ){
+  if( pParse->nErr || db->mallocFailed ){
     goto whereBeginError;
   }
 #ifdef WHERETRACE_ENABLED
@@ -151218,7 +155737,8 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   */
   notReady = ~(Bitmask)0;
   if( pWInfo->nLevel>=2
-   && pResultSet!=0               /* guarantees condition (1) above */
+   && pResultSet!=0                         /* these two combine to guarantee */
+   && 0==(wctrlFlags & WHERE_AGG_DISTINCT)  /* condition (1) above */
    && OptimizationEnabled(db, SQLITE_OmitNoopJoin)
   ){
     int i;
@@ -151228,7 +155748,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     }
     for(i=pWInfo->nLevel-1; i>=1; i--){
       WhereTerm *pTerm, *pEnd;
-      struct SrcList_item *pItem;
+      SrcItem *pItem;
       pLoop = pWInfo->a[i].pWLoop;
       pItem = &pWInfo->pTabList->a[pLoop->iTab];
       if( (pItem->fg.jointype & JT_LEFT)==0 ) continue;
@@ -151318,13 +155838,13 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   for(ii=0, pLevel=pWInfo->a; ii<nTabList; ii++, pLevel++){
     Table *pTab;     /* Table to open */
     int iDb;         /* Index of database containing table/index */
-    struct SrcList_item *pTabItem;
+    SrcItem *pTabItem;
 
     pTabItem = &pTabList->a[pLevel->iFrom];
     pTab = pTabItem->pTab;
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     pLoop = pLevel->pWLoop;
-    if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
+    if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){
       /* Do nothing */
     }else
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -151449,6 +155969,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   for(ii=0; ii<nTabList; ii++){
     int addrExplain;
     int wsFlags;
+    if( pParse->nErr ) goto whereBeginError;
     pLevel = &pWInfo->a[ii];
     wsFlags = pLevel->pWLoop->wsFlags;
 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
@@ -151477,6 +155998,8 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   /* Jump here if malloc fails */
 whereBeginError:
   if( pWInfo ){
+    testcase( pWInfo->pExprMods!=0 );
+    whereUndoExprMods(pWInfo);
     pParse->nQueryLoop = pWInfo->savedNQueryLoop;
     whereInfoFree(db, pWInfo);
   }
@@ -151568,11 +156091,13 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     }else{
       sqlite3VdbeResolveLabel(v, pLevel->addrCont);
     }
-    if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
+    if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){
       struct InLoop *pIn;
       int j;
       sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
       for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
+        assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull
+                 || pParse->db->mallocFailed );
         sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
         if( pIn->eEndLoopOp!=OP_Noop ){
           if( pIn->nPrefix ){
@@ -151597,6 +156122,11 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
                   sqlite3VdbeCurrentAddr(v)+2,
                   pIn->iBase, pIn->nPrefix);
               VdbeCoverage(v);
+              /* Retarget the OP_IsNull against the left operand of IN so
+              ** it jumps past the OP_IfNoHope.  This is because the
+              ** OP_IsNull also bypasses the OP_Affinity opcode that is
+              ** required by OP_IfNoHope. */
+              sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
             }
           }
           sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
@@ -151630,8 +156160,14 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
         sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
       }
       if( (ws & WHERE_INDEXED)
-       || ((ws & WHERE_MULTI_OR) && pLevel->u.pCovidx)
+       || ((ws & WHERE_MULTI_OR) && pLevel->u.pCoveringIdx)
       ){
+        if( ws & WHERE_MULTI_OR ){
+          Index *pIx = pLevel->u.pCoveringIdx;
+          int iDb = sqlite3SchemaToIndex(db, pIx->pSchema);
+          sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
+          sqlite3VdbeSetP4KeyInfo(pParse, pIx);
+        }
         sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
       }
       if( pLevel->op==OP_Return ){
@@ -151655,7 +156191,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     int k, last;
     VdbeOp *pOp, *pLastOp;
     Index *pIdx = 0;
-    struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
+    SrcItem *pTabItem = &pTabList->a[pLevel->iFrom];
     Table *pTab = pTabItem->pTab;
     assert( pTab!=0 );
     pLoop = pLevel->pWLoop;
@@ -151678,7 +156214,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     ** created for the ONEPASS optimization.
     */
     if( (pTab->tabFlags & TF_Ephemeral)==0
-     && pTab->pSelect==0
+     && !IsView(pTab)
      && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
     ){
       int ws = pLoop->wsFlags;
@@ -151708,7 +156244,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){
       pIdx = pLoop->u.btree.pIndex;
     }else if( pLoop->wsFlags & WHERE_MULTI_OR ){
-      pIdx = pLevel->u.pCovidx;
+      pIdx = pLevel->u.pCoveringIdx;
     }
     if( pIdx
      && !db->mallocFailed
@@ -151731,7 +156267,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
 #endif
       pOp = sqlite3VdbeGetOp(v, k);
       pLastOp = pOp + (last - k);
-      assert( pOp<pLastOp );
+      assert( pOp<=pLastOp );
       do{
         if( pOp->p1!=pLevel->iTabCur ){
           /* no-op */
@@ -151776,16 +156312,9 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
     }
   }
 
-  /* Undo all Expr node modifications */
-  while( pWInfo->pExprMods ){
-    WhereExprMod *p = pWInfo->pExprMods;
-    pWInfo->pExprMods = p->pNext;
-    memcpy(p->pExpr, &p->orig, sizeof(p->orig));
-    sqlite3DbFree(db, p);
-  }
-
   /* Final cleanup
   */
+  if( pWInfo->pExprMods ) whereUndoExprMods(pWInfo);
   pParse->nQueryLoop = pWInfo->savedNQueryLoop;
   whereInfoFree(db, pWInfo);
   return;
@@ -152376,7 +156905,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
 /* Window functions that use all window interfaces: xStep, xFinal,
 ** xValue, and xInverse */
 #define WINDOWFUNCALL(name,nArg,extra) {                                   \
-  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
+  nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
   name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc,               \
   name ## InvFunc, name ## Name, {0}                                       \
 }
@@ -152384,7 +156913,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
 /* Window functions that are implemented using bytecode and thus have
 ** no-op routines for their methods */
 #define WINDOWFUNCNOOP(name,nArg,extra) {                                  \
-  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
+  nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
   noopStepFunc, noopValueFunc, noopValueFunc,                              \
   noopStepFunc, name ## Name, {0}                                          \
 }
@@ -152393,7 +156922,7 @@ static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
 ** same routine for xFinalize and xValue and which never call
 ** xInverse. */
 #define WINDOWFUNCX(name,nArg,extra) {                                     \
-  nArg, (SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,                      \
+  nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
   name ## StepFunc, name ## ValueFunc, name ## ValueFunc,                  \
   noopStepFunc, name ## Name, {0}                                          \
 }
@@ -152583,6 +157112,7 @@ static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
     case TK_AGG_FUNCTION:
     case TK_COLUMN: {
       int iCol = -1;
+      if( pParse->db->mallocFailed ) return WRC_Abort;
       if( p->pSub ){
         int i;
         for(i=0; i<p->pSub->nExpr; i++){
@@ -152692,14 +157222,17 @@ static ExprList *exprListAppendList(
     int i;
     int nInit = pList ? pList->nExpr : 0;
     for(i=0; i<pAppend->nExpr; i++){
-      Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
+      sqlite3 *db = pParse->db;
+      Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
       assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) );
-      if( bIntToNull && pDup ){
+      if( db->mallocFailed ){
+        sqlite3ExprDelete(db, pDup);
+        break;
+      }
+      if( bIntToNull ){
         int iDummy;
         Expr *pSub;
-        for(pSub=pDup; ExprHasProperty(pSub, EP_Skip); pSub=pSub->pLeft){
-          assert( pSub );
-        }
+        pSub = sqlite3ExprSkipCollateAndLikely(pDup);
         if( sqlite3ExprIsInteger(pSub, &iDummy) ){
           pSub->op = TK_NULL;
           pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
@@ -152730,6 +157263,15 @@ static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
   return WRC_Continue;
 }
 
+static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
+  if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){
+    assert( !ExprHasProperty(pExpr, EP_IntValue) );
+     sqlite3ErrorMsg(pWalker->pParse,
+         "misuse of aggregate: %s()", pExpr->u.zToken);
+  }
+  return WRC_Continue;
+}
+
 /*
 ** If the SELECT statement passed as the second argument does not invoke
 ** any SQL window functions, this function is a no-op. Otherwise, it
@@ -152739,7 +157281,7 @@ static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
 */
 SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
   int rc = SQLITE_OK;
-  if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){
+  if( p->pWin && p->pPrior==0 && ALWAYS((p->selFlags & SF_WinRewrite)==0) ){
     Vdbe *v = sqlite3GetVdbe(pParse);
     sqlite3 *db = pParse->db;
     Select *pSub = 0;             /* The subquery */
@@ -152763,6 +157305,11 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
     }
     sqlite3AggInfoPersistWalkerInit(&w, pParse);
     sqlite3WalkSelect(&w, p);
+    if( (p->selFlags & SF_Aggregate)==0 ){
+      w.xExprCallback = disallowAggregatesInOrderByCb;
+      w.xSelectCallback = 0;
+      sqlite3WalkExprList(&w, p->pOrderBy);
+    }
 
     p->pSrc = 0;
     p->pWhere = 0;
@@ -152807,7 +157354,9 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
     ** window function - one for the accumulator, another for interim
     ** results.  */
     for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-      ExprList *pArgs = pWin->pOwner->x.pList;
+      ExprList *pArgs;
+      assert( ExprUseXList(pWin->pOwner) );
+      pArgs = pWin->pOwner->x.pList;
       if( pWin->pFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){
         selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
         pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
@@ -152844,11 +157393,14 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
        ("New window-function subquery in FROM clause of (%u/%p)\n",
        p->selId, p));
     p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
+    assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside
+                                     ** of sqlite3DbMallocRawNN() called from
+                                     ** sqlite3SrcListAppend() */
     if( p->pSrc ){
       Table *pTab2;
       p->pSrc->a[0].pSelect = pSub;
       sqlite3SrcListAssignCursors(pParse, p->pSrc);
-      pSub->selFlags |= SF_Expanded;
+      pSub->selFlags |= SF_Expanded|SF_OrderByReqd;
       pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);
       pSub->selFlags |= (selFlags & SF_Aggregate);
       if( pTab2==0 ){
@@ -152871,7 +157423,11 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
       sqlite3SelectDelete(db, pSub);
     }
     if( db->mallocFailed ) rc = SQLITE_NOMEM;
-    sqlite3DbFree(db, pTab);
+
+    /* Defer deleting the temporary table pTab because if an error occurred,
+    ** there could still be references to that table embedded in the
+    ** result-set or ORDER BY clause of the SELECT statement p.  */
+    sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
   }
 
   if( rc ){
@@ -153099,15 +157655,19 @@ SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){
 ** SELECT, or (b) the windows already linked use a compatible window frame.
 */
 SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){
-  if( pSel!=0
-   && (0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0))
-  ){
-    pWin->pNextWin = pSel->pWin;
-    if( pSel->pWin ){
-      pSel->pWin->ppThis = &pWin->pNextWin;
+  if( pSel ){
+    if( 0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0) ){
+      pWin->pNextWin = pSel->pWin;
+      if( pSel->pWin ){
+        pSel->pWin->ppThis = &pWin->pNextWin;
+      }
+      pSel->pWin = pWin;
+      pWin->ppThis = &pSel->pWin;
+    }else{
+      if( sqlite3ExprListCompare(pWin->pPartition, pSel->pWin->pPartition,-1) ){
+        pSel->selFlags |= SF_MultiPart;
+      }
     }
-    pSel->pWin = pWin;
-    pWin->ppThis = &pSel->pWin;
   }
 }
 
@@ -153116,7 +157676,12 @@ SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){
 ** different, or 2 if it cannot be determined if the objects are identical
 ** or not. Identical window objects can be processed in a single scan.
 */
-SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){
+SQLITE_PRIVATE int sqlite3WindowCompare(
+  const Parse *pParse,
+  const Window *p1,
+  const Window *p2,
+  int bFilter
+){
   int res;
   if( NEVER(p1==0) || NEVER(p2==0) ) return 1;
   if( p1->eFrmType!=p2->eFrmType ) return 1;
@@ -153188,8 +157753,11 @@ SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){
       **   regApp+1: integer value used to ensure keys are unique
       **   regApp+2: output of MakeRecord
       */
-      ExprList *pList = pWin->pOwner->x.pList;
-      KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
+      ExprList *pList;
+      KeyInfo *pKeyInfo;
+      assert( ExprUseXList(pWin->pOwner) );
+      pList = pWin->pOwner->x.pList;
+      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
       pWin->csrApp = pParse->nTab++;
       pWin->regApp = pParse->nMem+1;
       pParse->nMem += 3;
@@ -153260,6 +157828,7 @@ static void windowCheckValue(Parse *pParse, int reg, int eCond){
     VdbeCoverageIf(v, eCond==2);
   }
   sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
+  sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC);
   VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */
   VdbeCoverageNeverNullIf(v, eCond==1); /*   the OP_MustBeInt */
   VdbeCoverageNeverNullIf(v, eCond==2);
@@ -153276,7 +157845,9 @@ static void windowCheckValue(Parse *pParse, int reg, int eCond){
 ** with the object passed as the only argument to this function.
 */
 static int windowArgCount(Window *pWin){
-  ExprList *pList = pWin->pOwner->x.pList;
+  const ExprList *pList;
+  assert( ExprUseXList(pWin->pOwner) );
+  pList = pWin->pOwner->x.pList;
   return (pList ? pList->nExpr : 0);
 }
 
@@ -153354,6 +157925,7 @@ struct WindowCodeArg {
   int regGosub;              /* Register used with OP_Gosub(addrGosub) */
   int regArg;                /* First in array of accumulator registers */
   int eDelete;               /* See above */
+  int regRowid;
 
   WindowCsrAndReg start;
   WindowCsrAndReg current;
@@ -153460,6 +158032,7 @@ static void windowAggStep(
       int addrIf = 0;
       if( pWin->pFilter ){
         int regTmp;
+        assert( ExprUseXList(pWin->pOwner) );
         assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr );
         assert( pWin->bExprArgs || nArg  ||pWin->pOwner->x.pList==0 );
         regTmp = sqlite3GetTempReg(pParse);
@@ -153470,15 +158043,16 @@ static void windowAggStep(
       }
 
       if( pWin->bExprArgs ){
-        int iStart = sqlite3VdbeCurrentAddr(v);
-        VdbeOp *pOp, *pEnd;
+        int iOp = sqlite3VdbeCurrentAddr(v);
+        int iEnd;
 
+        assert( ExprUseXList(pWin->pOwner) );
         nArg = pWin->pOwner->x.pList->nExpr;
         regArg = sqlite3GetTempRange(pParse, nArg);
         sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0);
 
-        pEnd = sqlite3VdbeGetOp(v, -1);
-        for(pOp=sqlite3VdbeGetOp(v, iStart); pOp<=pEnd; pOp++){
+        for(iEnd=sqlite3VdbeCurrentAddr(v); iOp<iEnd; iOp++){
+          VdbeOp *pOp = sqlite3VdbeGetOp(v, iOp);
           if( pOp->opcode==OP_Column && pOp->p1==pWin->iEphCsr ){
             pOp->p1 = csr;
           }
@@ -153487,6 +158061,7 @@ static void windowAggStep(
       if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
         CollSeq *pColl;
         assert( nArg>0 );
+        assert( ExprUseXList(pWin->pOwner) );
         pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
         sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ);
       }
@@ -153672,6 +158247,7 @@ static void windowReturnOneRow(WindowCodeArg *p){
 
     for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
       FuncDef *pFunc = pWin->pFunc;
+      assert( ExprUseXList(pWin->pOwner) );
       if( pFunc->zName==nth_valueName
        || pFunc->zName==first_valueName
       ){
@@ -153837,7 +158413,7 @@ static void windowIfNewPeer(
 **   if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl;
 **
 ** A special type of arithmetic is used such that if csr1.peerVal is not
-** a numeric type (real or integer), then the result of the addition addition
+** a numeric type (real or integer), then the result of the addition
 ** or subtraction is a a copy of csr1.peerVal.
 */
 static void windowCodeRangeTest(
@@ -153856,6 +158432,12 @@ static void windowCodeRangeTest(
   int regString = ++pParse->nMem;           /* Reg. for constant value '' */
   int arith = OP_Add;                       /* OP_Add or OP_Subtract */
   int addrGe;                               /* Jump destination */
+  int addrDone = sqlite3VdbeMakeLabel(pParse);   /* Address past OP_Ge */
+  CollSeq *pColl;
+
+  /* Read the peer-value from each cursor into a register */
+  windowReadPeerValues(p, csr1, reg1);
+  windowReadPeerValues(p, csr2, reg2);
 
   assert( op==OP_Ge || op==OP_Gt || op==OP_Le );
   assert( pOrderBy && pOrderBy->nExpr==1 );
@@ -153868,34 +158450,11 @@ static void windowCodeRangeTest(
     arith = OP_Subtract;
   }
 
-  /* Read the peer-value from each cursor into a register */
-  windowReadPeerValues(p, csr1, reg1);
-  windowReadPeerValues(p, csr2, reg2);
-
   VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl",
       reg1, (arith==OP_Add ? "+" : "-"), regVal,
       ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2
   ));
 
-  /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
-  ** This block adds (or subtracts for DESC) the numeric value in regVal
-  ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
-  ** then leave reg1 as it is. In pseudo-code, this is implemented as:
-  **
-  **   if( reg1>='' ) goto addrGe;
-  **   reg1 = reg1 +/- regVal
-  **   addrGe:
-  **
-  ** Since all strings and blobs are greater-than-or-equal-to an empty string,
-  ** the add/subtract is skipped for these, as required. If reg1 is a NULL,
-  ** then the arithmetic is performed, but since adding or subtracting from
-  ** NULL is always NULL anyway, this case is handled as required too.  */
-  sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
-  addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1);
-  VdbeCoverage(v);
-  sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1);
-  sqlite3VdbeJumpHere(v, addrGe);
-
   /* If the BIGNULL flag is set for the ORDER BY, then it is required to
   ** consider NULL values to be larger than all other values, instead of
   ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this
@@ -153932,21 +158491,46 @@ static void windowCodeRangeTest(
         break;
       default: assert( op==OP_Lt ); /* no-op */ break;
     }
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3);
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
 
     /* This block runs if reg1 is not NULL, but reg2 is. */
     sqlite3VdbeJumpHere(v, addr);
     sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); VdbeCoverage(v);
     if( op==OP_Gt || op==OP_Ge ){
-      sqlite3VdbeChangeP2(v, -1, sqlite3VdbeCurrentAddr(v)+1);
+      sqlite3VdbeChangeP2(v, -1, addrDone);
     }
   }
 
+  /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
+  ** This block adds (or subtracts for DESC) the numeric value in regVal
+  ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
+  ** then leave reg1 as it is. In pseudo-code, this is implemented as:
+  **
+  **   if( reg1>='' ) goto addrGe;
+  **   reg1 = reg1 +/- regVal
+  **   addrGe:
+  **
+  ** Since all strings and blobs are greater-than-or-equal-to an empty string,
+  ** the add/subtract is skipped for these, as required. If reg1 is a NULL,
+  ** then the arithmetic is performed, but since adding or subtracting from
+  ** NULL is always NULL anyway, this case is handled as required too.  */
+  sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
+  addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1);
+  VdbeCoverage(v);
+  if( (op==OP_Ge && arith==OP_Add) || (op==OP_Le && arith==OP_Subtract) ){
+    sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
+  }
+  sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1);
+  sqlite3VdbeJumpHere(v, addrGe);
+
   /* Compare registers reg2 and reg1, taking the jump if required. Note that
   ** control skips over this test if the BIGNULL flag is set and either
   ** reg1 or reg2 contain a NULL value.  */
   sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
+  pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
+  sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ);
   sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
+  sqlite3VdbeResolveLabel(v, addrDone);
 
   assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le );
   testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
@@ -154022,16 +158606,24 @@ static int windowCodeOp(
   /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or
   ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the
   ** start cursor does not advance past the end cursor within the
-  ** temporary table. It otherwise might, if (a>b).  */
+  ** temporary table. It otherwise might, if (a>b). Also ensure that,
+  ** if the input cursor is still finding new rows, that the end
+  ** cursor does not go past it to EOF. */
   if( pMWin->eStart==pMWin->eEnd && regCountdown
-   && pMWin->eFrmType==TK_RANGE && op==WINDOW_AGGINVERSE
+   && pMWin->eFrmType==TK_RANGE
   ){
     int regRowid1 = sqlite3GetTempReg(pParse);
     int regRowid2 = sqlite3GetTempReg(pParse);
-    sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
-    sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
-    sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1);
-    VdbeCoverage(v);
+    if( op==WINDOW_AGGINVERSE ){
+      sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
+      sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
+      sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1);
+      VdbeCoverage(v);
+    }else if( p->regRowid ){
+      sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1);
+      sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1);
+      VdbeCoverageNeverNull(v);
+    }
     sqlite3ReleaseTempReg(pParse, regRowid1);
     sqlite3ReleaseTempReg(pParse, regRowid2);
     assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING );
@@ -154528,7 +159120,6 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
   int addrEmpty;                  /* Address of OP_Rewind in flush: */
   int regNew;                     /* Array of registers holding new input row */
   int regRecord;                  /* regNew array in record form */
-  int regRowid;                   /* Rowid for regRecord in eph table */
   int regNewPeer = 0;             /* Peer values for new row (part of regNew) */
   int regPeer = 0;                /* Peer values for current row */
   int regFlushPart = 0;           /* Register for "Gosub flush_partition" */
@@ -154600,7 +159191,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
   regNew = pParse->nMem+1;
   pParse->nMem += nInput;
   regRecord = ++pParse->nMem;
-  regRowid = ++pParse->nMem;
+  s.regRowid = ++pParse->nMem;
 
   /* If the window frame contains an "<expr> PRECEDING" or "<expr> FOLLOWING"
   ** clause, allocate registers to store the results of evaluating each
@@ -154656,9 +159247,9 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
   }
 
   /* Insert the new row into the ephemeral table */
-  sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid);
-  sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid);
-  addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, regRowid);
+  sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid);
+  sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid);
+  addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid);
   VdbeCoverageNeverNull(v);
 
   /* This block is run for the first row of each partition */
@@ -154776,6 +159367,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
     sqlite3VdbeJumpHere(v, addrGosubFlush);
   }
 
+  s.regRowid = 0;
   addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
   VdbeCoverage(v);
   if( pMWin->eEnd==TK_PRECEDING ){
@@ -154952,11 +159544,21 @@ static void updateDeleteLimitError(
   static void parserDoubleLinkSelect(Parse *pParse, Select *p){
     assert( p!=0 );
     if( p->pPrior ){
-      Select *pNext = 0, *pLoop;
-      int mxSelect, cnt = 0;
-      for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
+      Select *pNext = 0, *pLoop = p;
+      int mxSelect, cnt = 1;
+      while(1){
         pLoop->pNext = pNext;
         pLoop->selFlags |= SF_Compound;
+        pNext = pLoop;
+        pLoop = pLoop->pPrior;
+        if( pLoop==0 ) break;
+        cnt++;
+        if( pLoop->pOrderBy || pLoop->pLimit ){
+          sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
+             pLoop->pOrderBy!=0 ? "ORDER BY" : "LIMIT",
+             sqlite3SelectOpName(pNext->op));
+          break;
+        }
       }
       if( (p->selFlags & SF_MultiValue)==0 &&
         (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&
@@ -154967,6 +159569,19 @@ static void updateDeleteLimitError(
     }
   }
 
+  /* Attach a With object describing the WITH clause to a Select
+  ** object describing the query for which the WITH clause is a prefix.
+  */
+  static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){
+    if( pSelect ){
+      pSelect->pWith = pWith;
+      parserDoubleLinkSelect(pParse, pSelect);
+    }else{
+      sqlite3WithDelete(pParse->db, pWith);
+    }
+    return pSelect;
+  }
+
 
   /* Construct a new Expr object from a single identifier.  Use the
   ** new Expr to populate pOut.  Set the span of pOut to be the identifier
@@ -154982,9 +159597,9 @@ static void updateDeleteLimitError(
       ExprClearVVAProperties(p);
       p->iAgg = -1;
       p->pLeft = p->pRight = 0;
-      p->x.pList = 0;
       p->pAggInfo = 0;
-      p->y.pTab = 0;
+      memset(&p->x, 0, sizeof(p->x));
+      memset(&p->y, 0, sizeof(p->y));
       p->op2 = 0;
       p->iTable = 0;
       p->iColumn = 0;
@@ -155070,8 +159685,8 @@ static void updateDeleteLimitError(
 #define TK_LP                             22
 #define TK_RP                             23
 #define TK_AS                             24
-#define TK_WITHOUT                        25
-#define TK_COMMA                          26
+#define TK_COMMA                          25
+#define TK_WITHOUT                        26
 #define TK_ABORT                          27
 #define TK_ACTION                         28
 #define TK_AFTER                          29
@@ -155142,90 +159757,93 @@ static void updateDeleteLimitError(
 #define TK_TIES                           94
 #define TK_GENERATED                      95
 #define TK_ALWAYS                         96
-#define TK_REINDEX                        97
-#define TK_RENAME                         98
-#define TK_CTIME_KW                       99
-#define TK_ANY                            100
-#define TK_BITAND                         101
-#define TK_BITOR                          102
-#define TK_LSHIFT                         103
-#define TK_RSHIFT                         104
-#define TK_PLUS                           105
-#define TK_MINUS                          106
-#define TK_STAR                           107
-#define TK_SLASH                          108
-#define TK_REM                            109
-#define TK_CONCAT                         110
-#define TK_COLLATE                        111
-#define TK_BITNOT                         112
-#define TK_ON                             113
-#define TK_INDEXED                        114
-#define TK_STRING                         115
-#define TK_JOIN_KW                        116
-#define TK_CONSTRAINT                     117
-#define TK_DEFAULT                        118
-#define TK_NULL                           119
-#define TK_PRIMARY                        120
-#define TK_UNIQUE                         121
-#define TK_CHECK                          122
-#define TK_REFERENCES                     123
-#define TK_AUTOINCR                       124
-#define TK_INSERT                         125
-#define TK_DELETE                         126
-#define TK_UPDATE                         127
-#define TK_SET                            128
-#define TK_DEFERRABLE                     129
-#define TK_FOREIGN                        130
-#define TK_DROP                           131
-#define TK_UNION                          132
-#define TK_ALL                            133
-#define TK_EXCEPT                         134
-#define TK_INTERSECT                      135
-#define TK_SELECT                         136
-#define TK_VALUES                         137
-#define TK_DISTINCT                       138
-#define TK_DOT                            139
-#define TK_FROM                           140
-#define TK_JOIN                           141
-#define TK_USING                          142
-#define TK_ORDER                          143
-#define TK_GROUP                          144
-#define TK_HAVING                         145
-#define TK_LIMIT                          146
-#define TK_WHERE                          147
-#define TK_INTO                           148
-#define TK_NOTHING                        149
-#define TK_FLOAT                          150
-#define TK_BLOB                           151
-#define TK_INTEGER                        152
-#define TK_VARIABLE                       153
-#define TK_CASE                           154
-#define TK_WHEN                           155
-#define TK_THEN                           156
-#define TK_ELSE                           157
-#define TK_INDEX                          158
-#define TK_ALTER                          159
-#define TK_ADD                            160
-#define TK_WINDOW                         161
-#define TK_OVER                           162
-#define TK_FILTER                         163
-#define TK_COLUMN                         164
-#define TK_AGG_FUNCTION                   165
-#define TK_AGG_COLUMN                     166
-#define TK_TRUEFALSE                      167
-#define TK_ISNOT                          168
-#define TK_FUNCTION                       169
-#define TK_UMINUS                         170
-#define TK_UPLUS                          171
-#define TK_TRUTH                          172
-#define TK_REGISTER                       173
-#define TK_VECTOR                         174
-#define TK_SELECT_COLUMN                  175
-#define TK_IF_NULL_ROW                    176
-#define TK_ASTERISK                       177
-#define TK_SPAN                           178
-#define TK_SPACE                          179
-#define TK_ILLEGAL                        180
+#define TK_MATERIALIZED                   97
+#define TK_REINDEX                        98
+#define TK_RENAME                         99
+#define TK_CTIME_KW                       100
+#define TK_ANY                            101
+#define TK_BITAND                         102
+#define TK_BITOR                          103
+#define TK_LSHIFT                         104
+#define TK_RSHIFT                         105
+#define TK_PLUS                           106
+#define TK_MINUS                          107
+#define TK_STAR                           108
+#define TK_SLASH                          109
+#define TK_REM                            110
+#define TK_CONCAT                         111
+#define TK_COLLATE                        112
+#define TK_BITNOT                         113
+#define TK_ON                             114
+#define TK_INDEXED                        115
+#define TK_STRING                         116
+#define TK_JOIN_KW                        117
+#define TK_CONSTRAINT                     118
+#define TK_DEFAULT                        119
+#define TK_NULL                           120
+#define TK_PRIMARY                        121
+#define TK_UNIQUE                         122
+#define TK_CHECK                          123
+#define TK_REFERENCES                     124
+#define TK_AUTOINCR                       125
+#define TK_INSERT                         126
+#define TK_DELETE                         127
+#define TK_UPDATE                         128
+#define TK_SET                            129
+#define TK_DEFERRABLE                     130
+#define TK_FOREIGN                        131
+#define TK_DROP                           132
+#define TK_UNION                          133
+#define TK_ALL                            134
+#define TK_EXCEPT                         135
+#define TK_INTERSECT                      136
+#define TK_SELECT                         137
+#define TK_VALUES                         138
+#define TK_DISTINCT                       139
+#define TK_DOT                            140
+#define TK_FROM                           141
+#define TK_JOIN                           142
+#define TK_USING                          143
+#define TK_ORDER                          144
+#define TK_GROUP                          145
+#define TK_HAVING                         146
+#define TK_LIMIT                          147
+#define TK_WHERE                          148
+#define TK_RETURNING                      149
+#define TK_INTO                           150
+#define TK_NOTHING                        151
+#define TK_FLOAT                          152
+#define TK_BLOB                           153
+#define TK_INTEGER                        154
+#define TK_VARIABLE                       155
+#define TK_CASE                           156
+#define TK_WHEN                           157
+#define TK_THEN                           158
+#define TK_ELSE                           159
+#define TK_INDEX                          160
+#define TK_ALTER                          161
+#define TK_ADD                            162
+#define TK_WINDOW                         163
+#define TK_OVER                           164
+#define TK_FILTER                         165
+#define TK_COLUMN                         166
+#define TK_AGG_FUNCTION                   167
+#define TK_AGG_COLUMN                     168
+#define TK_TRUEFALSE                      169
+#define TK_ISNOT                          170
+#define TK_FUNCTION                       171
+#define TK_UMINUS                         172
+#define TK_UPLUS                          173
+#define TK_TRUTH                          174
+#define TK_REGISTER                       175
+#define TK_VECTOR                         176
+#define TK_SELECT_COLUMN                  177
+#define TK_IF_NULL_ROW                    178
+#define TK_ASTERISK                       179
+#define TK_SPAN                           180
+#define TK_ERROR                          181
+#define TK_SPACE                          182
+#define TK_ILLEGAL                        183
 #endif
 /**************** End token definitions ***************************************/
 
@@ -155285,28 +159903,30 @@ static void updateDeleteLimitError(
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 310
+#define YYNOCODE 318
 #define YYACTIONTYPE unsigned short int
-#define YYWILDCARD 100
+#define YYWILDCARD 101
 #define sqlite3ParserTOKENTYPE Token
 typedef union {
   int yyinit;
   sqlite3ParserTOKENTYPE yy0;
-  SrcList* yy47;
-  u8 yy58;
-  struct FrameBound yy77;
-  With* yy131;
-  int yy192;
-  Expr* yy202;
-  struct {int value; int mask;} yy207;
-  struct TrigEvent yy230;
-  ExprList* yy242;
-  Window* yy303;
-  Upsert* yy318;
-  const char* yy436;
-  TriggerStep* yy447;
-  Select* yy539;
-  IdList* yy600;
+  With* yy43;
+  u32 yy51;
+  int yy64;
+  struct FrameBound yy81;
+  struct {int value; int mask;} yy83;
+  TriggerStep* yy95;
+  Upsert* yy138;
+  IdList* yy240;
+  Cte* yy255;
+  Select* yy303;
+  Window* yy375;
+  u8 yy534;
+  ExprList* yy562;
+  struct TrigEvent yy570;
+  const char* yy600;
+  SrcList* yy607;
+  Expr* yy626;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -155322,18 +159942,18 @@ typedef union {
 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
 #define YYFALLBACK 1
-#define YYNSTATE             553
-#define YYNRULE              385
-#define YYNRULE_WITH_ACTION  325
-#define YYNTOKEN             181
-#define YY_MAX_SHIFT         552
-#define YY_MIN_SHIFTREDUCE   803
-#define YY_MAX_SHIFTREDUCE   1187
-#define YY_ERROR_ACTION      1188
-#define YY_ACCEPT_ACTION     1189
-#define YY_NO_ACTION         1190
-#define YY_MIN_REDUCE        1191
-#define YY_MAX_REDUCE        1575
+#define YYNSTATE             572
+#define YYNRULE              401
+#define YYNRULE_WITH_ACTION  339
+#define YYNTOKEN             184
+#define YY_MAX_SHIFT         571
+#define YY_MIN_SHIFTREDUCE   829
+#define YY_MAX_SHIFTREDUCE   1229
+#define YY_ERROR_ACTION      1230
+#define YY_ACCEPT_ACTION     1231
+#define YY_NO_ACTION         1232
+#define YY_MIN_REDUCE        1233
+#define YY_MAX_REDUCE        1633
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -155400,586 +160020,606 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (1962)
+#define YY_ACTTAB_COUNT (2037)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   546, 1222,  546,  451, 1260,  546, 1239,  546,  114,  111,
- /*    10 */   211,  546, 1537,  546, 1260,  523,  114,  111,  211,  392,
- /*    20 */  1232,  344,   42,   42,   42,   42, 1225,   42,   42,   71,
- /*    30 */    71,  937, 1224,   71,   71,   71,   71, 1462, 1493,  938,
- /*    40 */   820,  453,    6,  121,  122,  112, 1165, 1165, 1006, 1009,
- /*    50 */   999,  999,  119,  119,  120,  120,  120,  120, 1543,  392,
- /*    60 */  1358, 1517,  552,    2, 1193,  194,  528,  436,  143,  291,
- /*    70 */   528,  136,  528,  371,  261,  504,  272,  385, 1273,  527,
- /*    80 */   503,  493,  164,  121,  122,  112, 1165, 1165, 1006, 1009,
- /*    90 */   999,  999,  119,  119,  120,  120,  120,  120, 1358,  442,
- /*   100 */  1514,  118,  118,  118,  118,  117,  117,  116,  116,  116,
- /*   110 */   115,  424,  266,  266,  266,  266, 1498,  358, 1500,  435,
- /*   120 */   357, 1498,  517,  524, 1485,  543, 1114,  543, 1114,  392,
- /*   130 */   405,  241,  208,  114,  111,  211,   98,  290,  537,  221,
- /*   140 */  1029,  118,  118,  118,  118,  117,  117,  116,  116,  116,
- /*   150 */   115,  424, 1142,  121,  122,  112, 1165, 1165, 1006, 1009,
- /*   160 */   999,  999,  119,  119,  120,  120,  120,  120,  406,  428,
- /*   170 */   117,  117,  116,  116,  116,  115,  424, 1418,  468,  123,
- /*   180 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
- /*   190 */   424,  116,  116,  116,  115,  424,  540,  540,  540,  392,
- /*   200 */   505,  120,  120,  120,  120,  113, 1051, 1142, 1143, 1144,
- /*   210 */  1051,  118,  118,  118,  118,  117,  117,  116,  116,  116,
- /*   220 */   115,  424, 1461,  121,  122,  112, 1165, 1165, 1006, 1009,
- /*   230 */   999,  999,  119,  119,  120,  120,  120,  120,  392,  444,
- /*   240 */   316,   83,  463,   81,  359,  382, 1142,   80,  118,  118,
- /*   250 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  179,
- /*   260 */   434,  424,  121,  122,  112, 1165, 1165, 1006, 1009,  999,
- /*   270 */   999,  119,  119,  120,  120,  120,  120,  434,  433,  266,
- /*   280 */   266,  118,  118,  118,  118,  117,  117,  116,  116,  116,
- /*   290 */   115,  424,  543, 1109,  903,  506, 1142,  114,  111,  211,
- /*   300 */  1431, 1142, 1143, 1144,  206,  491, 1109,  392,  449, 1109,
- /*   310 */   545,  330,  120,  120,  120,  120,  298, 1431, 1433,   17,
- /*   320 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
- /*   330 */   424,  121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,
- /*   340 */   119,  119,  120,  120,  120,  120,  392, 1358,  434, 1142,
- /*   350 */   482, 1142, 1143, 1144,  996,  996, 1007, 1010,  445,  118,
- /*   360 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  424,
- /*   370 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
- /*   380 */   119,  120,  120,  120,  120, 1054, 1054,  465, 1431,  118,
- /*   390 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  424,
- /*   400 */  1142,  451,  546, 1426, 1142, 1143, 1144,  233,  966, 1142,
- /*   410 */   481,  478,  477,  171,  360,  392,  164,  407,  414,  842,
- /*   420 */   476,  164,  185,  334,   71,   71, 1243, 1000,  118,  118,
- /*   430 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  121,
- /*   440 */   122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,  119,
- /*   450 */   120,  120,  120,  120,  392, 1142, 1143, 1144,  835,   12,
- /*   460 */   314,  509,  163,  356, 1142, 1143, 1144,  114,  111,  211,
- /*   470 */   508,  290,  537,  546,  276,  180,  290,  537,  121,  122,
- /*   480 */   112, 1165, 1165, 1006, 1009,  999,  999,  119,  119,  120,
- /*   490 */   120,  120,  120,  345,  484,   71,   71,  118,  118,  118,
- /*   500 */   118,  117,  117,  116,  116,  116,  115,  424, 1142,  209,
- /*   510 */   411,  523, 1142, 1109, 1571,  378,  252,  269,  342,  487,
- /*   520 */   337,  486,  238,  392,  513,  364, 1109, 1127,  333, 1109,
- /*   530 */   191,  409,  286,   32,  457,  443,  118,  118,  118,  118,
- /*   540 */   117,  117,  116,  116,  116,  115,  424,  121,  122,  112,
- /*   550 */  1165, 1165, 1006, 1009,  999,  999,  119,  119,  120,  120,
- /*   560 */   120,  120,  392, 1142, 1143, 1144,  987, 1142, 1143, 1144,
- /*   570 */  1142,  233,  492, 1492,  481,  478,  477,    6,  163,  546,
- /*   580 */   512,  546,  115,  424,  476,    5,  121,  122,  112, 1165,
- /*   590 */  1165, 1006, 1009,  999,  999,  119,  119,  120,  120,  120,
- /*   600 */   120,   13,   13,   13,   13,  118,  118,  118,  118,  117,
- /*   610 */   117,  116,  116,  116,  115,  424,  403,  502,  408,  546,
- /*   620 */  1486,  544, 1142,  892,  892, 1142, 1143, 1144, 1473, 1142,
- /*   630 */   275,  392,  808,  809,  810,  971,  422,  422,  422,   16,
- /*   640 */    16,   55,   55, 1242,  118,  118,  118,  118,  117,  117,
- /*   650 */   116,  116,  116,  115,  424,  121,  122,  112, 1165, 1165,
- /*   660 */  1006, 1009,  999,  999,  119,  119,  120,  120,  120,  120,
- /*   670 */   392, 1189,    1,    1,  552,    2, 1193, 1142, 1143, 1144,
- /*   680 */   194,  291,  898,  136, 1142, 1143, 1144,  897,  521, 1492,
- /*   690 */  1273,    3,  380,    6,  121,  122,  112, 1165, 1165, 1006,
- /*   700 */  1009,  999,  999,  119,  119,  120,  120,  120,  120,  858,
- /*   710 */   546,  924,  546,  118,  118,  118,  118,  117,  117,  116,
- /*   720 */   116,  116,  115,  424,  266,  266, 1092, 1569, 1142,  551,
- /*   730 */  1569, 1193,   13,   13,   13,   13,  291,  543,  136,  392,
- /*   740 */   485,  421,  420,  966,  344, 1273,  468,  410,  859,  279,
- /*   750 */   140,  221,  118,  118,  118,  118,  117,  117,  116,  116,
- /*   760 */   116,  115,  424,  121,  122,  112, 1165, 1165, 1006, 1009,
- /*   770 */   999,  999,  119,  119,  120,  120,  120,  120,  546,  266,
- /*   780 */   266,  428,  392, 1142, 1143, 1144, 1172,  830, 1172,  468,
- /*   790 */   431,  145,  543, 1146,  401,  314,  439,  302,  838, 1490,
- /*   800 */    71,   71,  412,    6, 1090,  473,  221,  100,  112, 1165,
- /*   810 */  1165, 1006, 1009,  999,  999,  119,  119,  120,  120,  120,
- /*   820 */   120,  118,  118,  118,  118,  117,  117,  116,  116,  116,
- /*   830 */   115,  424,  237, 1425,  546,  451,  428,  287,  986,  546,
- /*   840 */   236,  235,  234,  830,   97,  529,  429, 1265, 1265, 1146,
- /*   850 */   494,  307,  430,  838,  977,  546,   71,   71,  976, 1241,
- /*   860 */   546,   51,   51,  300,  118,  118,  118,  118,  117,  117,
- /*   870 */   116,  116,  116,  115,  424,  194,  103,   70,   70,  266,
- /*   880 */   266,  546,   71,   71,  266,  266,   30,  391,  344,  976,
- /*   890 */   976,  978,  543,  528, 1109,  328,  392,  543,  495,  397,
- /*   900 */  1470,  195,  530,   13,   13, 1358,  240, 1109,  277,  280,
- /*   910 */  1109,  280,  304,  457,  306,  333,  392,   31,  188,  419,
- /*   920 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
- /*   930 */   119,  120,  120,  120,  120,  142,  392,  365,  457,  986,
- /*   940 */   121,  122,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
- /*   950 */   119,  120,  120,  120,  120,  977,  323, 1142,  326,  976,
- /*   960 */   121,  110,  112, 1165, 1165, 1006, 1009,  999,  999,  119,
- /*   970 */   119,  120,  120,  120,  120,  464,  377, 1185,  118,  118,
- /*   980 */   118,  118,  117,  117,  116,  116,  116,  115,  424, 1142,
- /*   990 */   976,  976,  978,  305,    9,  366,  244,  362,  118,  118,
- /*  1000 */   118,  118,  117,  117,  116,  116,  116,  115,  424,  313,
- /*  1010 */   546,  344, 1142, 1143, 1144,  299,  290,  537,  118,  118,
- /*  1020 */   118,  118,  117,  117,  116,  116,  116,  115,  424, 1263,
- /*  1030 */  1263, 1163,   13,   13,  278,  421,  420,  468,  392,  923,
- /*  1040 */   260,  260,  289, 1169, 1142, 1143, 1144,  189, 1171,  266,
- /*  1050 */   266,  468,  390,  543, 1186,  546, 1170,  263,  144,  489,
- /*  1060 */   922,  546,  543,  122,  112, 1165, 1165, 1006, 1009,  999,
- /*  1070 */   999,  119,  119,  120,  120,  120,  120,   71,   71, 1142,
- /*  1080 */  1172, 1272, 1172,   13,   13,  898, 1070, 1163,  546,  468,
- /*  1090 */   897,  107,  538, 1491,    4, 1268, 1109,    6,  525, 1049,
- /*  1100 */    12, 1071, 1092, 1570,  312,  455, 1570,  520,  541, 1109,
- /*  1110 */    56,   56, 1109, 1489,  423, 1358, 1072,    6,  345,  285,
- /*  1120 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
- /*  1130 */   424,  425, 1271,  321, 1142, 1143, 1144,  878,  266,  266,
- /*  1140 */  1277,  107,  538,  535,    4, 1488,  293,  879, 1211,    6,
- /*  1150 */   210,  543,  543,  164,  294,  496,  416,  204,  541,  267,
- /*  1160 */   267, 1214,  398,  511,  499,  204,  266,  266,  396,  531,
- /*  1170 */     8,  986,  543,  519,  546,  922,  458,  105,  105,  543,
- /*  1180 */  1090,  425,  266,  266,  106,  417,  425,  548,  547,  266,
- /*  1190 */   266,  976,  518,  535, 1373,  543,   15,   15,  266,  266,
- /*  1200 */   456, 1120,  543,  266,  266, 1070, 1372,  515,  290,  537,
- /*  1210 */   546,  543,  514,   97,  444,  316,  543,  546,  922,  125,
- /*  1220 */  1071,  986,  976,  976,  978,  979,   27,  105,  105,  401,
- /*  1230 */   343, 1511,   44,   44,  106, 1072,  425,  548,  547,   57,
- /*  1240 */    57,  976,  343, 1511,  107,  538,  546,    4,  462,  401,
- /*  1250 */   214, 1120,  459,  297,  377, 1091,  534, 1309,  546,  539,
- /*  1260 */   398,  541,  290,  537,  104,  244,  102,  526,   58,   58,
- /*  1270 */   546,  199,  976,  976,  978,  979,   27, 1516, 1131,  427,
- /*  1280 */    59,   59,  270,  237,  425,  138,   95,  375,  375,  374,
- /*  1290 */   255,  372,   60,   60,  817, 1180,  535,  546,  273,  546,
- /*  1300 */  1163, 1308,  389,  388,  546,  438,  546,  215,  210,  296,
- /*  1310 */   515,  849,  546,  265,  208,  516, 1476,  295,  274,   61,
- /*  1320 */    61,   62,   62,  308,  986,  109,   45,   45,   46,   46,
- /*  1330 */   105,  105, 1186,  922,   47,   47,  341,  106,  546,  425,
- /*  1340 */   548,  547, 1542,  546,  976,  867,  340,  217,  546,  937,
- /*  1350 */   397,  107,  538,  218,    4,  156, 1163,  938,  158,  546,
- /*  1360 */    49,   49, 1162,  546,  268,   50,   50,  546,  541, 1450,
- /*  1370 */    63,   63,  546, 1449,  216,  976,  976,  978,  979,   27,
- /*  1380 */   446,   64,   64,  546,  460,   65,   65,  546,  318,   14,
- /*  1390 */    14,  425, 1305,  546,   66,   66, 1087,  546,  141,  379,
- /*  1400 */    38,  546,  963,  535,  322,  127,  127,  546,  393,   67,
- /*  1410 */    67,  546,  325,  290,  537,   52,   52,  515,  546,   68,
- /*  1420 */    68,  845,  514,   69,   69,  399,  165,  857,  856,   53,
- /*  1430 */    53,  986,  311,  151,  151,   97,  432,  105,  105,  327,
- /*  1440 */   152,  152,  526, 1048,  106, 1048,  425,  548,  547, 1131,
- /*  1450 */   427,  976, 1032,  270,  968,  239,  329,  243,  375,  375,
- /*  1460 */   374,  255,  372,  940,  941,  817, 1296,  546,  220,  546,
- /*  1470 */   107,  538,  546,    4,  546, 1256,  199,  845,  215, 1036,
- /*  1480 */   296, 1530,  976,  976,  978,  979,   27,  541,  295,   76,
- /*  1490 */    76,   54,   54,  980,   72,   72,  128,  128,  864,  865,
- /*  1500 */   107,  538,  546,    4, 1047,  546, 1047,  533,  469,  546,
- /*  1510 */   425,  546,  450, 1240,  546,  243,  546,  541,  217,  546,
- /*  1520 */   452,  197,  535,  243,   73,   73,  156,  129,  129,  158,
- /*  1530 */   336,  130,  130,  126,  126, 1036,  150,  150,  149,  149,
- /*  1540 */   425,  134,  134,  317,  474,  216,   97,  239,  331,  980,
- /*  1550 */   986,   97,  535,  346,  347,  546,  105,  105,  902,  931,
- /*  1560 */   546,  895,  243,  106,  109,  425,  548,  547,  546, 1505,
- /*  1570 */   976,  828,   99,  538,  139,    4,  546,  133,  133,  393,
- /*  1580 */   986, 1317,  131,  131,  290,  537,  105,  105, 1357,  541,
- /*  1590 */   132,  132, 1292,  106, 1303,  425,  548,  547,   75,   75,
- /*  1600 */   976,  976,  976,  978,  979,   27,  546,  432,  896, 1289,
- /*  1610 */   532,  109,  425, 1363,  546, 1221, 1213, 1202,  258,  546,
- /*  1620 */   349,  546, 1201,   11,  535, 1203, 1524,  351,   77,   77,
- /*  1630 */   376,  976,  976,  978,  979,   27,   74,   74,  353,  213,
- /*  1640 */   301,   43,   43,   48,   48,  437,  310,  201,  303, 1350,
- /*  1650 */   315,  355,  986,  454,  479, 1239,  339,  192,  105,  105,
- /*  1660 */  1422, 1421,  193,  536,  205,  106, 1527,  425,  548,  547,
- /*  1670 */  1180,  167,  976,  270,  247, 1469, 1467, 1177,  375,  375,
- /*  1680 */   374,  255,  372,  200,  369,  817,  400,   83,   79,   82,
- /*  1690 */  1427,  448,  177,   95, 1342,  161,  169, 1339,  215,  440,
- /*  1700 */   296,  172,  173,  976,  976,  978,  979,   27,  295,  174,
- /*  1710 */   175,  441,  472,  223, 1347,  383,   35,  381,   36,  461,
- /*  1720 */    88, 1353,  181,  447,  384, 1416,  227,  467,  259,  229,
- /*  1730 */   186,  488,  470,  324, 1250,  230,  231,  320,  217, 1204,
- /*  1740 */  1438, 1259,  386, 1258,  413,   90,  156,  849, 1541,  158,
- /*  1750 */   206,  415, 1540,  507, 1300, 1257,   94,  348, 1229, 1301,
- /*  1760 */   387, 1510, 1228,  338, 1227,  216,  350, 1539,  498,  283,
- /*  1770 */   284, 1249,  501, 1299,  352,  245,  246,  418, 1298,  354,
- /*  1780 */  1496, 1495,  124,   10,  526,  363,  101, 1324,  253,   96,
- /*  1790 */   510, 1210,   34,  549, 1137,  254,  256,  257,  166,  393,
- /*  1800 */   550, 1199, 1282,  361,  290,  537, 1281,  196,  367,  368,
- /*  1810 */  1194,  153, 1454,  137,  281, 1323, 1455,  804,  154,  426,
- /*  1820 */   198,  155, 1453, 1452,  292,  212,  202,  432, 1402,  203,
- /*  1830 */   271,  135,  288,   78, 1046, 1044,  960,  168,  157,  881,
- /*  1840 */   170,  219,  309,  222, 1060,  176,  964,  159,  402,   84,
- /*  1850 */   178,  404,   85,   86,   87,  160, 1063,  224,  394,  395,
- /*  1860 */   225, 1059,  146,   18,  226,  319,  243, 1174,  466,  228,
- /*  1870 */  1052,  182,  183,   37,  819,  471,  340,  232,  332,  483,
- /*  1880 */   184,   89,  162,   19,   20,  475,   91,  480,  847,  335,
- /*  1890 */   147,  860,  282,   92,  490,   93, 1125,  148, 1012, 1095,
- /*  1900 */    39,  497, 1096,   40,  500,  262,  207,  264,  930,  187,
- /*  1910 */   925,  109, 1111, 1115, 1113,    7, 1099,  242,   33, 1119,
- /*  1920 */    21,  522,   22,   23,   24, 1118,   25,  190,   97,   26,
- /*  1930 */  1027, 1013, 1011, 1015, 1069, 1016, 1068,  249,  248,   28,
- /*  1940 */    41,  891,  981,  829,  108,   29,  250,  542,  251,  370,
- /*  1950 */   373, 1133, 1132, 1190, 1190, 1190, 1190, 1190, 1190, 1190,
- /*  1960 */  1532, 1531,
+ /*     0 */   564,  115,  112,  220,  169,  199,  115,  112,  220,  564,
+ /*    10 */   375, 1266,  564,  376,  564,  270, 1309, 1309,  406,  407,
+ /*    20 */  1084,  199, 1513,   41,   41,  515,  489,  521,  558,  558,
+ /*    30 */   558,  965,   41,   41,  395,   41,   41,   51,   51,  966,
+ /*    40 */   296, 1269,  296,  122,  123,  113, 1207, 1207, 1041, 1044,
+ /*    50 */  1034, 1034,  120,  120,  121,  121,  121,  121,  564,  407,
+ /*    60 */   275,  275,  275,  275, 1268,  115,  112,  220,  115,  112,
+ /*    70 */   220, 1512,  846,  561,  516,  561,  115,  112,  220,  250,
+ /*    80 */   217,   71,   71,  122,  123,  113, 1207, 1207, 1041, 1044,
+ /*    90 */  1034, 1034,  120,  120,  121,  121,  121,  121,  440,  440,
+ /*   100 */   440, 1149,  119,  119,  119,  119,  118,  118,  117,  117,
+ /*   110 */   117,  116,  442, 1183, 1149,  116,  442, 1149,  546,  513,
+ /*   120 */  1548, 1554,  374,  442,    6, 1183, 1154,  522, 1154,  407,
+ /*   130 */  1556,  461,  373, 1554,  535,   99,  463,  332,  121,  121,
+ /*   140 */   121,  121,  119,  119,  119,  119,  118,  118,  117,  117,
+ /*   150 */   117,  116,  442,  122,  123,  113, 1207, 1207, 1041, 1044,
+ /*   160 */  1034, 1034,  120,  120,  121,  121,  121,  121, 1257, 1183,
+ /*   170 */  1184, 1185,  243, 1064,  564,  502,  499,  498,  567,  124,
+ /*   180 */   567, 1183, 1184, 1185,  474,  497,  119,  119,  119,  119,
+ /*   190 */   118,  118,  117,  117,  117,  116,  442,   70,   70,  407,
+ /*   200 */   121,  121,  121,  121,  114,  117,  117,  117,  116,  442,
+ /*   210 */  1409, 1469,  119,  119,  119,  119,  118,  118,  117,  117,
+ /*   220 */   117,  116,  442,  122,  123,  113, 1207, 1207, 1041, 1044,
+ /*   230 */  1034, 1034,  120,  120,  121,  121,  121,  121,  407, 1031,
+ /*   240 */  1031, 1042, 1045,   81,  382,  541,  378,   80,  119,  119,
+ /*   250 */   119,  119,  118,  118,  117,  117,  117,  116,  442,  381,
+ /*   260 */   463,  332,  122,  123,  113, 1207, 1207, 1041, 1044, 1034,
+ /*   270 */  1034,  120,  120,  121,  121,  121,  121,  262,  215,  512,
+ /*   280 */  1424,  422,  119,  119,  119,  119,  118,  118,  117,  117,
+ /*   290 */   117,  116,  442, 1231,    1,    1,  571,    2, 1235, 1573,
+ /*   300 */   571,    2, 1235,  307, 1149,  141, 1600,  307,  407,  141,
+ /*   310 */  1183,  361, 1317, 1035,  866,  531, 1317, 1149,  359, 1567,
+ /*   320 */  1149,  119,  119,  119,  119,  118,  118,  117,  117,  117,
+ /*   330 */   116,  442,  122,  123,  113, 1207, 1207, 1041, 1044, 1034,
+ /*   340 */  1034,  120,  120,  121,  121,  121,  121,  275,  275, 1001,
+ /*   350 */   426,  275,  275, 1128, 1627, 1021, 1627,  137,  542, 1541,
+ /*   360 */   561,  272,  950,  950,  561, 1423, 1183, 1184, 1185, 1594,
+ /*   370 */   866, 1012,  530,  315,  231, 1011,  468, 1276,  231,  119,
+ /*   380 */   119,  119,  119,  118,  118,  117,  117,  117,  116,  442,
+ /*   390 */  1570,  119,  119,  119,  119,  118,  118,  117,  117,  117,
+ /*   400 */   116,  442,  330,  359, 1567,  564,  446, 1011, 1011, 1013,
+ /*   410 */   446,  207,  564,  306,  555,  407,  363, 1021,  363,  346,
+ /*   420 */   184,  118,  118,  117,  117,  117,  116,  442,   71,   71,
+ /*   430 */   439,  438, 1126, 1012,  472,   71,   71, 1011,  205,  122,
+ /*   440 */   123,  113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,
+ /*   450 */   121,  121,  121,  121,  219,  219,  472, 1183,  407,  570,
+ /*   460 */  1183, 1235,  503, 1477,  149,  546,  307,  489,  141, 1011,
+ /*   470 */  1011, 1013,  546,  140,  545, 1317, 1214,  191, 1214,  950,
+ /*   480 */   950,  514,  122,  123,  113, 1207, 1207, 1041, 1044, 1034,
+ /*   490 */  1034,  120,  120,  121,  121,  121,  121,  563,  119,  119,
+ /*   500 */   119,  119,  118,  118,  117,  117,  117,  116,  442,  283,
+ /*   510 */   275,  275,  415, 1183, 1184, 1185, 1183, 1184, 1185,  372,
+ /*   520 */  1183,  243,  344,  561,  502,  499,  498, 1539,  407, 1540,
+ /*   530 */  1183,  288,  870,  143,  497, 1549,  185,  231,    9,    6,
+ /*   540 */   253,  119,  119,  119,  119,  118,  118,  117,  117,  117,
+ /*   550 */   116,  442,  122,  123,  113, 1207, 1207, 1041, 1044, 1034,
+ /*   560 */  1034,  120,  120,  121,  121,  121,  121,  407,  137,  446,
+ /*   570 */   447,  863,  169, 1183,  397, 1204, 1183, 1184, 1185,  931,
+ /*   580 */   526, 1001,   98,  339,  564,  342, 1183, 1184, 1185,  306,
+ /*   590 */   555,  122,  123,  113, 1207, 1207, 1041, 1044, 1034, 1034,
+ /*   600 */   120,  120,  121,  121,  121,  121,  452,   71,   71,  275,
+ /*   610 */   275,  119,  119,  119,  119,  118,  118,  117,  117,  117,
+ /*   620 */   116,  442,  561,  417,  306,  555, 1183, 1307, 1307, 1183,
+ /*   630 */  1184, 1185, 1204, 1149,  330,  458,  318,  407,  363,  470,
+ /*   640 */   431, 1167,   32,  541,  527,  350, 1149, 1629,  393, 1149,
+ /*   650 */   119,  119,  119,  119,  118,  118,  117,  117,  117,  116,
+ /*   660 */   442,  122,  123,  113, 1207, 1207, 1041, 1044, 1034, 1034,
+ /*   670 */   120,  120,  121,  121,  121,  121,  407,  199,  472, 1183,
+ /*   680 */  1022,  472, 1183, 1184, 1185,  386,  151,  539, 1548,  277,
+ /*   690 */   400,  137,    6,  317,    5,  564,  562,    3,  920,  920,
+ /*   700 */   122,  123,  113, 1207, 1207, 1041, 1044, 1034, 1034,  120,
+ /*   710 */   120,  121,  121,  121,  121,  411,  505,   83,   71,   71,
+ /*   720 */   119,  119,  119,  119,  118,  118,  117,  117,  117,  116,
+ /*   730 */   442, 1183,  218,  428, 1183, 1183, 1184, 1185,  363,  261,
+ /*   740 */   278,  358,  508,  353,  507,  248,  407,  306,  555, 1539,
+ /*   750 */  1006,  349,  363,  291,  489,  302,  293, 1542,  281,  119,
+ /*   760 */   119,  119,  119,  118,  118,  117,  117,  117,  116,  442,
+ /*   770 */   122,  123,  113, 1207, 1207, 1041, 1044, 1034, 1034,  120,
+ /*   780 */   120,  121,  121,  121,  121,  407,  148, 1183, 1184, 1185,
+ /*   790 */  1183, 1184, 1185,  275,  275, 1304, 1257, 1283,  483, 1476,
+ /*   800 */   150,  489,  480,  564, 1187, 1304,  561, 1587, 1255,  122,
+ /*   810 */   123,  113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,
+ /*   820 */   121,  121,  121,  121,  564,  886,   13,   13,  520,  119,
+ /*   830 */   119,  119,  119,  118,  118,  117,  117,  117,  116,  442,
+ /*   840 */  1183,  420,  417,  564,  269,  269, 1316,   13,   13, 1539,
+ /*   850 */  1546,   16,   16,  322,    6,  407,  506,  561, 1089, 1089,
+ /*   860 */   486, 1187,  425, 1539,  887,  292,   71,   71,  119,  119,
+ /*   870 */   119,  119,  118,  118,  117,  117,  117,  116,  442,  122,
+ /*   880 */   123,  113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,
+ /*   890 */   121,  121,  121,  121,  564,   12, 1183, 1184, 1185,  407,
+ /*   900 */   275,  275,  451,  303,  834,  835,  836,  417,  489,  276,
+ /*   910 */   276, 1547,  284,  561,  319,    6,  321,   71,   71,  429,
+ /*   920 */   451,  450,  561,  952,  101,  113, 1207, 1207, 1041, 1044,
+ /*   930 */  1034, 1034,  120,  120,  121,  121,  121,  121,  119,  119,
+ /*   940 */   119,  119,  118,  118,  117,  117,  117,  116,  442, 1105,
+ /*   950 */  1183,  489,  564, 1312,  437,  455,  478,  564,  246,  245,
+ /*   960 */   244, 1409, 1545,  547, 1106,  405,    6, 1544,  196, 1258,
+ /*   970 */   413,    6,  105,  462,  103,   71,   71,  286,  564, 1107,
+ /*   980 */    13,   13,  119,  119,  119,  119,  118,  118,  117,  117,
+ /*   990 */   117,  116,  442,  451,  104,  427,  337,  320,  275,  275,
+ /*  1000 */   906,   13,   13,  564, 1482, 1105, 1183, 1184, 1185,  126,
+ /*  1010 */   907,  561,  546,  564,  407,  478,  295, 1321,  253,  200,
+ /*  1020 */  1106,  548, 1482, 1484,  280, 1409,   55,   55, 1287,  561,
+ /*  1030 */   478,  380,  423,  951,  407, 1107,   71,   71,  122,  123,
+ /*  1040 */   113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,  121,
+ /*  1050 */   121,  121,  121, 1204,  407,  287,  552,  309,  122,  123,
+ /*  1060 */   113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,  121,
+ /*  1070 */   121,  121,  121,  441, 1128, 1628,  146, 1628,  122,  111,
+ /*  1080 */   113, 1207, 1207, 1041, 1044, 1034, 1034,  120,  120,  121,
+ /*  1090 */   121,  121,  121,  404,  403, 1482,  424,  119,  119,  119,
+ /*  1100 */   119,  118,  118,  117,  117,  117,  116,  442, 1183,  564,
+ /*  1110 */  1204,  544, 1086,  858,  329,  361, 1086,  119,  119,  119,
+ /*  1120 */   119,  118,  118,  117,  117,  117,  116,  442,  564,  294,
+ /*  1130 */   144,  523,   56,   56,  224,  564,  510,  119,  119,  119,
+ /*  1140 */   119,  118,  118,  117,  117,  117,  116,  442,  484, 1409,
+ /*  1150 */   537,   15,   15, 1126,  434,  439,  438,  407,   13,   13,
+ /*  1160 */  1523,   12,  926, 1211, 1183, 1184, 1185,  925, 1213,  536,
+ /*  1170 */   858,  557,  413,  193, 1525,  494, 1212,  448, 1160, 1222,
+ /*  1180 */  1183,  564,  123,  113, 1207, 1207, 1041, 1044, 1034, 1034,
+ /*  1190 */   120,  120,  121,  121,  121,  121, 1521, 1149,  564,  965,
+ /*  1200 */   564, 1214,  247, 1214,   13,   13, 1409,  966,  538,  564,
+ /*  1210 */  1149,  108,  556, 1149,    4,  310,  392, 1227,   17,  194,
+ /*  1220 */   485,   43,   43,   57,   57,  306,  555,  524,  559, 1160,
+ /*  1230 */   464,  564,   44,   44,  392, 1127, 1183, 1184, 1185,  479,
+ /*  1240 */   119,  119,  119,  119,  118,  118,  117,  117,  117,  116,
+ /*  1250 */   442,  443,  564,  327,   13,   13,  564,  418, 1315,  414,
+ /*  1260 */   171,  564,  311,  553,  213,  529, 1253,  564,  517,  543,
+ /*  1270 */   412,  108,  556,  137,    4,   58,   58,  435,  314,   59,
+ /*  1280 */    59,  274,  217,  549,   60,   60,  349,  476,  559, 1353,
+ /*  1290 */    61,   61, 1021,  275,  275, 1228,  213,  564,  106,  106,
+ /*  1300 */     8,  275,  275,  275,  275,  107,  561,  443,  566,  565,
+ /*  1310 */   564,  443, 1011, 1228,  561,  564,  561,  564,  275,  275,
+ /*  1320 */    62,   62, 1352,  553,  247,  456,  564,   98,  110,  306,
+ /*  1330 */   555,  561,  564,   45,   45,  405, 1203,  533,   46,   46,
+ /*  1340 */    47,   47,  532,  465, 1011, 1011, 1013, 1014,   27,   49,
+ /*  1350 */    49,  564, 1021,  405,  469,   50,   50,  564,  106,  106,
+ /*  1360 */   305,  564,   84,  204,  405,  107,  564,  443,  566,  565,
+ /*  1370 */   405,  564, 1011,  564,   63,   63,  564, 1599,  564,  895,
+ /*  1380 */    64,   64,  457,  477,   65,   65,  147,   96,   38,   14,
+ /*  1390 */    14, 1528,  412,  564,   66,   66,  128,  128,  926,   67,
+ /*  1400 */    67,   52,   52,  925, 1011, 1011, 1013, 1014,   27, 1572,
+ /*  1410 */  1171,  445,  208, 1123,  279,  394,   68,   68,  228,  390,
+ /*  1420 */   390,  389,  264,  387, 1171,  445,  843,  877,  279,  108,
+ /*  1430 */   556,  453,    4,  390,  390,  389,  264,  387,  564,  225,
+ /*  1440 */   843,  313,  328, 1003,   98,  252,  559,  544,  471,  312,
+ /*  1450 */   252,  564,  208,  225,  564,  313,  473,   30,  252,  279,
+ /*  1460 */   466,   69,   69,  312,  390,  390,  389,  264,  387,  443,
+ /*  1470 */   333,  843,   98,  564,   53,   53,  323,  157,  157,  227,
+ /*  1480 */   495,  553,  249,  289,  225,  564,  313,  162,   31, 1501,
+ /*  1490 */   135,  564, 1500,  227,  312,  533,  158,  158,  885,  884,
+ /*  1500 */   534,  162,  873,  301,  135,  564,  481,  226,   76,   76,
+ /*  1510 */  1021,  347, 1071,   98,   54,   54,  106,  106, 1067,  564,
+ /*  1520 */   249,  226,  519,  107,  227,  443,  566,  565,   72,   72,
+ /*  1530 */  1011,  334,  162,  564,  230,  135,  108,  556,  959,    4,
+ /*  1540 */   252,  408,  129,  129,  564, 1349,  306,  555,  564,  923,
+ /*  1550 */   564,  110,  226,  559,  564,  408,   73,   73,  564,  873,
+ /*  1560 */   306,  555, 1011, 1011, 1013, 1014,   27,  130,  130, 1071,
+ /*  1570 */   449,  131,  131,  127,  127,  357,  443,  156,  156,  892,
+ /*  1580 */   893,  155,  155,  338,  449,  356,  408,  564,  553,  968,
+ /*  1590 */   969,  306,  555, 1015,  341,  564,  108,  556,  564,    4,
+ /*  1600 */  1132, 1286,  533,  564,  856,  343,  145,  532,  345, 1300,
+ /*  1610 */   136,  136, 1083,  559, 1083,  449,  564, 1021,  134,  134,
+ /*  1620 */  1284,  132,  132,  106,  106, 1285,  133,  133,  564,  352,
+ /*  1630 */   107,  564,  443,  566,  565, 1340,  443, 1011,  362,   75,
+ /*  1640 */    75, 1082,  564, 1082,  564,  924, 1561,  110,  553,  551,
+ /*  1650 */  1015,   77,   77, 1361,   74,   74, 1408, 1336, 1347,  550,
+ /*  1660 */  1414, 1265, 1256, 1244, 1243,   42,   42,   48,   48, 1011,
+ /*  1670 */  1011, 1013, 1014,   27, 1245, 1580,  490, 1021,  267,  202,
+ /*  1680 */  1333,  365,   11,  106,  106,  930,  367,  210,  369,  391,
+ /*  1690 */   107, 1395,  443,  566,  565,  223, 1390, 1011,  500,  454,
+ /*  1700 */   282, 1400,  285,  108,  556,  214,    4,  325, 1383, 1283,
+ /*  1710 */   475,  355, 1473, 1583, 1472, 1399,  371, 1222,  326,  398,
+ /*  1720 */   559,  290,  331,  197,  100,  556,  209,    4,  198, 1011,
+ /*  1730 */  1011, 1013, 1014,   27,  385,  256, 1520, 1518,  554, 1219,
+ /*  1740 */   416,  559,   83,  443,  173,  206,  182,  221,  459,  167,
+ /*  1750 */   177,  460,  175,  493,  233,  553,   79,  178, 1396,  179,
+ /*  1760 */    35,  180,   96, 1402,  443,  396,   36,  467, 1478, 1401,
+ /*  1770 */   482,  237, 1404,  399,   82,  186,  553, 1467,   89,  488,
+ /*  1780 */   190,  268,  239,  491, 1021,  340,  240,  401, 1246, 1489,
+ /*  1790 */   106,  106,  336,  509, 1294,  241, 1303,  107,  430,  443,
+ /*  1800 */   566,  565, 1302,   91, 1011, 1021, 1598, 1301, 1273,  215,
+ /*  1810 */  1597,  106,  106,  402,  877,  432,  354, 1272,  107, 1271,
+ /*  1820 */   443,  566,  565, 1596, 1566, 1011, 1293,  433,  518,  299,
+ /*  1830 */   300,  360,   95,  525, 1344,  364, 1011, 1011, 1013, 1014,
+ /*  1840 */    27,  254,  255, 1552,  436, 1551,  125,  544,   10,  379,
+ /*  1850 */  1326, 1453,  102,   97, 1345,  528,  304, 1011, 1011, 1013,
+ /*  1860 */  1014,   27,  366,  377, 1343, 1342,  368,  370, 1325,  384,
+ /*  1870 */   201,  383,   34, 1368, 1367,  568, 1177,  266,  263,  265,
+ /*  1880 */  1505,  159,  569, 1241, 1236, 1506,  160,  142, 1504, 1503,
+ /*  1890 */   297,  211,  830,  161,  212,   78,  444,  203,  308,  222,
+ /*  1900 */  1081,  139, 1079,  316,  174,  163, 1203,  229,  176,  909,
+ /*  1910 */   324,  232, 1095,  181,  409,  410,  172,  164,  165,  419,
+ /*  1920 */   183,   85,   86,  421,  166,   87,   88, 1098, 1094,  234,
+ /*  1930 */   235,  152,   18,  236,  335, 1087, 1216,  252,  187,  487,
+ /*  1940 */   238,  188,   37,  845,  492,  356,  242,  496,  351,  501,
+ /*  1950 */   189,   90,   19,  504,  348,   20,  875,   92,  298,  168,
+ /*  1960 */   888,  153,   93,  511,   94, 1165,  154, 1047, 1134,   39,
+ /*  1970 */   216, 1133,  271,  273,  958,  192,  953,  110, 1151, 1155,
+ /*  1980 */   251,    7,   21, 1159, 1139,   22, 1153,   33,   23,   24,
+ /*  1990 */    25,  540, 1158,  195,   98, 1062,   26, 1048, 1046, 1050,
+ /*  2000 */  1104, 1051, 1103,  257,  258,   28,   40, 1173, 1016,  857,
+ /*  2010 */   109,   29,  560,  388,  138, 1172,  259,  170,  260, 1232,
+ /*  2020 */  1232,  919, 1232, 1232, 1232, 1232, 1232, 1232, 1232, 1232,
+ /*  2030 */  1232, 1232, 1589, 1232, 1232, 1232, 1588,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   189,  211,  189,  189,  218,  189,  220,  189,  267,  268,
- /*    10 */   269,  189,  210,  189,  228,  189,  267,  268,  269,   19,
- /*    20 */   218,  189,  211,  212,  211,  212,  211,  211,  212,  211,
- /*    30 */   212,   31,  211,  211,  212,  211,  212,  288,  300,   39,
- /*    40 */    21,  189,  304,   43,   44,   45,   46,   47,   48,   49,
- /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,  225,   19,
- /*    60 */   189,  183,  184,  185,  186,  189,  248,  263,  236,  191,
- /*    70 */   248,  193,  248,  197,  208,  257,  262,  201,  200,  257,
- /*    80 */   200,  257,   81,   43,   44,   45,   46,   47,   48,   49,
- /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,  189,   80,
- /*   100 */   189,  101,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   110 */   110,  111,  234,  235,  234,  235,  305,  306,  305,  118,
- /*   120 */   307,  305,  306,  297,  298,  247,   86,  247,   88,   19,
- /*   130 */   259,  251,  252,  267,  268,  269,   26,  136,  137,  261,
- /*   140 */   121,  101,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   150 */   110,  111,   59,   43,   44,   45,   46,   47,   48,   49,
- /*   160 */    50,   51,   52,   53,   54,   55,   56,   57,  259,  291,
- /*   170 */   105,  106,  107,  108,  109,  110,  111,  158,  189,   69,
- /*   180 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
- /*   190 */   111,  107,  108,  109,  110,  111,  205,  206,  207,   19,
- /*   200 */    19,   54,   55,   56,   57,   58,   29,  114,  115,  116,
- /*   210 */    33,  101,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   220 */   110,  111,  233,   43,   44,   45,   46,   47,   48,   49,
- /*   230 */    50,   51,   52,   53,   54,   55,   56,   57,   19,  126,
- /*   240 */   127,  148,   65,   24,  214,  200,   59,   67,  101,  102,
- /*   250 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   22,
- /*   260 */   189,  111,   43,   44,   45,   46,   47,   48,   49,   50,
- /*   270 */    51,   52,   53,   54,   55,   56,   57,  206,  207,  234,
- /*   280 */   235,  101,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   290 */   110,  111,  247,   76,  107,  114,   59,  267,  268,  269,
- /*   300 */   189,  114,  115,  116,  162,  163,   89,   19,  263,   92,
- /*   310 */   189,   23,   54,   55,   56,   57,  189,  206,  207,   22,
- /*   320 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
- /*   330 */   111,   43,   44,   45,   46,   47,   48,   49,   50,   51,
- /*   340 */    52,   53,   54,   55,   56,   57,   19,  189,  277,   59,
- /*   350 */    23,  114,  115,  116,   46,   47,   48,   49,   61,  101,
- /*   360 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   370 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
- /*   380 */    53,   54,   55,   56,   57,  125,  126,  127,  277,  101,
- /*   390 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
- /*   400 */    59,  189,  189,  276,  114,  115,  116,  117,   73,   59,
- /*   410 */   120,  121,  122,   72,  214,   19,   81,  259,   19,   23,
- /*   420 */   130,   81,   72,   24,  211,  212,  221,  119,  101,  102,
- /*   430 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   43,
+ /*     0 */   192,  273,  274,  275,  192,  192,  273,  274,  275,  192,
+ /*    10 */   218,  215,  192,  218,  192,  212,  234,  235,  205,   19,
+ /*    20 */    11,  192,  294,  215,  216,  203,  192,  203,  209,  210,
+ /*    30 */   211,   31,  215,  216,  205,  215,  216,  215,  216,   39,
+ /*    40 */   227,  215,  229,   43,   44,   45,   46,   47,   48,   49,
+ /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,  192,   19,
+ /*    60 */   238,  239,  238,  239,  215,  273,  274,  275,  273,  274,
+ /*    70 */   275,  237,   21,  251,  252,  251,  273,  274,  275,  255,
+ /*    80 */   256,  215,  216,   43,   44,   45,   46,   47,   48,   49,
+ /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,  209,  210,
+ /*   100 */   211,   76,  102,  103,  104,  105,  106,  107,  108,  109,
+ /*   110 */   110,  111,  112,   59,   89,  111,  112,   92,  252,  307,
+ /*   120 */   308,  313,  314,  112,  312,   59,   86,  261,   88,   19,
+ /*   130 */   313,   80,  315,  313,  314,   25,  127,  128,   54,   55,
+ /*   140 */    56,   57,  102,  103,  104,  105,  106,  107,  108,  109,
+ /*   150 */   110,  111,  112,   43,   44,   45,   46,   47,   48,   49,
+ /*   160 */    50,   51,   52,   53,   54,   55,   56,   57,  192,  115,
+ /*   170 */   116,  117,  118,  122,  192,  121,  122,  123,  202,   69,
+ /*   180 */   204,  115,  116,  117,  192,  131,  102,  103,  104,  105,
+ /*   190 */   106,  107,  108,  109,  110,  111,  112,  215,  216,   19,
+ /*   200 */    54,   55,   56,   57,   58,  108,  109,  110,  111,  112,
+ /*   210 */   192,  160,  102,  103,  104,  105,  106,  107,  108,  109,
+ /*   220 */   110,  111,  112,   43,   44,   45,   46,   47,   48,   49,
+ /*   230 */    50,   51,   52,   53,   54,   55,   56,   57,   19,   46,
+ /*   240 */    47,   48,   49,   24,  248,  192,  250,   67,  102,  103,
+ /*   250 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  277,
+ /*   260 */   127,  128,   43,   44,   45,   46,   47,   48,   49,   50,
+ /*   270 */    51,   52,   53,   54,   55,   56,   57,   26,  164,  165,
+ /*   280 */   272,  263,  102,  103,  104,  105,  106,  107,  108,  109,
+ /*   290 */   110,  111,  112,  184,  185,  186,  187,  188,  189,  186,
+ /*   300 */   187,  188,  189,  194,   76,  196,  229,  194,   19,  196,
+ /*   310 */    59,  192,  203,  120,   59,   87,  203,   89,  310,  311,
+ /*   320 */    92,  102,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*   330 */   111,  112,   43,   44,   45,   46,   47,   48,   49,   50,
+ /*   340 */    51,   52,   53,   54,   55,   56,   57,  238,  239,   73,
+ /*   350 */   231,  238,  239,   22,   23,  100,   25,   81,  305,  306,
+ /*   360 */   251,   23,   25,   25,  251,  272,  115,  116,  117,  214,
+ /*   370 */   115,  116,  144,  192,  265,  120,  114,  222,  265,  102,
+ /*   380 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*   390 */   192,  102,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*   400 */   111,  112,  126,  310,  311,  192,  297,  152,  153,  154,
+ /*   410 */   297,  149,  192,  137,  138,   19,  192,  100,  192,   23,
+ /*   420 */    22,  106,  107,  108,  109,  110,  111,  112,  215,  216,
+ /*   430 */   106,  107,  101,  116,  192,  215,  216,  120,  149,   43,
  /*   440 */    44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
- /*   450 */    54,   55,   56,   57,   19,  114,  115,  116,   23,  208,
- /*   460 */   125,  248,  189,  189,  114,  115,  116,  267,  268,  269,
- /*   470 */   189,  136,  137,  189,  262,   22,  136,  137,   43,   44,
- /*   480 */    45,   46,   47,   48,   49,   50,   51,   52,   53,   54,
- /*   490 */    55,   56,   57,  189,   95,  211,  212,  101,  102,  103,
- /*   500 */   104,  105,  106,  107,  108,  109,  110,  111,   59,  189,
- /*   510 */   111,  189,   59,   76,  294,  295,  117,  118,  119,  120,
- /*   520 */   121,  122,  123,   19,   87,  189,   89,   23,  129,   92,
- /*   530 */   279,  227,  248,   22,  189,  284,  101,  102,  103,  104,
- /*   540 */   105,  106,  107,  108,  109,  110,  111,   43,   44,   45,
- /*   550 */    46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
- /*   560 */    56,   57,   19,  114,  115,  116,   23,  114,  115,  116,
- /*   570 */    59,  117,  299,  300,  120,  121,  122,  304,  189,  189,
- /*   580 */   143,  189,  110,  111,  130,   22,   43,   44,   45,   46,
- /*   590 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   600 */    57,  211,  212,  211,  212,  101,  102,  103,  104,  105,
- /*   610 */   106,  107,  108,  109,  110,  111,  226,  189,  226,  189,
- /*   620 */   298,  132,   59,  134,  135,  114,  115,  116,  189,   59,
- /*   630 */   285,   19,    7,    8,    9,   23,  205,  206,  207,  211,
- /*   640 */   212,  211,  212,  221,  101,  102,  103,  104,  105,  106,
- /*   650 */   107,  108,  109,  110,  111,   43,   44,   45,   46,   47,
- /*   660 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   670 */    19,  181,  182,  183,  184,  185,  186,  114,  115,  116,
- /*   680 */   189,  191,  133,  193,  114,  115,  116,  138,  299,  300,
- /*   690 */   200,   22,  201,  304,   43,   44,   45,   46,   47,   48,
- /*   700 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   35,
- /*   710 */   189,  141,  189,  101,  102,  103,  104,  105,  106,  107,
- /*   720 */   108,  109,  110,  111,  234,  235,   22,   23,   59,  184,
- /*   730 */    26,  186,  211,  212,  211,  212,  191,  247,  193,   19,
- /*   740 */    66,  105,  106,   73,  189,  200,  189,  226,   74,  226,
- /*   750 */    22,  261,  101,  102,  103,  104,  105,  106,  107,  108,
- /*   760 */   109,  110,  111,   43,   44,   45,   46,   47,   48,   49,
- /*   770 */    50,   51,   52,   53,   54,   55,   56,   57,  189,  234,
- /*   780 */   235,  291,   19,  114,  115,  116,  150,   59,  152,  189,
- /*   790 */   233,  236,  247,   59,  189,  125,  126,  127,   59,  300,
- /*   800 */   211,  212,  128,  304,  100,   19,  261,  156,   45,   46,
- /*   810 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
- /*   820 */    57,  101,  102,  103,  104,  105,  106,  107,  108,  109,
- /*   830 */   110,  111,   46,  233,  189,  189,  291,  248,   99,  189,
- /*   840 */   125,  126,  127,  115,   26,  200,  289,  230,  231,  115,
- /*   850 */   200,   16,  189,  114,  115,  189,  211,  212,  119,  221,
- /*   860 */   189,  211,  212,  258,  101,  102,  103,  104,  105,  106,
- /*   870 */   107,  108,  109,  110,  111,  189,  156,  211,  212,  234,
- /*   880 */   235,  189,  211,  212,  234,  235,   22,  201,  189,  150,
- /*   890 */   151,  152,  247,  248,   76,   16,   19,  247,  248,  113,
- /*   900 */   189,   24,  257,  211,  212,  189,   26,   89,  262,  223,
- /*   910 */    92,  225,   77,  189,   79,  129,   19,   53,  226,  248,
- /*   920 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
- /*   930 */    53,   54,   55,   56,   57,  236,   19,  271,  189,   99,
- /*   940 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
- /*   950 */    53,   54,   55,   56,   57,  115,   77,   59,   79,  119,
- /*   960 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
- /*   970 */    53,   54,   55,   56,   57,  259,   22,   23,  101,  102,
- /*   980 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   59,
- /*   990 */   150,  151,  152,  158,   22,  244,   24,  246,  101,  102,
- /*  1000 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  285,
- /*  1010 */   189,  189,  114,  115,  116,  200,  136,  137,  101,  102,
- /*  1020 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  230,
- /*  1030 */   231,   59,  211,  212,  285,  105,  106,  189,   19,  141,
- /*  1040 */   234,  235,  239,  113,  114,  115,  116,  226,  118,  234,
- /*  1050 */   235,  189,  249,  247,  100,  189,  126,   23,  236,  107,
- /*  1060 */    26,  189,  247,   44,   45,   46,   47,   48,   49,   50,
- /*  1070 */    51,   52,   53,   54,   55,   56,   57,  211,  212,   59,
- /*  1080 */   150,  233,  152,  211,  212,  133,   12,  115,  189,  189,
- /*  1090 */   138,   19,   20,  300,   22,  233,   76,  304,  226,   11,
- /*  1100 */   208,   27,   22,   23,  200,   19,   26,   87,   36,   89,
- /*  1110 */   211,  212,   92,  300,  248,  189,   42,  304,  189,  250,
- /*  1120 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
- /*  1130 */   111,   59,  200,  233,  114,  115,  116,   63,  234,  235,
- /*  1140 */   235,   19,   20,   71,   22,  300,  189,   73,  200,  304,
- /*  1150 */   116,  247,  247,   81,  189,  200,  227,   26,   36,  234,
- /*  1160 */   235,  203,  204,  143,  200,   26,  234,  235,  194,  200,
- /*  1170 */    48,   99,  247,   66,  189,  141,  284,  105,  106,  247,
- /*  1180 */   100,   59,  234,  235,  112,  259,  114,  115,  116,  234,
- /*  1190 */   235,  119,   85,   71,  266,  247,  211,  212,  234,  235,
- /*  1200 */   114,   94,  247,  234,  235,   12,  266,   85,  136,  137,
- /*  1210 */   189,  247,   90,   26,  126,  127,  247,  189,   26,   22,
- /*  1220 */    27,   99,  150,  151,  152,  153,  154,  105,  106,  189,
- /*  1230 */   302,  303,  211,  212,  112,   42,  114,  115,  116,  211,
- /*  1240 */   212,  119,  302,  303,   19,   20,  189,   22,  274,  189,
- /*  1250 */    15,  144,  278,  189,   22,   23,   63,  189,  189,  203,
- /*  1260 */   204,   36,  136,  137,  155,   24,  157,  143,  211,  212,
- /*  1270 */   189,  140,  150,  151,  152,  153,  154,    0,    1,    2,
- /*  1280 */   211,  212,    5,   46,   59,  161,  147,   10,   11,   12,
- /*  1290 */    13,   14,  211,  212,   17,   60,   71,  189,  258,  189,
- /*  1300 */    59,  189,  105,  106,  189,  189,  189,   30,  116,   32,
- /*  1310 */    85,  124,  189,  251,  252,   90,  189,   40,  258,  211,
- /*  1320 */   212,  211,  212,  189,   99,   26,  211,  212,  211,  212,
- /*  1330 */   105,  106,  100,  141,  211,  212,  119,  112,  189,  114,
- /*  1340 */   115,  116,   23,  189,  119,   26,  129,   70,  189,   31,
- /*  1350 */   113,   19,   20,   24,   22,   78,  115,   39,   81,  189,
- /*  1360 */   211,  212,   26,  189,   22,  211,  212,  189,   36,  189,
- /*  1370 */   211,  212,  189,  189,   97,  150,  151,  152,  153,  154,
- /*  1380 */   127,  211,  212,  189,  189,  211,  212,  189,  189,  211,
- /*  1390 */   212,   59,  189,  189,  211,  212,   23,  189,   22,   26,
- /*  1400 */    24,  189,  149,   71,  189,  211,  212,  189,  131,  211,
- /*  1410 */   212,  189,  189,  136,  137,  211,  212,   85,  189,  211,
- /*  1420 */   212,   59,   90,  211,  212,  292,  293,  118,  119,  211,
- /*  1430 */   212,   99,   23,  211,  212,   26,  159,  105,  106,  189,
- /*  1440 */   211,  212,  143,  150,  112,  152,  114,  115,  116,    1,
- /*  1450 */     2,  119,   23,    5,   23,   26,  189,   26,   10,   11,
- /*  1460 */    12,   13,   14,   83,   84,   17,  253,  189,  139,  189,
- /*  1470 */    19,   20,  189,   22,  189,  189,  140,  115,   30,   59,
- /*  1480 */    32,  139,  150,  151,  152,  153,  154,   36,   40,  211,
- /*  1490 */   212,  211,  212,   59,  211,  212,  211,  212,    7,    8,
- /*  1500 */    19,   20,  189,   22,  150,  189,  152,  231,  281,  189,
- /*  1510 */    59,  189,   23,  189,  189,   26,  189,   36,   70,  189,
- /*  1520 */    23,  237,   71,   26,  211,  212,   78,  211,  212,   81,
- /*  1530 */   189,  211,  212,  211,  212,  115,  211,  212,  211,  212,
- /*  1540 */    59,  211,  212,   23,   23,   97,   26,   26,   23,  115,
- /*  1550 */    99,   26,   71,  189,  189,  189,  105,  106,  107,   23,
- /*  1560 */   189,   23,   26,  112,   26,  114,  115,  116,  189,  309,
- /*  1570 */   119,   23,   19,   20,   26,   22,  189,  211,  212,  131,
- /*  1580 */    99,  189,  211,  212,  136,  137,  105,  106,  189,   36,
- /*  1590 */   211,  212,  189,  112,  189,  114,  115,  116,  211,  212,
- /*  1600 */   119,  150,  151,  152,  153,  154,  189,  159,   23,  250,
- /*  1610 */   189,   26,   59,  189,  189,  189,  189,  189,  280,  189,
- /*  1620 */   250,  189,  189,  238,   71,  189,  189,  250,  211,  212,
- /*  1630 */   187,  150,  151,  152,  153,  154,  211,  212,  250,  290,
- /*  1640 */   240,  211,  212,  211,  212,  254,  286,  209,  254,  241,
- /*  1650 */   240,  254,   99,  286,  215,  220,  214,  244,  105,  106,
- /*  1660 */   214,  214,  244,  273,  224,  112,  192,  114,  115,  116,
- /*  1670 */    60,  290,  119,    5,  139,  196,  196,   38,   10,   11,
- /*  1680 */    12,   13,   14,  238,  240,   17,  196,  148,  287,  287,
- /*  1690 */   276,  113,   22,  147,  241,   43,  229,  241,   30,   18,
- /*  1700 */    32,  232,  232,  150,  151,  152,  153,  154,   40,  232,
- /*  1710 */   232,  196,   18,  195,  265,  265,  264,  241,  264,  196,
- /*  1720 */   155,  229,  229,  241,  241,  241,  195,   62,  196,  195,
- /*  1730 */    22,  113,  216,  196,  222,  195,  195,  282,   70,  196,
- /*  1740 */   283,  213,  216,  213,   64,   22,   78,  124,  219,   81,
- /*  1750 */   162,  111,  219,  142,  256,  213,  113,  255,  213,  256,
- /*  1760 */   216,  303,  215,  213,  213,   97,  255,  213,  216,  275,
- /*  1770 */   275,  222,  216,  256,  255,  196,   91,   82,  256,  255,
- /*  1780 */   308,  308,  146,   22,  143,  196,  155,  260,   25,  145,
- /*  1790 */   144,  199,   26,  198,   13,  190,  190,    6,  293,  131,
- /*  1800 */   188,  188,  245,  244,  136,  137,  245,  243,  242,  241,
- /*  1810 */   188,  202,  208,  217,  217,  260,  208,    4,  202,    3,
- /*  1820 */    22,  202,  208,  208,  160,   15,  209,  159,  270,  209,
- /*  1830 */    98,   16,  272,  208,   23,   23,  137,  148,  128,   20,
- /*  1840 */   140,   24,   16,  142,    1,  140,  149,  128,   61,   53,
- /*  1850 */   148,   37,   53,   53,   53,  128,  114,   34,  296,  296,
- /*  1860 */   139,    1,    5,   22,  113,  158,   26,   75,   41,  139,
- /*  1870 */    68,   68,  113,   24,   20,   19,  129,  123,   23,   96,
- /*  1880 */    22,   22,   37,   22,   22,   67,   22,   67,   59,   24,
- /*  1890 */    23,   28,   67,  147,   22,   26,   23,   23,   23,   23,
- /*  1900 */    22,   24,   23,   22,   24,   23,  139,   23,  114,   22,
- /*  1910 */   141,   26,   88,   75,   86,   44,   23,   34,   22,   75,
- /*  1920 */    34,   24,   34,   34,   34,   93,   34,   26,   26,   34,
- /*  1930 */    23,   23,   23,   23,   23,   11,   23,   22,   26,   22,
- /*  1940 */    22,  133,   23,   23,   22,   22,  139,   26,  139,   23,
- /*  1950 */    15,    1,    1,  310,  310,  310,  310,  310,  310,  310,
- /*  1960 */   139,  139,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  1970 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  1980 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  1990 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2000 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2010 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2020 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2030 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2040 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2050 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2060 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2070 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2080 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2090 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2100 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2110 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2120 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2130 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
- /*  2140 */   310,  310,  310,
+ /*   450 */    54,   55,   56,   57,  117,  117,  192,   59,   19,  187,
+ /*   460 */    59,  189,   23,  282,  240,  252,  194,  192,  196,  152,
+ /*   470 */   153,  154,  252,   72,  261,  203,  152,   25,  154,  142,
+ /*   480 */   142,  261,   43,   44,   45,   46,   47,   48,   49,   50,
+ /*   490 */    51,   52,   53,   54,   55,   56,   57,  192,  102,  103,
+ /*   500 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  267,
+ /*   510 */   238,  239,  237,  115,  116,  117,  115,  116,  117,  192,
+ /*   520 */    59,  118,   16,  251,  121,  122,  123,  303,   19,  303,
+ /*   530 */    59,  267,   23,   72,  131,  308,   22,  265,   22,  312,
+ /*   540 */    24,  102,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*   550 */   111,  112,   43,   44,   45,   46,   47,   48,   49,   50,
+ /*   560 */    51,   52,   53,   54,   55,   56,   57,   19,   81,  297,
+ /*   570 */   295,   23,  192,   59,  203,   59,  115,  116,  117,  108,
+ /*   580 */   192,   73,   25,   77,  192,   79,  115,  116,  117,  137,
+ /*   590 */   138,   43,   44,   45,   46,   47,   48,   49,   50,   51,
+ /*   600 */    52,   53,   54,   55,   56,   57,  119,  215,  216,  238,
+ /*   610 */   239,  102,  103,  104,  105,  106,  107,  108,  109,  110,
+ /*   620 */   111,  112,  251,  192,  137,  138,   59,  234,  235,  115,
+ /*   630 */   116,  117,  116,   76,  126,  127,  128,   19,  192,  268,
+ /*   640 */    19,   23,   22,  192,  252,   24,   89,  300,  301,   92,
+ /*   650 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*   660 */   112,   43,   44,   45,   46,   47,   48,   49,   50,   51,
+ /*   670 */    52,   53,   54,   55,   56,   57,   19,  192,  192,   59,
+ /*   680 */    23,  192,  115,  116,  117,  200,  240,  307,  308,   22,
+ /*   690 */   205,   81,  312,  262,   22,  192,  133,   22,  135,  136,
+ /*   700 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
+ /*   710 */    53,   54,   55,   56,   57,  197,   95,  150,  215,  216,
+ /*   720 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*   730 */   112,   59,  192,  112,   59,  115,  116,  117,  192,  118,
+ /*   740 */   119,  120,  121,  122,  123,  124,   19,  137,  138,  303,
+ /*   750 */    23,  130,  192,  267,  192,  252,  267,  306,  203,  102,
+ /*   760 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*   770 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
+ /*   780 */    53,   54,   55,   56,   57,   19,  240,  115,  116,  117,
+ /*   790 */   115,  116,  117,  238,  239,  222,  192,  224,  280,  237,
+ /*   800 */   240,  192,  284,  192,   59,  232,  251,  140,  204,   43,
+ /*   810 */    44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
+ /*   820 */    54,   55,   56,   57,  192,   35,  215,  216,  192,  102,
+ /*   830 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
+ /*   840 */    59,  230,  192,  192,  238,  239,  237,  215,  216,  303,
+ /*   850 */   308,  215,  216,   16,  312,   19,   66,  251,  126,  127,
+ /*   860 */   128,  116,  230,  303,   74,  203,  215,  216,  102,  103,
+ /*   870 */   104,  105,  106,  107,  108,  109,  110,  111,  112,   43,
+ /*   880 */    44,   45,   46,   47,   48,   49,   50,   51,   52,   53,
+ /*   890 */    54,   55,   56,   57,  192,  212,  115,  116,  117,   19,
+ /*   900 */   238,  239,  192,  252,    7,    8,    9,  192,  192,  238,
+ /*   910 */   239,  308,  262,  251,   77,  312,   79,  215,  216,  129,
+ /*   920 */   210,  211,  251,  142,  158,   45,   46,   47,   48,   49,
+ /*   930 */    50,   51,   52,   53,   54,   55,   56,   57,  102,  103,
+ /*   940 */   104,  105,  106,  107,  108,  109,  110,  111,  112,   12,
+ /*   950 */    59,  192,  192,  237,  252,  243,  192,  192,  126,  127,
+ /*   960 */   128,  192,  308,  203,   27,  253,  312,  308,  285,  207,
+ /*   970 */   208,  312,  157,  290,  159,  215,  216,  262,  192,   42,
+ /*   980 */   215,  216,  102,  103,  104,  105,  106,  107,  108,  109,
+ /*   990 */   110,  111,  112,  283,  158,  230,  237,  160,  238,  239,
+ /*  1000 */    63,  215,  216,  192,  192,   12,  115,  116,  117,   22,
+ /*  1010 */    73,  251,  252,  192,   19,  192,  230,  239,   24,   24,
+ /*  1020 */    27,  261,  210,  211,   99,  192,  215,  216,  225,  251,
+ /*  1030 */   192,  192,  263,  142,   19,   42,  215,  216,   43,   44,
+ /*  1040 */    45,   46,   47,   48,   49,   50,   51,   52,   53,   54,
+ /*  1050 */    55,   56,   57,   59,   19,  291,   63,  132,   43,   44,
+ /*  1060 */    45,   46,   47,   48,   49,   50,   51,   52,   53,   54,
+ /*  1070 */    55,   56,   57,  252,   22,   23,   22,   25,   43,   44,
+ /*  1080 */    45,   46,   47,   48,   49,   50,   51,   52,   53,   54,
+ /*  1090 */    55,   56,   57,  106,  107,  283,  263,  102,  103,  104,
+ /*  1100 */   105,  106,  107,  108,  109,  110,  111,  112,   59,  192,
+ /*  1110 */   116,  144,   29,   59,  291,  192,   33,  102,  103,  104,
+ /*  1120 */   105,  106,  107,  108,  109,  110,  111,  112,  192,  291,
+ /*  1130 */   163,   19,  215,  216,   15,  192,  108,  102,  103,  104,
+ /*  1140 */   105,  106,  107,  108,  109,  110,  111,  112,   65,  192,
+ /*  1150 */    66,  215,  216,  101,  231,  106,  107,   19,  215,  216,
+ /*  1160 */   192,  212,  134,  114,  115,  116,  117,  139,  119,   85,
+ /*  1170 */   116,  207,  208,  230,  192,   19,  127,  192,   94,   60,
+ /*  1180 */    59,  192,   44,   45,   46,   47,   48,   49,   50,   51,
+ /*  1190 */    52,   53,   54,   55,   56,   57,  192,   76,  192,   31,
+ /*  1200 */   192,  152,   46,  154,  215,  216,  192,   39,   87,  192,
+ /*  1210 */    89,   19,   20,   92,   22,  192,   22,   23,   22,  230,
+ /*  1220 */   263,  215,  216,  215,  216,  137,  138,  115,   36,  145,
+ /*  1230 */   128,  192,  215,  216,   22,   23,  115,  116,  117,  290,
+ /*  1240 */   102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
+ /*  1250 */   112,   59,  192,  151,  215,  216,  192,   61,  203,  298,
+ /*  1260 */   299,  192,  192,   71,   25,  144,  203,  192,  203,  230,
+ /*  1270 */   114,   19,   20,   81,   22,  215,  216,  263,  192,  215,
+ /*  1280 */   216,  255,  256,  203,  215,  216,  130,   19,   36,  192,
+ /*  1290 */   215,  216,  100,  238,  239,  101,   25,  192,  106,  107,
+ /*  1300 */    48,  238,  239,  238,  239,  113,  251,  115,  116,  117,
+ /*  1310 */   192,   59,  120,  101,  251,  192,  251,  192,  238,  239,
+ /*  1320 */   215,  216,  192,   71,   46,  243,  192,   25,   25,  137,
+ /*  1330 */   138,  251,  192,  215,  216,  253,   25,   85,  215,  216,
+ /*  1340 */   215,  216,   90,  243,  152,  153,  154,  155,  156,  215,
+ /*  1350 */   216,  192,  100,  253,  243,  215,  216,  192,  106,  107,
+ /*  1360 */   243,  192,  148,  149,  253,  113,  192,  115,  116,  117,
+ /*  1370 */   253,  192,  120,  192,  215,  216,  192,   23,  192,   25,
+ /*  1380 */   215,  216,  192,  115,  215,  216,   22,  148,   24,  215,
+ /*  1390 */   216,  192,  114,  192,  215,  216,  215,  216,  134,  215,
+ /*  1400 */   216,  215,  216,  139,  152,  153,  154,  155,  156,    0,
+ /*  1410 */     1,    2,  141,   23,    5,   25,  215,  216,   24,   10,
+ /*  1420 */    11,   12,   13,   14,    1,    2,   17,  125,    5,   19,
+ /*  1430 */    20,  268,   22,   10,   11,   12,   13,   14,  192,   30,
+ /*  1440 */    17,   32,   23,   23,   25,   25,   36,  144,   23,   40,
+ /*  1450 */    25,  192,  141,   30,  192,   32,   23,   22,   25,    5,
+ /*  1460 */   128,  215,  216,   40,   10,   11,   12,   13,   14,   59,
+ /*  1470 */    23,   17,   25,  192,  215,  216,  192,  215,  216,   70,
+ /*  1480 */    23,   71,   25,  151,   30,  192,   32,   78,   53,  192,
+ /*  1490 */    81,  192,  192,   70,   40,   85,  215,  216,  119,  120,
+ /*  1500 */    90,   78,   59,  254,   81,  192,  192,   98,  215,  216,
+ /*  1510 */   100,   23,   59,   25,  215,  216,  106,  107,   23,  192,
+ /*  1520 */    25,   98,   19,  113,   70,  115,  116,  117,  215,  216,
+ /*  1530 */   120,  192,   78,  192,  140,   81,   19,   20,   23,   22,
+ /*  1540 */    25,  132,  215,  216,  192,  192,  137,  138,  192,   23,
+ /*  1550 */   192,   25,   98,   36,  192,  132,  215,  216,  192,  116,
+ /*  1560 */   137,  138,  152,  153,  154,  155,  156,  215,  216,  116,
+ /*  1570 */   161,  215,  216,  215,  216,  120,   59,  215,  216,    7,
+ /*  1580 */     8,  215,  216,  192,  161,  130,  132,  192,   71,   83,
+ /*  1590 */    84,  137,  138,   59,  192,  192,   19,   20,  192,   22,
+ /*  1600 */    97,  225,   85,  192,   23,  192,   25,   90,  192,  192,
+ /*  1610 */   215,  216,  152,   36,  154,  161,  192,  100,  215,  216,
+ /*  1620 */   192,  215,  216,  106,  107,  225,  215,  216,  192,  192,
+ /*  1630 */   113,  192,  115,  116,  117,  257,   59,  120,  192,  215,
+ /*  1640 */   216,  152,  192,  154,  192,   23,  317,   25,   71,  235,
+ /*  1650 */   116,  215,  216,  192,  215,  216,  192,  192,  192,  192,
+ /*  1660 */   192,  192,  192,  192,  192,  215,  216,  215,  216,  152,
+ /*  1670 */   153,  154,  155,  156,  192,  192,  287,  100,  286,  241,
+ /*  1680 */   254,  254,  242,  106,  107,  108,  254,  213,  254,  190,
+ /*  1690 */   113,  270,  115,  116,  117,  296,  266,  120,  219,  258,
+ /*  1700 */   244,  270,  258,   19,   20,  228,   22,  292,  266,  224,
+ /*  1710 */   292,  218,  218,  195,  218,  270,  258,   60,  245,  270,
+ /*  1720 */    36,  245,  244,  248,   19,   20,  242,   22,  248,  152,
+ /*  1730 */   153,  154,  155,  156,  244,  140,  199,  199,  279,   38,
+ /*  1740 */   199,   36,  150,   59,  296,  149,   22,  296,   18,   43,
+ /*  1750 */   236,  199,  233,   18,  198,   71,  293,  236,  271,  236,
+ /*  1760 */   269,  236,  148,  271,   59,  245,  269,  245,  282,  271,
+ /*  1770 */   199,  198,  233,  245,  293,  233,   71,  245,  157,   62,
+ /*  1780 */    22,  199,  198,  220,  100,  199,  198,  220,  199,  289,
+ /*  1790 */   106,  107,  288,  114,  226,  198,  217,  113,   64,  115,
+ /*  1800 */   116,  117,  217,   22,  120,  100,  223,  217,  217,  164,
+ /*  1810 */   223,  106,  107,  220,  125,   24,  217,  219,  113,  217,
+ /*  1820 */   115,  116,  117,  217,  311,  120,  226,  112,  304,  281,
+ /*  1830 */   281,  220,  114,  143,  260,  259,  152,  153,  154,  155,
+ /*  1840 */   156,  199,   91,  316,   82,  316,  147,  144,   22,  199,
+ /*  1850 */   249,  276,  157,  146,  260,  145,  278,  152,  153,  154,
+ /*  1860 */   155,  156,  259,  248,  260,  260,  259,  259,  249,  245,
+ /*  1870 */   247,  246,   25,  264,  264,  201,   13,    6,  193,  193,
+ /*  1880 */   212,  206,  191,  191,  191,  212,  206,  221,  212,  212,
+ /*  1890 */   221,  213,    4,  206,  213,  212,    3,   22,  162,   15,
+ /*  1900 */    23,   16,   23,  138,  150,  129,   25,   24,  141,   20,
+ /*  1910 */    16,  143,    1,  141,  302,  302,  299,  129,  129,   61,
+ /*  1920 */   150,   53,   53,   37,  129,   53,   53,  115,    1,   34,
+ /*  1930 */   140,    5,   22,  114,  160,   68,   75,   25,   68,   41,
+ /*  1940 */   140,  114,   24,   20,   19,  130,  124,   67,   24,   67,
+ /*  1950 */    22,   22,   22,   96,   23,   22,   59,   22,   67,   37,
+ /*  1960 */    28,   23,  148,   22,   25,   23,   23,   23,   23,   22,
+ /*  1970 */   140,   97,   23,   23,  115,   22,  142,   25,   88,   75,
+ /*  1980 */    34,   44,   34,   75,   23,   34,   86,   22,   34,   34,
+ /*  1990 */    34,   24,   93,   25,   25,   23,   34,   23,   23,   23,
+ /*  2000 */    23,   11,   23,   25,   22,   22,   22,    1,   23,   23,
+ /*  2010 */    22,   22,   25,   15,   23,    1,  140,   25,  140,  318,
+ /*  2020 */   318,  134,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2030 */   318,  318,  140,  318,  318,  318,  140,  318,  318,  318,
+ /*  2040 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2050 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2060 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2070 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2080 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2090 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2100 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2110 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2120 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2130 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2140 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2150 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2160 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2170 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2180 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2190 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2200 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2210 */   318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
+ /*  2220 */   318,
 };
-#define YY_SHIFT_COUNT    (552)
+#define YY_SHIFT_COUNT    (571)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (1951)
+#define YY_SHIFT_MAX      (2014)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */  1448, 1277, 1668, 1072, 1072,  340, 1122, 1225, 1332, 1481,
- /*    10 */  1481, 1481,  335,    0,    0,  180,  897, 1481, 1481, 1481,
- /*    20 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
- /*    30 */   930,  930, 1020, 1020,  290,    1,  340,  340,  340,  340,
- /*    40 */   340,  340,   40,  110,  219,  288,  327,  396,  435,  504,
- /*    50 */   543,  612,  651,  720,  877,  897,  897,  897,  897,  897,
- /*    60 */   897,  897,  897,  897,  897,  897,  897,  897,  897,  897,
- /*    70 */   897,  897,  897,  917,  897, 1019,  763,  763, 1451, 1481,
- /*    80 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
- /*    90 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
- /*   100 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
- /*   110 */  1481, 1481, 1553, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
- /*   120 */  1481, 1481, 1481, 1481, 1481, 1481,  147,  258,  258,  258,
- /*   130 */   258,  258,   79,   65,   84,  449,   19,  786,  449,  636,
- /*   140 */   636,  449,  880,  880,  880,  880,  113,  142,  142,  472,
- /*   150 */   150, 1962, 1962,  399,  399,  399,   93,  237,  341,  237,
- /*   160 */   237, 1074, 1074,  437,  350,  704, 1080,  449,  449,  449,
- /*   170 */   449,  449,  449,  449,  449,  449,  449,  449,  449,  449,
- /*   180 */   449,  449,  449,  449,  449,  449,  449,  449,  818,  818,
- /*   190 */   449, 1088,  217,  217,  734,  734, 1124, 1126, 1962, 1962,
- /*   200 */  1962,  739,  840,  840,  453,  454,  511,  187,  563,  570,
- /*   210 */   898,  669,  449,  449,  449,  449,  449,  449,  449,  449,
- /*   220 */   449,  670,  449,  449,  449,  449,  449,  449,  449,  449,
- /*   230 */   449,  449,  449,  449,  674,  674,  674,  449,  449,  449,
- /*   240 */   449, 1034,  449,  449,  449,  972, 1107,  449,  449, 1193,
- /*   250 */   449,  449,  449,  449,  449,  449,  449,  449,  260,  177,
- /*   260 */   489, 1241, 1241, 1241, 1241, 1192,  489,  489,  952, 1197,
- /*   270 */   625, 1235, 1131,  181,  181, 1086, 1139, 1131, 1086, 1187,
- /*   280 */  1319, 1237, 1318, 1318, 1318,  181, 1299, 1299, 1109, 1336,
- /*   290 */   549, 1376, 1610, 1535, 1535, 1639, 1639, 1535, 1539, 1578,
- /*   300 */  1670, 1546, 1652, 1546, 1681, 1681, 1681, 1681, 1535, 1694,
- /*   310 */  1546, 1546, 1578, 1670, 1652, 1546, 1652, 1546, 1535, 1694,
- /*   320 */  1565, 1665, 1535, 1694, 1708, 1535, 1694, 1535, 1694, 1708,
- /*   330 */  1618, 1618, 1618, 1680, 1723, 1723, 1708, 1618, 1623, 1618,
- /*   340 */  1680, 1618, 1618, 1588, 1708, 1640, 1640, 1708, 1611, 1643,
- /*   350 */  1611, 1643, 1611, 1643, 1611, 1643, 1535, 1685, 1685, 1695,
- /*   360 */  1695, 1636, 1641, 1761, 1535, 1631, 1636, 1644, 1646, 1546,
- /*   370 */  1763, 1766, 1781, 1781, 1791, 1791, 1791, 1962, 1962, 1962,
- /*   380 */  1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962, 1962,
- /*   390 */  1962, 1962,  308,  835,  954, 1232,  879,  715,  728, 1373,
- /*   400 */   864, 1329, 1253, 1409,  297, 1431, 1489, 1497, 1520, 1521,
- /*   410 */  1525, 1362, 1309, 1491, 1217, 1420, 1429, 1536, 1380, 1538,
- /*   420 */  1293, 1354, 1548, 1585, 1434, 1342, 1813, 1816, 1798, 1664,
- /*   430 */  1810, 1732, 1815, 1811, 1812, 1699, 1689, 1710, 1817, 1700,
- /*   440 */  1819, 1701, 1826, 1843, 1705, 1697, 1719, 1787, 1814, 1702,
- /*   450 */  1796, 1799, 1800, 1801, 1727, 1742, 1823, 1721, 1860, 1857,
- /*   460 */  1841, 1751, 1707, 1802, 1840, 1803, 1792, 1827, 1730, 1759,
- /*   470 */  1849, 1854, 1856, 1747, 1754, 1858, 1818, 1859, 1861, 1855,
- /*   480 */  1862, 1820, 1829, 1865, 1783, 1863, 1864, 1825, 1845, 1867,
- /*   490 */  1746, 1872, 1873, 1874, 1875, 1869, 1876, 1878, 1877, 1879,
- /*   500 */  1881, 1880, 1767, 1882, 1884, 1794, 1883, 1887, 1769, 1885,
- /*   510 */  1886, 1888, 1889, 1890, 1824, 1838, 1828, 1871, 1844, 1832,
- /*   520 */  1892, 1893, 1896, 1897, 1901, 1902, 1895, 1907, 1885, 1908,
- /*   530 */  1909, 1910, 1911, 1912, 1913, 1915, 1924, 1917, 1918, 1919,
- /*   540 */  1920, 1922, 1923, 1921, 1808, 1807, 1809, 1821, 1822, 1926,
- /*   550 */  1935, 1950, 1951,
+ /*     0 */  1423, 1409, 1454, 1192, 1192,  610, 1252, 1410, 1517, 1684,
+ /*    10 */  1684, 1684,  276,    0,    0,  180, 1015, 1684, 1684, 1684,
+ /*    20 */  1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
+ /*    30 */  1049, 1049, 1121, 1121,   54,  487,  610,  610,  610,  610,
+ /*    40 */   610,   40,  110,  219,  289,  396,  439,  509,  548,  618,
+ /*    50 */   657,  727,  766,  836,  995, 1015, 1015, 1015, 1015, 1015,
+ /*    60 */  1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
+ /*    70 */  1015, 1015, 1015, 1035, 1015, 1138,  880,  880, 1577, 1684,
+ /*    80 */  1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
+ /*    90 */  1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
+ /*   100 */  1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
+ /*   110 */  1684, 1684, 1684, 1705, 1684, 1684, 1684, 1684, 1684, 1684,
+ /*   120 */  1684, 1684, 1684, 1684, 1684, 1684, 1684,  146,   84,   84,
+ /*   130 */    84,   84,   84,  277,  315,  401,   97,  461,  251,   66,
+ /*   140 */    66,   51, 1156,   66,   66,  324,  324,   66,  452,  452,
+ /*   150 */   452,  452,  133,  114,  114,    4,   11, 2037, 2037,  621,
+ /*   160 */   621,  621,  567,  398,  398,  398,  398,  937,  937,  228,
+ /*   170 */   251,  331, 1052,   66,   66,   66,   66,   66,   66,   66,
+ /*   180 */    66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
+ /*   190 */    66,   66,   66,  557,  557,   66,    9,   25,   25,  745,
+ /*   200 */   745,  967, 1088, 2037, 2037, 2037, 2037, 2037, 2037, 2037,
+ /*   210 */   255,  317,  317,  514,  403,  620,  471,  672,  781,  891,
+ /*   220 */   675,   66,   66,   66,   66,   66,   66,   66,   66,   66,
+ /*   230 */    66,  508,   66,   66,   66,   66,   66,   66,   66,   66,
+ /*   240 */    66,   66,   66,   66,  790,  790,  790,   66,   66,   66,
+ /*   250 */   338,   66,   66,   66,  516, 1084,   66,   66,  993,   66,
+ /*   260 */    66,   66,   66,   66,   66,   66,   66,  732, 1083,  563,
+ /*   270 */   994,  994,  994,  994,  337,  563,  563, 1028,  987,  897,
+ /*   280 */  1119,  262, 1214, 1271, 1112, 1214, 1112, 1268, 1239,  262,
+ /*   290 */   262, 1239,  262, 1271, 1268, 1302, 1354, 1278, 1168, 1168,
+ /*   300 */  1168, 1112, 1303, 1303,  815, 1311, 1264, 1364, 1657, 1657,
+ /*   310 */  1595, 1595, 1701, 1701, 1595, 1592, 1596, 1724, 1706, 1730,
+ /*   320 */  1730, 1730, 1730, 1595, 1735, 1614, 1596, 1596, 1614, 1724,
+ /*   330 */  1706, 1614, 1706, 1614, 1595, 1735, 1621, 1717, 1595, 1735,
+ /*   340 */  1758, 1595, 1735, 1595, 1735, 1758, 1679, 1679, 1679, 1734,
+ /*   350 */  1781, 1781, 1758, 1679, 1689, 1679, 1734, 1679, 1679, 1645,
+ /*   360 */  1791, 1715, 1715, 1758, 1690, 1718, 1690, 1718, 1690, 1718,
+ /*   370 */  1690, 1718, 1595, 1751, 1751, 1762, 1762, 1699, 1703, 1826,
+ /*   380 */  1595, 1695, 1699, 1707, 1710, 1614, 1847, 1863, 1863, 1871,
+ /*   390 */  1871, 1871, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037,
+ /*   400 */  2037, 2037, 2037, 2037, 2037, 2037, 2037,  193,  837, 1194,
+ /*   410 */  1212,  506,  832, 1054, 1390,  925, 1435, 1394, 1102, 1332,
+ /*   420 */  1419, 1196, 1420, 1425, 1433, 1447, 1457, 1488, 1443, 1379,
+ /*   430 */  1572, 1455, 1503, 1453, 1495, 1515, 1506, 1526, 1460, 1489,
+ /*   440 */  1581, 1622, 1534,  667, 1888, 1893, 1875, 1736, 1884, 1885,
+ /*   450 */  1877, 1879, 1765, 1754, 1776, 1881, 1881, 1883, 1767, 1889,
+ /*   460 */  1768, 1894, 1911, 1772, 1788, 1881, 1789, 1858, 1886, 1881,
+ /*   470 */  1770, 1868, 1869, 1872, 1873, 1795, 1812, 1895, 1790, 1927,
+ /*   480 */  1926, 1910, 1819, 1774, 1867, 1912, 1870, 1861, 1898, 1800,
+ /*   490 */  1827, 1918, 1923, 1925, 1815, 1822, 1928, 1880, 1929, 1930,
+ /*   500 */  1931, 1933, 1882, 1897, 1924, 1857, 1932, 1935, 1891, 1922,
+ /*   510 */  1938, 1814, 1941, 1942, 1943, 1944, 1939, 1945, 1947, 1874,
+ /*   520 */  1830, 1949, 1950, 1859, 1946, 1953, 1834, 1952, 1948, 1951,
+ /*   530 */  1954, 1955, 1890, 1904, 1900, 1937, 1908, 1899, 1956, 1961,
+ /*   540 */  1965, 1967, 1968, 1969, 1962, 1972, 1952, 1974, 1975, 1976,
+ /*   550 */  1977, 1978, 1979, 1982, 1990, 1983, 1984, 1985, 1986, 1988,
+ /*   560 */  1989, 1987, 1887, 1876, 1878, 1892, 1896, 1992, 1991, 1998,
+ /*   570 */  2006, 2014,
 };
-#define YY_REDUCE_COUNT (391)
-#define YY_REDUCE_MIN   (-262)
-#define YY_REDUCE_MAX   (1625)
+#define YY_REDUCE_COUNT (406)
+#define YY_REDUCE_MIN   (-272)
+#define YY_REDUCE_MAX   (1693)
 static const short yy_reduce_ofst[] = {
- /*     0 */   490, -122,  545,  645,  650, -120, -189, -187, -184, -182,
- /*    10 */  -178, -176,   45,   30,  200, -251, -134,  390,  392,  521,
- /*    20 */   523,  213,  692,  821,  284,  589,  872,  666,  671,  866,
- /*    30 */    71,  111,  273,  389,  686,  815,  904,  932,  948,  955,
- /*    40 */   964,  969, -259, -259, -259, -259, -259, -259, -259, -259,
- /*    50 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
- /*    60 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
- /*    70 */  -259, -259, -259, -259, -259, -259, -259, -259,  428,  430,
- /*    80 */   899,  985, 1021, 1028, 1057, 1069, 1081, 1108, 1110, 1115,
- /*    90 */  1117, 1123, 1149, 1154, 1159, 1170, 1174, 1178, 1183, 1194,
- /*   100 */  1198, 1204, 1208, 1212, 1218, 1222, 1229, 1278, 1280, 1283,
- /*   110 */  1285, 1313, 1316, 1320, 1322, 1325, 1327, 1330, 1366, 1371,
- /*   120 */  1379, 1387, 1417, 1425, 1430, 1432, -259, -259, -259, -259,
- /*   130 */  -259, -259, -259, -259, -259,  557,  974, -214, -174,   -9,
- /*   140 */   431, -124,  806,  925,  806,  925,  251,  928,  940, -259,
- /*   150 */  -259, -259, -259, -198, -198, -198,  127, -186, -168,  212,
- /*   160 */   646,  617,  799, -262,  555,  220,  220,  491,  605, 1040,
- /*   170 */  1060,  699,  -11,  600,  848,  862,  345, -129,  724,  -91,
- /*   180 */   158,  749,  716,  900,  304,  822,  929,  926,  499,  793,
- /*   190 */   322,  892,  813,  845,  958, 1056,  751,  905, 1133, 1062,
- /*   200 */   803, -210, -185, -179, -148, -167,  -89,  121,  274,  281,
- /*   210 */   320,  336,  439,  663,  711,  957,  965, 1064, 1068, 1112,
- /*   220 */  1116, -196, 1127, 1134, 1180, 1184, 1195, 1199, 1203, 1215,
- /*   230 */  1223, 1250, 1267, 1286,  205,  422,  638, 1324, 1341, 1364,
- /*   240 */  1365, 1213, 1392, 1399, 1403,  869, 1260, 1405, 1421, 1276,
- /*   250 */  1424,  121, 1426, 1427, 1428, 1433, 1436, 1437, 1227, 1338,
- /*   260 */  1284, 1359, 1370, 1377, 1388, 1213, 1284, 1284, 1385, 1438,
- /*   270 */  1443, 1349, 1400, 1391, 1394, 1360, 1408, 1410, 1367, 1439,
- /*   280 */  1440, 1435, 1442, 1446, 1447, 1397, 1413, 1418, 1390, 1444,
- /*   290 */  1445, 1474, 1381, 1479, 1480, 1401, 1402, 1490, 1414, 1449,
- /*   300 */  1452, 1453, 1467, 1456, 1469, 1470, 1477, 1478, 1515, 1518,
- /*   310 */  1476, 1482, 1450, 1454, 1492, 1483, 1493, 1484, 1523, 1531,
- /*   320 */  1457, 1455, 1532, 1534, 1516, 1537, 1540, 1543, 1541, 1526,
- /*   330 */  1528, 1530, 1542, 1512, 1529, 1533, 1544, 1545, 1547, 1550,
- /*   340 */  1549, 1551, 1554, 1458, 1552, 1494, 1495, 1556, 1498, 1502,
- /*   350 */  1503, 1511, 1517, 1519, 1522, 1524, 1579, 1472, 1473, 1527,
- /*   360 */  1555, 1557, 1559, 1558, 1589, 1560, 1561, 1564, 1566, 1568,
- /*   370 */  1592, 1595, 1605, 1606, 1612, 1613, 1622, 1562, 1563, 1505,
- /*   380 */  1609, 1604, 1608, 1614, 1615, 1616, 1596, 1597, 1617, 1620,
- /*   390 */  1625, 1619,
+ /*     0 */   109,  113,  272,  760, -178, -176, -192, -183, -180, -134,
+ /*    10 */   213,  220,  371, -208, -205, -272, -197,  611,  632,  765,
+ /*    20 */   786,  392,  943,  989,  503,  651, 1039,  -18,  702,  821,
+ /*    30 */   710,  812, -188,  380, -187,  555,  662, 1055, 1063, 1065,
+ /*    40 */  1080, -267, -267, -267, -267, -267, -267, -267, -267, -267,
+ /*    50 */  -267, -267, -267, -267, -267, -267, -267, -267, -267, -267,
+ /*    60 */  -267, -267, -267, -267, -267, -267, -267, -267, -267, -267,
+ /*    70 */  -267, -267, -267, -267, -267, -267, -267, -267,  636,  811,
+ /*    80 */   917,  936, 1006, 1008, 1017, 1060, 1064, 1069, 1075, 1105,
+ /*    90 */  1118, 1123, 1125, 1134, 1140, 1159, 1165, 1169, 1174, 1179,
+ /*   100 */  1181, 1184, 1186, 1201, 1246, 1259, 1262, 1281, 1293, 1299,
+ /*   110 */  1313, 1327, 1341, 1352, 1356, 1358, 1362, 1366, 1395, 1403,
+ /*   120 */  1406, 1411, 1424, 1436, 1439, 1450, 1452, -267, -267, -267,
+ /*   130 */  -267, -267, -267, -267, -267,  224, -267,  446,  -24,  275,
+ /*   140 */   546,  518,  573,  560,   53, -181, -111,  485,  606,  671,
+ /*   150 */   606,  671,  683,    8,   93, -267, -267, -267, -267,  155,
+ /*   160 */   155,  155,  181,  242,  264,  486,  489, -218,  393,  227,
+ /*   170 */   604,  347,  347, -171,  431,  650,  715, -166,  562,  609,
+ /*   180 */   716,  764,   18,  823,  769,  833,  838,  957,  759,  119,
+ /*   190 */   923,  226, 1014,  542,  603,  451,  949,  654,  659,  762,
+ /*   200 */   964,   -4,  778,  961,  712, 1082, 1100, 1111, 1026, 1117,
+ /*   210 */  -204, -174, -151,   -8,   77,  198,  305,  327,  388,  540,
+ /*   220 */   839,  968,  982,  985, 1004, 1023, 1070, 1086, 1097, 1130,
+ /*   230 */  1190, 1163, 1199, 1284, 1297, 1300, 1314, 1339, 1353, 1391,
+ /*   240 */  1402, 1413, 1416, 1417,  803, 1376, 1400, 1428, 1437, 1446,
+ /*   250 */  1378, 1461, 1464, 1465, 1249, 1329, 1466, 1467, 1414, 1468,
+ /*   260 */   305, 1469, 1470, 1471, 1472, 1482, 1483, 1389, 1392, 1438,
+ /*   270 */  1426, 1427, 1432, 1434, 1378, 1438, 1438, 1440, 1474, 1499,
+ /*   280 */  1399, 1421, 1430, 1456, 1441, 1442, 1444, 1415, 1473, 1431,
+ /*   290 */  1445, 1476, 1449, 1478, 1418, 1479, 1477, 1485, 1493, 1494,
+ /*   300 */  1496, 1458, 1475, 1480, 1459, 1490, 1484, 1518, 1448, 1451,
+ /*   310 */  1537, 1538, 1463, 1481, 1541, 1486, 1487, 1491, 1519, 1514,
+ /*   320 */  1521, 1523, 1525, 1552, 1556, 1520, 1492, 1498, 1522, 1497,
+ /*   330 */  1539, 1528, 1542, 1532, 1571, 1573, 1500, 1504, 1582, 1584,
+ /*   340 */  1563, 1586, 1588, 1589, 1597, 1567, 1579, 1585, 1590, 1568,
+ /*   350 */  1583, 1587, 1593, 1591, 1598, 1599, 1600, 1602, 1606, 1513,
+ /*   360 */  1524, 1548, 1549, 1611, 1574, 1576, 1594, 1603, 1604, 1607,
+ /*   370 */  1605, 1608, 1642, 1527, 1529, 1609, 1610, 1601, 1615, 1575,
+ /*   380 */  1650, 1578, 1619, 1623, 1625, 1624, 1674, 1685, 1686, 1691,
+ /*   390 */  1692, 1693, 1612, 1613, 1617, 1675, 1668, 1673, 1676, 1677,
+ /*   400 */  1680, 1666, 1669, 1678, 1681, 1683, 1687,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */  1575, 1575, 1575, 1411, 1188, 1297, 1188, 1188, 1188, 1411,
- /*    10 */  1411, 1411, 1188, 1327, 1327, 1464, 1219, 1188, 1188, 1188,
- /*    20 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1410, 1188, 1188,
- /*    30 */  1188, 1188, 1494, 1494, 1188, 1188, 1188, 1188, 1188, 1188,
- /*    40 */  1188, 1188, 1188, 1336, 1188, 1188, 1188, 1188, 1188, 1188,
- /*    50 */  1412, 1413, 1188, 1188, 1188, 1463, 1465, 1428, 1346, 1345,
- /*    60 */  1344, 1343, 1446, 1314, 1341, 1334, 1338, 1406, 1407, 1405,
- /*    70 */  1409, 1413, 1412, 1188, 1337, 1377, 1391, 1376, 1188, 1188,
- /*    80 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*    90 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   100 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   110 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   120 */  1188, 1188, 1188, 1188, 1188, 1188, 1385, 1390, 1396, 1389,
- /*   130 */  1386, 1379, 1378, 1380, 1381, 1188, 1209, 1261, 1188, 1188,
- /*   140 */  1188, 1188, 1482, 1481, 1188, 1188, 1219, 1371, 1370, 1382,
- /*   150 */  1383, 1393, 1392, 1471, 1529, 1528, 1429, 1188, 1188, 1188,
- /*   160 */  1188, 1188, 1188, 1494, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   170 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   180 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1494, 1494,
- /*   190 */  1188, 1219, 1494, 1494, 1215, 1215, 1321, 1188, 1477, 1297,
- /*   200 */  1288, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   210 */  1188, 1188, 1188, 1188, 1188, 1468, 1466, 1188, 1188, 1188,
- /*   220 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   230 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   240 */  1188, 1188, 1188, 1188, 1188, 1293, 1188, 1188, 1188, 1188,
- /*   250 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1523, 1188, 1441,
- /*   260 */  1275, 1293, 1293, 1293, 1293, 1295, 1276, 1274, 1287, 1220,
- /*   270 */  1195, 1567, 1294, 1316, 1316, 1564, 1340, 1294, 1564, 1236,
- /*   280 */  1545, 1231, 1327, 1327, 1327, 1316, 1321, 1321, 1408, 1294,
- /*   290 */  1287, 1188, 1567, 1302, 1302, 1566, 1566, 1302, 1429, 1349,
- /*   300 */  1355, 1340, 1264, 1340, 1270, 1270, 1270, 1270, 1302, 1206,
- /*   310 */  1340, 1340, 1349, 1355, 1264, 1340, 1264, 1340, 1302, 1206,
- /*   320 */  1445, 1561, 1302, 1206, 1419, 1302, 1206, 1302, 1206, 1419,
- /*   330 */  1262, 1262, 1262, 1251, 1188, 1188, 1419, 1262, 1236, 1262,
- /*   340 */  1251, 1262, 1262, 1512, 1419, 1423, 1423, 1419, 1320, 1315,
- /*   350 */  1320, 1315, 1320, 1315, 1320, 1315, 1302, 1504, 1504, 1330,
- /*   360 */  1330, 1335, 1321, 1414, 1302, 1188, 1335, 1333, 1331, 1340,
- /*   370 */  1212, 1254, 1526, 1526, 1522, 1522, 1522, 1572, 1572, 1477,
- /*   380 */  1538, 1219, 1219, 1219, 1219, 1538, 1238, 1238, 1220, 1220,
- /*   390 */  1219, 1538, 1188, 1188, 1188, 1188, 1188, 1188, 1533, 1188,
- /*   400 */  1430, 1306, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   410 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   420 */  1188, 1188, 1188, 1188, 1188, 1360, 1188, 1191, 1474, 1188,
- /*   430 */  1188, 1472, 1188, 1188, 1188, 1188, 1188, 1188, 1307, 1188,
- /*   440 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   450 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1563, 1188, 1188,
- /*   460 */  1188, 1188, 1188, 1188, 1444, 1443, 1188, 1188, 1304, 1188,
- /*   470 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   480 */  1188, 1188, 1234, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   490 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   500 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1332,
- /*   510 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   520 */  1188, 1188, 1188, 1188, 1509, 1322, 1188, 1188, 1554, 1188,
- /*   530 */  1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188,
- /*   540 */  1188, 1188, 1188, 1549, 1278, 1362, 1188, 1361, 1365, 1188,
- /*   550 */  1200, 1188, 1188,
+ /*     0 */  1633, 1633, 1633, 1462, 1230, 1341, 1230, 1230, 1230, 1462,
+ /*    10 */  1462, 1462, 1230, 1371, 1371, 1515, 1263, 1230, 1230, 1230,
+ /*    20 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1461, 1230, 1230,
+ /*    30 */  1230, 1230, 1550, 1550, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*    40 */  1230, 1230, 1380, 1230, 1387, 1230, 1230, 1230, 1230, 1230,
+ /*    50 */  1463, 1464, 1230, 1230, 1230, 1514, 1516, 1479, 1394, 1393,
+ /*    60 */  1392, 1391, 1497, 1358, 1385, 1378, 1382, 1457, 1458, 1456,
+ /*    70 */  1460, 1464, 1463, 1230, 1381, 1428, 1442, 1427, 1230, 1230,
+ /*    80 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*    90 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   100 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   110 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   120 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1436, 1441, 1447,
+ /*   130 */  1440, 1437, 1430, 1429, 1431, 1230, 1432, 1230, 1254, 1230,
+ /*   140 */  1230, 1251, 1305, 1230, 1230, 1230, 1230, 1230, 1534, 1533,
+ /*   150 */  1230, 1230, 1263, 1422, 1421, 1433, 1434, 1444, 1443, 1522,
+ /*   160 */  1586, 1585, 1480, 1230, 1230, 1230, 1230, 1230, 1230, 1550,
+ /*   170 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   180 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   190 */  1230, 1230, 1230, 1550, 1550, 1230, 1263, 1550, 1550, 1259,
+ /*   200 */  1259, 1365, 1230, 1529, 1332, 1332, 1332, 1332, 1341, 1332,
+ /*   210 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   220 */  1230, 1230, 1230, 1230, 1230, 1519, 1517, 1230, 1230, 1230,
+ /*   230 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   240 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   250 */  1230, 1230, 1230, 1230, 1337, 1230, 1230, 1230, 1230, 1230,
+ /*   260 */  1230, 1230, 1230, 1230, 1230, 1230, 1579, 1230, 1492, 1319,
+ /*   270 */  1337, 1337, 1337, 1337, 1339, 1320, 1318, 1331, 1264, 1237,
+ /*   280 */  1625, 1397, 1386, 1338, 1360, 1386, 1360, 1622, 1384, 1397,
+ /*   290 */  1397, 1384, 1397, 1338, 1622, 1280, 1602, 1275, 1371, 1371,
+ /*   300 */  1371, 1360, 1365, 1365, 1459, 1338, 1331, 1230, 1625, 1625,
+ /*   310 */  1346, 1346, 1624, 1624, 1346, 1480, 1609, 1406, 1308, 1314,
+ /*   320 */  1314, 1314, 1314, 1346, 1248, 1384, 1609, 1609, 1384, 1406,
+ /*   330 */  1308, 1384, 1308, 1384, 1346, 1248, 1496, 1619, 1346, 1248,
+ /*   340 */  1470, 1346, 1248, 1346, 1248, 1470, 1306, 1306, 1306, 1295,
+ /*   350 */  1230, 1230, 1470, 1306, 1280, 1306, 1295, 1306, 1306, 1568,
+ /*   360 */  1230, 1474, 1474, 1470, 1364, 1359, 1364, 1359, 1364, 1359,
+ /*   370 */  1364, 1359, 1346, 1560, 1560, 1374, 1374, 1379, 1365, 1465,
+ /*   380 */  1346, 1230, 1379, 1377, 1375, 1384, 1298, 1582, 1582, 1578,
+ /*   390 */  1578, 1578, 1630, 1630, 1529, 1595, 1263, 1263, 1263, 1263,
+ /*   400 */  1595, 1282, 1282, 1264, 1264, 1263, 1595, 1230, 1230, 1230,
+ /*   410 */  1230, 1230, 1230, 1590, 1230, 1524, 1481, 1350, 1230, 1230,
+ /*   420 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   430 */  1230, 1230, 1535, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   440 */  1230, 1230, 1230, 1411, 1230, 1233, 1526, 1230, 1230, 1230,
+ /*   450 */  1230, 1230, 1230, 1230, 1230, 1388, 1389, 1351, 1230, 1230,
+ /*   460 */  1230, 1230, 1230, 1230, 1230, 1403, 1230, 1230, 1230, 1398,
+ /*   470 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1621, 1230,
+ /*   480 */  1230, 1230, 1230, 1230, 1230, 1495, 1494, 1230, 1230, 1348,
+ /*   490 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   500 */  1230, 1230, 1230, 1278, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   510 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   520 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1376, 1230, 1230,
+ /*   530 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   540 */  1230, 1230, 1565, 1366, 1230, 1230, 1612, 1230, 1230, 1230,
+ /*   550 */  1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230,
+ /*   560 */  1230, 1606, 1322, 1413, 1230, 1412, 1416, 1252, 1230, 1242,
+ /*   570 */  1230, 1230,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -156024,8 +160664,8 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*         LP => nothing */
     0,  /*         RP => nothing */
     0,  /*         AS => nothing */
-   59,  /*    WITHOUT => ID */
     0,  /*      COMMA => nothing */
+   59,  /*    WITHOUT => ID */
    59,  /*      ABORT => ID */
    59,  /*     ACTION => ID */
    59,  /*      AFTER => ID */
@@ -156096,6 +160736,7 @@ static const YYCODETYPE yyFallback[] = {
    59,  /*       TIES => ID */
    59,  /*  GENERATED => ID */
    59,  /*     ALWAYS => ID */
+   59,  /* MATERIALIZED => ID */
    59,  /*    REINDEX => ID */
    59,  /*     RENAME => ID */
    59,  /*   CTIME_KW => ID */
@@ -156147,6 +160788,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*     HAVING => nothing */
     0,  /*      LIMIT => nothing */
     0,  /*      WHERE => nothing */
+    0,  /*  RETURNING => nothing */
     0,  /*       INTO => nothing */
     0,  /*    NOTHING => nothing */
     0,  /*      FLOAT => nothing */
@@ -156178,6 +160820,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /* IF_NULL_ROW => nothing */
     0,  /*   ASTERISK => nothing */
     0,  /*       SPAN => nothing */
+    0,  /*      ERROR => nothing */
     0,  /*      SPACE => nothing */
     0,  /*    ILLEGAL => nothing */
 };
@@ -156231,9 +160874,9 @@ struct yyParser {
 };
 typedef struct yyParser yyParser;
 
+/* #include <assert.h> */
 #ifndef NDEBUG
 /* #include <stdio.h> */
-/* #include <assert.h> */
 static FILE *yyTraceFILE = 0;
 static char *yyTracePrompt = 0;
 #endif /* NDEBUG */
@@ -156293,8 +160936,8 @@ static const char *const yyTokenName[] = {
   /*   22 */ "LP",
   /*   23 */ "RP",
   /*   24 */ "AS",
-  /*   25 */ "WITHOUT",
-  /*   26 */ "COMMA",
+  /*   25 */ "COMMA",
+  /*   26 */ "WITHOUT",
   /*   27 */ "ABORT",
   /*   28 */ "ACTION",
   /*   29 */ "AFTER",
@@ -156365,219 +161008,227 @@ static const char *const yyTokenName[] = {
   /*   94 */ "TIES",
   /*   95 */ "GENERATED",
   /*   96 */ "ALWAYS",
-  /*   97 */ "REINDEX",
-  /*   98 */ "RENAME",
-  /*   99 */ "CTIME_KW",
-  /*  100 */ "ANY",
-  /*  101 */ "BITAND",
-  /*  102 */ "BITOR",
-  /*  103 */ "LSHIFT",
-  /*  104 */ "RSHIFT",
-  /*  105 */ "PLUS",
-  /*  106 */ "MINUS",
-  /*  107 */ "STAR",
-  /*  108 */ "SLASH",
-  /*  109 */ "REM",
-  /*  110 */ "CONCAT",
-  /*  111 */ "COLLATE",
-  /*  112 */ "BITNOT",
-  /*  113 */ "ON",
-  /*  114 */ "INDEXED",
-  /*  115 */ "STRING",
-  /*  116 */ "JOIN_KW",
-  /*  117 */ "CONSTRAINT",
-  /*  118 */ "DEFAULT",
-  /*  119 */ "NULL",
-  /*  120 */ "PRIMARY",
-  /*  121 */ "UNIQUE",
-  /*  122 */ "CHECK",
-  /*  123 */ "REFERENCES",
-  /*  124 */ "AUTOINCR",
-  /*  125 */ "INSERT",
-  /*  126 */ "DELETE",
-  /*  127 */ "UPDATE",
-  /*  128 */ "SET",
-  /*  129 */ "DEFERRABLE",
-  /*  130 */ "FOREIGN",
-  /*  131 */ "DROP",
-  /*  132 */ "UNION",
-  /*  133 */ "ALL",
-  /*  134 */ "EXCEPT",
-  /*  135 */ "INTERSECT",
-  /*  136 */ "SELECT",
-  /*  137 */ "VALUES",
-  /*  138 */ "DISTINCT",
-  /*  139 */ "DOT",
-  /*  140 */ "FROM",
-  /*  141 */ "JOIN",
-  /*  142 */ "USING",
-  /*  143 */ "ORDER",
-  /*  144 */ "GROUP",
-  /*  145 */ "HAVING",
-  /*  146 */ "LIMIT",
-  /*  147 */ "WHERE",
-  /*  148 */ "INTO",
-  /*  149 */ "NOTHING",
-  /*  150 */ "FLOAT",
-  /*  151 */ "BLOB",
-  /*  152 */ "INTEGER",
-  /*  153 */ "VARIABLE",
-  /*  154 */ "CASE",
-  /*  155 */ "WHEN",
-  /*  156 */ "THEN",
-  /*  157 */ "ELSE",
-  /*  158 */ "INDEX",
-  /*  159 */ "ALTER",
-  /*  160 */ "ADD",
-  /*  161 */ "WINDOW",
-  /*  162 */ "OVER",
-  /*  163 */ "FILTER",
-  /*  164 */ "COLUMN",
-  /*  165 */ "AGG_FUNCTION",
-  /*  166 */ "AGG_COLUMN",
-  /*  167 */ "TRUEFALSE",
-  /*  168 */ "ISNOT",
-  /*  169 */ "FUNCTION",
-  /*  170 */ "UMINUS",
-  /*  171 */ "UPLUS",
-  /*  172 */ "TRUTH",
-  /*  173 */ "REGISTER",
-  /*  174 */ "VECTOR",
-  /*  175 */ "SELECT_COLUMN",
-  /*  176 */ "IF_NULL_ROW",
-  /*  177 */ "ASTERISK",
-  /*  178 */ "SPAN",
-  /*  179 */ "SPACE",
-  /*  180 */ "ILLEGAL",
-  /*  181 */ "input",
-  /*  182 */ "cmdlist",
-  /*  183 */ "ecmd",
-  /*  184 */ "cmdx",
-  /*  185 */ "explain",
-  /*  186 */ "cmd",
-  /*  187 */ "transtype",
-  /*  188 */ "trans_opt",
-  /*  189 */ "nm",
-  /*  190 */ "savepoint_opt",
-  /*  191 */ "create_table",
-  /*  192 */ "create_table_args",
-  /*  193 */ "createkw",
-  /*  194 */ "temp",
-  /*  195 */ "ifnotexists",
-  /*  196 */ "dbnm",
-  /*  197 */ "columnlist",
-  /*  198 */ "conslist_opt",
-  /*  199 */ "table_options",
-  /*  200 */ "select",
-  /*  201 */ "columnname",
-  /*  202 */ "carglist",
-  /*  203 */ "typetoken",
-  /*  204 */ "typename",
-  /*  205 */ "signed",
-  /*  206 */ "plus_num",
-  /*  207 */ "minus_num",
-  /*  208 */ "scanpt",
-  /*  209 */ "scantok",
-  /*  210 */ "ccons",
-  /*  211 */ "term",
-  /*  212 */ "expr",
-  /*  213 */ "onconf",
-  /*  214 */ "sortorder",
-  /*  215 */ "autoinc",
-  /*  216 */ "eidlist_opt",
-  /*  217 */ "refargs",
-  /*  218 */ "defer_subclause",
-  /*  219 */ "generated",
-  /*  220 */ "refarg",
-  /*  221 */ "refact",
-  /*  222 */ "init_deferred_pred_opt",
-  /*  223 */ "conslist",
-  /*  224 */ "tconscomma",
-  /*  225 */ "tcons",
-  /*  226 */ "sortlist",
-  /*  227 */ "eidlist",
-  /*  228 */ "defer_subclause_opt",
-  /*  229 */ "orconf",
-  /*  230 */ "resolvetype",
-  /*  231 */ "raisetype",
-  /*  232 */ "ifexists",
-  /*  233 */ "fullname",
-  /*  234 */ "selectnowith",
-  /*  235 */ "oneselect",
-  /*  236 */ "wqlist",
-  /*  237 */ "multiselect_op",
-  /*  238 */ "distinct",
-  /*  239 */ "selcollist",
-  /*  240 */ "from",
-  /*  241 */ "where_opt",
-  /*  242 */ "groupby_opt",
-  /*  243 */ "having_opt",
-  /*  244 */ "orderby_opt",
-  /*  245 */ "limit_opt",
-  /*  246 */ "window_clause",
-  /*  247 */ "values",
-  /*  248 */ "nexprlist",
-  /*  249 */ "sclp",
-  /*  250 */ "as",
-  /*  251 */ "seltablist",
-  /*  252 */ "stl_prefix",
-  /*  253 */ "joinop",
-  /*  254 */ "indexed_opt",
-  /*  255 */ "on_opt",
-  /*  256 */ "using_opt",
-  /*  257 */ "exprlist",
-  /*  258 */ "xfullname",
-  /*  259 */ "idlist",
-  /*  260 */ "nulls",
-  /*  261 */ "with",
-  /*  262 */ "setlist",
-  /*  263 */ "insert_cmd",
-  /*  264 */ "idlist_opt",
-  /*  265 */ "upsert",
-  /*  266 */ "filter_over",
-  /*  267 */ "likeop",
-  /*  268 */ "between_op",
-  /*  269 */ "in_op",
-  /*  270 */ "paren_exprlist",
-  /*  271 */ "case_operand",
-  /*  272 */ "case_exprlist",
-  /*  273 */ "case_else",
-  /*  274 */ "uniqueflag",
-  /*  275 */ "collate",
-  /*  276 */ "vinto",
-  /*  277 */ "nmnum",
-  /*  278 */ "trigger_decl",
-  /*  279 */ "trigger_cmd_list",
-  /*  280 */ "trigger_time",
-  /*  281 */ "trigger_event",
-  /*  282 */ "foreach_clause",
-  /*  283 */ "when_clause",
-  /*  284 */ "trigger_cmd",
-  /*  285 */ "trnm",
-  /*  286 */ "tridxby",
-  /*  287 */ "database_kw_opt",
-  /*  288 */ "key_opt",
-  /*  289 */ "add_column_fullname",
-  /*  290 */ "kwcolumn_opt",
-  /*  291 */ "create_vtab",
-  /*  292 */ "vtabarglist",
-  /*  293 */ "vtabarg",
-  /*  294 */ "vtabargtoken",
-  /*  295 */ "lp",
-  /*  296 */ "anylist",
-  /*  297 */ "windowdefn_list",
-  /*  298 */ "windowdefn",
-  /*  299 */ "window",
-  /*  300 */ "frame_opt",
-  /*  301 */ "part_opt",
-  /*  302 */ "filter_clause",
-  /*  303 */ "over_clause",
-  /*  304 */ "range_or_rows",
-  /*  305 */ "frame_bound",
-  /*  306 */ "frame_bound_s",
-  /*  307 */ "frame_bound_e",
-  /*  308 */ "frame_exclude_opt",
-  /*  309 */ "frame_exclude",
+  /*   97 */ "MATERIALIZED",
+  /*   98 */ "REINDEX",
+  /*   99 */ "RENAME",
+  /*  100 */ "CTIME_KW",
+  /*  101 */ "ANY",
+  /*  102 */ "BITAND",
+  /*  103 */ "BITOR",
+  /*  104 */ "LSHIFT",
+  /*  105 */ "RSHIFT",
+  /*  106 */ "PLUS",
+  /*  107 */ "MINUS",
+  /*  108 */ "STAR",
+  /*  109 */ "SLASH",
+  /*  110 */ "REM",
+  /*  111 */ "CONCAT",
+  /*  112 */ "COLLATE",
+  /*  113 */ "BITNOT",
+  /*  114 */ "ON",
+  /*  115 */ "INDEXED",
+  /*  116 */ "STRING",
+  /*  117 */ "JOIN_KW",
+  /*  118 */ "CONSTRAINT",
+  /*  119 */ "DEFAULT",
+  /*  120 */ "NULL",
+  /*  121 */ "PRIMARY",
+  /*  122 */ "UNIQUE",
+  /*  123 */ "CHECK",
+  /*  124 */ "REFERENCES",
+  /*  125 */ "AUTOINCR",
+  /*  126 */ "INSERT",
+  /*  127 */ "DELETE",
+  /*  128 */ "UPDATE",
+  /*  129 */ "SET",
+  /*  130 */ "DEFERRABLE",
+  /*  131 */ "FOREIGN",
+  /*  132 */ "DROP",
+  /*  133 */ "UNION",
+  /*  134 */ "ALL",
+  /*  135 */ "EXCEPT",
+  /*  136 */ "INTERSECT",
+  /*  137 */ "SELECT",
+  /*  138 */ "VALUES",
+  /*  139 */ "DISTINCT",
+  /*  140 */ "DOT",
+  /*  141 */ "FROM",
+  /*  142 */ "JOIN",
+  /*  143 */ "USING",
+  /*  144 */ "ORDER",
+  /*  145 */ "GROUP",
+  /*  146 */ "HAVING",
+  /*  147 */ "LIMIT",
+  /*  148 */ "WHERE",
+  /*  149 */ "RETURNING",
+  /*  150 */ "INTO",
+  /*  151 */ "NOTHING",
+  /*  152 */ "FLOAT",
+  /*  153 */ "BLOB",
+  /*  154 */ "INTEGER",
+  /*  155 */ "VARIABLE",
+  /*  156 */ "CASE",
+  /*  157 */ "WHEN",
+  /*  158 */ "THEN",
+  /*  159 */ "ELSE",
+  /*  160 */ "INDEX",
+  /*  161 */ "ALTER",
+  /*  162 */ "ADD",
+  /*  163 */ "WINDOW",
+  /*  164 */ "OVER",
+  /*  165 */ "FILTER",
+  /*  166 */ "COLUMN",
+  /*  167 */ "AGG_FUNCTION",
+  /*  168 */ "AGG_COLUMN",
+  /*  169 */ "TRUEFALSE",
+  /*  170 */ "ISNOT",
+  /*  171 */ "FUNCTION",
+  /*  172 */ "UMINUS",
+  /*  173 */ "UPLUS",
+  /*  174 */ "TRUTH",
+  /*  175 */ "REGISTER",
+  /*  176 */ "VECTOR",
+  /*  177 */ "SELECT_COLUMN",
+  /*  178 */ "IF_NULL_ROW",
+  /*  179 */ "ASTERISK",
+  /*  180 */ "SPAN",
+  /*  181 */ "ERROR",
+  /*  182 */ "SPACE",
+  /*  183 */ "ILLEGAL",
+  /*  184 */ "input",
+  /*  185 */ "cmdlist",
+  /*  186 */ "ecmd",
+  /*  187 */ "cmdx",
+  /*  188 */ "explain",
+  /*  189 */ "cmd",
+  /*  190 */ "transtype",
+  /*  191 */ "trans_opt",
+  /*  192 */ "nm",
+  /*  193 */ "savepoint_opt",
+  /*  194 */ "create_table",
+  /*  195 */ "create_table_args",
+  /*  196 */ "createkw",
+  /*  197 */ "temp",
+  /*  198 */ "ifnotexists",
+  /*  199 */ "dbnm",
+  /*  200 */ "columnlist",
+  /*  201 */ "conslist_opt",
+  /*  202 */ "table_option_set",
+  /*  203 */ "select",
+  /*  204 */ "table_option",
+  /*  205 */ "columnname",
+  /*  206 */ "carglist",
+  /*  207 */ "typetoken",
+  /*  208 */ "typename",
+  /*  209 */ "signed",
+  /*  210 */ "plus_num",
+  /*  211 */ "minus_num",
+  /*  212 */ "scanpt",
+  /*  213 */ "scantok",
+  /*  214 */ "ccons",
+  /*  215 */ "term",
+  /*  216 */ "expr",
+  /*  217 */ "onconf",
+  /*  218 */ "sortorder",
+  /*  219 */ "autoinc",
+  /*  220 */ "eidlist_opt",
+  /*  221 */ "refargs",
+  /*  222 */ "defer_subclause",
+  /*  223 */ "generated",
+  /*  224 */ "refarg",
+  /*  225 */ "refact",
+  /*  226 */ "init_deferred_pred_opt",
+  /*  227 */ "conslist",
+  /*  228 */ "tconscomma",
+  /*  229 */ "tcons",
+  /*  230 */ "sortlist",
+  /*  231 */ "eidlist",
+  /*  232 */ "defer_subclause_opt",
+  /*  233 */ "orconf",
+  /*  234 */ "resolvetype",
+  /*  235 */ "raisetype",
+  /*  236 */ "ifexists",
+  /*  237 */ "fullname",
+  /*  238 */ "selectnowith",
+  /*  239 */ "oneselect",
+  /*  240 */ "wqlist",
+  /*  241 */ "multiselect_op",
+  /*  242 */ "distinct",
+  /*  243 */ "selcollist",
+  /*  244 */ "from",
+  /*  245 */ "where_opt",
+  /*  246 */ "groupby_opt",
+  /*  247 */ "having_opt",
+  /*  248 */ "orderby_opt",
+  /*  249 */ "limit_opt",
+  /*  250 */ "window_clause",
+  /*  251 */ "values",
+  /*  252 */ "nexprlist",
+  /*  253 */ "sclp",
+  /*  254 */ "as",
+  /*  255 */ "seltablist",
+  /*  256 */ "stl_prefix",
+  /*  257 */ "joinop",
+  /*  258 */ "indexed_opt",
+  /*  259 */ "on_opt",
+  /*  260 */ "using_opt",
+  /*  261 */ "exprlist",
+  /*  262 */ "xfullname",
+  /*  263 */ "idlist",
+  /*  264 */ "nulls",
+  /*  265 */ "with",
+  /*  266 */ "where_opt_ret",
+  /*  267 */ "setlist",
+  /*  268 */ "insert_cmd",
+  /*  269 */ "idlist_opt",
+  /*  270 */ "upsert",
+  /*  271 */ "returning",
+  /*  272 */ "filter_over",
+  /*  273 */ "likeop",
+  /*  274 */ "between_op",
+  /*  275 */ "in_op",
+  /*  276 */ "paren_exprlist",
+  /*  277 */ "case_operand",
+  /*  278 */ "case_exprlist",
+  /*  279 */ "case_else",
+  /*  280 */ "uniqueflag",
+  /*  281 */ "collate",
+  /*  282 */ "vinto",
+  /*  283 */ "nmnum",
+  /*  284 */ "trigger_decl",
+  /*  285 */ "trigger_cmd_list",
+  /*  286 */ "trigger_time",
+  /*  287 */ "trigger_event",
+  /*  288 */ "foreach_clause",
+  /*  289 */ "when_clause",
+  /*  290 */ "trigger_cmd",
+  /*  291 */ "trnm",
+  /*  292 */ "tridxby",
+  /*  293 */ "database_kw_opt",
+  /*  294 */ "key_opt",
+  /*  295 */ "add_column_fullname",
+  /*  296 */ "kwcolumn_opt",
+  /*  297 */ "create_vtab",
+  /*  298 */ "vtabarglist",
+  /*  299 */ "vtabarg",
+  /*  300 */ "vtabargtoken",
+  /*  301 */ "lp",
+  /*  302 */ "anylist",
+  /*  303 */ "wqitem",
+  /*  304 */ "wqas",
+  /*  305 */ "windowdefn_list",
+  /*  306 */ "windowdefn",
+  /*  307 */ "window",
+  /*  308 */ "frame_opt",
+  /*  309 */ "part_opt",
+  /*  310 */ "filter_clause",
+  /*  311 */ "over_clause",
+  /*  312 */ "range_or_rows",
+  /*  313 */ "frame_bound",
+  /*  314 */ "frame_bound_s",
+  /*  315 */ "frame_bound_e",
+  /*  316 */ "frame_exclude_opt",
+  /*  317 */ "frame_exclude",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -156604,372 +161255,388 @@ static const char *const yyRuleName[] = {
  /*  16 */ "ifnotexists ::= IF NOT EXISTS",
  /*  17 */ "temp ::= TEMP",
  /*  18 */ "temp ::=",
- /*  19 */ "create_table_args ::= LP columnlist conslist_opt RP table_options",
+ /*  19 */ "create_table_args ::= LP columnlist conslist_opt RP table_option_set",
  /*  20 */ "create_table_args ::= AS select",
- /*  21 */ "table_options ::=",
- /*  22 */ "table_options ::= WITHOUT nm",
- /*  23 */ "columnname ::= nm typetoken",
- /*  24 */ "typetoken ::=",
- /*  25 */ "typetoken ::= typename LP signed RP",
- /*  26 */ "typetoken ::= typename LP signed COMMA signed RP",
- /*  27 */ "typename ::= typename ID|STRING",
- /*  28 */ "scanpt ::=",
- /*  29 */ "scantok ::=",
- /*  30 */ "ccons ::= CONSTRAINT nm",
- /*  31 */ "ccons ::= DEFAULT scantok term",
- /*  32 */ "ccons ::= DEFAULT LP expr RP",
- /*  33 */ "ccons ::= DEFAULT PLUS scantok term",
- /*  34 */ "ccons ::= DEFAULT MINUS scantok term",
- /*  35 */ "ccons ::= DEFAULT scantok ID|INDEXED",
- /*  36 */ "ccons ::= NOT NULL onconf",
- /*  37 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
- /*  38 */ "ccons ::= UNIQUE onconf",
- /*  39 */ "ccons ::= CHECK LP expr RP",
- /*  40 */ "ccons ::= REFERENCES nm eidlist_opt refargs",
- /*  41 */ "ccons ::= defer_subclause",
- /*  42 */ "ccons ::= COLLATE ID|STRING",
- /*  43 */ "generated ::= LP expr RP",
- /*  44 */ "generated ::= LP expr RP ID",
- /*  45 */ "autoinc ::=",
- /*  46 */ "autoinc ::= AUTOINCR",
- /*  47 */ "refargs ::=",
- /*  48 */ "refargs ::= refargs refarg",
- /*  49 */ "refarg ::= MATCH nm",
- /*  50 */ "refarg ::= ON INSERT refact",
- /*  51 */ "refarg ::= ON DELETE refact",
- /*  52 */ "refarg ::= ON UPDATE refact",
- /*  53 */ "refact ::= SET NULL",
- /*  54 */ "refact ::= SET DEFAULT",
- /*  55 */ "refact ::= CASCADE",
- /*  56 */ "refact ::= RESTRICT",
- /*  57 */ "refact ::= NO ACTION",
- /*  58 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
- /*  59 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
- /*  60 */ "init_deferred_pred_opt ::=",
- /*  61 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
- /*  62 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
- /*  63 */ "conslist_opt ::=",
- /*  64 */ "tconscomma ::= COMMA",
- /*  65 */ "tcons ::= CONSTRAINT nm",
- /*  66 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf",
- /*  67 */ "tcons ::= UNIQUE LP sortlist RP onconf",
- /*  68 */ "tcons ::= CHECK LP expr RP onconf",
- /*  69 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt",
- /*  70 */ "defer_subclause_opt ::=",
- /*  71 */ "onconf ::=",
- /*  72 */ "onconf ::= ON CONFLICT resolvetype",
- /*  73 */ "orconf ::=",
- /*  74 */ "orconf ::= OR resolvetype",
- /*  75 */ "resolvetype ::= IGNORE",
- /*  76 */ "resolvetype ::= REPLACE",
- /*  77 */ "cmd ::= DROP TABLE ifexists fullname",
- /*  78 */ "ifexists ::= IF EXISTS",
- /*  79 */ "ifexists ::=",
- /*  80 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select",
- /*  81 */ "cmd ::= DROP VIEW ifexists fullname",
- /*  82 */ "cmd ::= select",
- /*  83 */ "select ::= WITH wqlist selectnowith",
- /*  84 */ "select ::= WITH RECURSIVE wqlist selectnowith",
- /*  85 */ "select ::= selectnowith",
- /*  86 */ "selectnowith ::= selectnowith multiselect_op oneselect",
- /*  87 */ "multiselect_op ::= UNION",
- /*  88 */ "multiselect_op ::= UNION ALL",
- /*  89 */ "multiselect_op ::= EXCEPT|INTERSECT",
- /*  90 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
- /*  91 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
- /*  92 */ "values ::= VALUES LP nexprlist RP",
- /*  93 */ "values ::= values COMMA LP nexprlist RP",
- /*  94 */ "distinct ::= DISTINCT",
- /*  95 */ "distinct ::= ALL",
- /*  96 */ "distinct ::=",
- /*  97 */ "sclp ::=",
- /*  98 */ "selcollist ::= sclp scanpt expr scanpt as",
- /*  99 */ "selcollist ::= sclp scanpt STAR",
- /* 100 */ "selcollist ::= sclp scanpt nm DOT STAR",
- /* 101 */ "as ::= AS nm",
- /* 102 */ "as ::=",
- /* 103 */ "from ::=",
- /* 104 */ "from ::= FROM seltablist",
- /* 105 */ "stl_prefix ::= seltablist joinop",
- /* 106 */ "stl_prefix ::=",
- /* 107 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
- /* 108 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt",
- /* 109 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
- /* 110 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
- /* 111 */ "dbnm ::=",
- /* 112 */ "dbnm ::= DOT nm",
- /* 113 */ "fullname ::= nm",
- /* 114 */ "fullname ::= nm DOT nm",
- /* 115 */ "xfullname ::= nm",
- /* 116 */ "xfullname ::= nm DOT nm",
- /* 117 */ "xfullname ::= nm DOT nm AS nm",
- /* 118 */ "xfullname ::= nm AS nm",
- /* 119 */ "joinop ::= COMMA|JOIN",
- /* 120 */ "joinop ::= JOIN_KW JOIN",
- /* 121 */ "joinop ::= JOIN_KW nm JOIN",
- /* 122 */ "joinop ::= JOIN_KW nm nm JOIN",
- /* 123 */ "on_opt ::= ON expr",
- /* 124 */ "on_opt ::=",
- /* 125 */ "indexed_opt ::=",
- /* 126 */ "indexed_opt ::= INDEXED BY nm",
- /* 127 */ "indexed_opt ::= NOT INDEXED",
- /* 128 */ "using_opt ::= USING LP idlist RP",
- /* 129 */ "using_opt ::=",
- /* 130 */ "orderby_opt ::=",
- /* 131 */ "orderby_opt ::= ORDER BY sortlist",
- /* 132 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
- /* 133 */ "sortlist ::= expr sortorder nulls",
- /* 134 */ "sortorder ::= ASC",
- /* 135 */ "sortorder ::= DESC",
- /* 136 */ "sortorder ::=",
- /* 137 */ "nulls ::= NULLS FIRST",
- /* 138 */ "nulls ::= NULLS LAST",
- /* 139 */ "nulls ::=",
- /* 140 */ "groupby_opt ::=",
- /* 141 */ "groupby_opt ::= GROUP BY nexprlist",
- /* 142 */ "having_opt ::=",
- /* 143 */ "having_opt ::= HAVING expr",
- /* 144 */ "limit_opt ::=",
- /* 145 */ "limit_opt ::= LIMIT expr",
- /* 146 */ "limit_opt ::= LIMIT expr OFFSET expr",
- /* 147 */ "limit_opt ::= LIMIT expr COMMA expr",
- /* 148 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt",
- /* 149 */ "where_opt ::=",
- /* 150 */ "where_opt ::= WHERE expr",
- /* 151 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt",
- /* 152 */ "setlist ::= setlist COMMA nm EQ expr",
- /* 153 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
- /* 154 */ "setlist ::= nm EQ expr",
- /* 155 */ "setlist ::= LP idlist RP EQ expr",
- /* 156 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
- /* 157 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES",
- /* 158 */ "upsert ::=",
- /* 159 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt",
- /* 160 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING",
- /* 161 */ "upsert ::= ON CONFLICT DO NOTHING",
- /* 162 */ "insert_cmd ::= INSERT orconf",
- /* 163 */ "insert_cmd ::= REPLACE",
- /* 164 */ "idlist_opt ::=",
- /* 165 */ "idlist_opt ::= LP idlist RP",
- /* 166 */ "idlist ::= idlist COMMA nm",
- /* 167 */ "idlist ::= nm",
- /* 168 */ "expr ::= LP expr RP",
- /* 169 */ "expr ::= ID|INDEXED",
- /* 170 */ "expr ::= JOIN_KW",
- /* 171 */ "expr ::= nm DOT nm",
- /* 172 */ "expr ::= nm DOT nm DOT nm",
- /* 173 */ "term ::= NULL|FLOAT|BLOB",
- /* 174 */ "term ::= STRING",
- /* 175 */ "term ::= INTEGER",
- /* 176 */ "expr ::= VARIABLE",
- /* 177 */ "expr ::= expr COLLATE ID|STRING",
- /* 178 */ "expr ::= CAST LP expr AS typetoken RP",
- /* 179 */ "expr ::= ID|INDEXED LP distinct exprlist RP",
- /* 180 */ "expr ::= ID|INDEXED LP STAR RP",
- /* 181 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over",
- /* 182 */ "expr ::= ID|INDEXED LP STAR RP filter_over",
- /* 183 */ "term ::= CTIME_KW",
- /* 184 */ "expr ::= LP nexprlist COMMA expr RP",
- /* 185 */ "expr ::= expr AND expr",
- /* 186 */ "expr ::= expr OR expr",
- /* 187 */ "expr ::= expr LT|GT|GE|LE expr",
- /* 188 */ "expr ::= expr EQ|NE expr",
- /* 189 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
- /* 190 */ "expr ::= expr PLUS|MINUS expr",
- /* 191 */ "expr ::= expr STAR|SLASH|REM expr",
- /* 192 */ "expr ::= expr CONCAT expr",
- /* 193 */ "likeop ::= NOT LIKE_KW|MATCH",
- /* 194 */ "expr ::= expr likeop expr",
- /* 195 */ "expr ::= expr likeop expr ESCAPE expr",
- /* 196 */ "expr ::= expr ISNULL|NOTNULL",
- /* 197 */ "expr ::= expr NOT NULL",
- /* 198 */ "expr ::= expr IS expr",
- /* 199 */ "expr ::= expr IS NOT expr",
- /* 200 */ "expr ::= NOT expr",
- /* 201 */ "expr ::= BITNOT expr",
- /* 202 */ "expr ::= PLUS|MINUS expr",
- /* 203 */ "between_op ::= BETWEEN",
- /* 204 */ "between_op ::= NOT BETWEEN",
- /* 205 */ "expr ::= expr between_op expr AND expr",
- /* 206 */ "in_op ::= IN",
- /* 207 */ "in_op ::= NOT IN",
- /* 208 */ "expr ::= expr in_op LP exprlist RP",
- /* 209 */ "expr ::= LP select RP",
- /* 210 */ "expr ::= expr in_op LP select RP",
- /* 211 */ "expr ::= expr in_op nm dbnm paren_exprlist",
- /* 212 */ "expr ::= EXISTS LP select RP",
- /* 213 */ "expr ::= CASE case_operand case_exprlist case_else END",
- /* 214 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
- /* 215 */ "case_exprlist ::= WHEN expr THEN expr",
- /* 216 */ "case_else ::= ELSE expr",
- /* 217 */ "case_else ::=",
- /* 218 */ "case_operand ::= expr",
- /* 219 */ "case_operand ::=",
- /* 220 */ "exprlist ::=",
- /* 221 */ "nexprlist ::= nexprlist COMMA expr",
- /* 222 */ "nexprlist ::= expr",
- /* 223 */ "paren_exprlist ::=",
- /* 224 */ "paren_exprlist ::= LP exprlist RP",
- /* 225 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
- /* 226 */ "uniqueflag ::= UNIQUE",
- /* 227 */ "uniqueflag ::=",
- /* 228 */ "eidlist_opt ::=",
- /* 229 */ "eidlist_opt ::= LP eidlist RP",
- /* 230 */ "eidlist ::= eidlist COMMA nm collate sortorder",
- /* 231 */ "eidlist ::= nm collate sortorder",
- /* 232 */ "collate ::=",
- /* 233 */ "collate ::= COLLATE ID|STRING",
- /* 234 */ "cmd ::= DROP INDEX ifexists fullname",
- /* 235 */ "cmd ::= VACUUM vinto",
- /* 236 */ "cmd ::= VACUUM nm vinto",
- /* 237 */ "vinto ::= INTO expr",
- /* 238 */ "vinto ::=",
- /* 239 */ "cmd ::= PRAGMA nm dbnm",
- /* 240 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
- /* 241 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
- /* 242 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
- /* 243 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
- /* 244 */ "plus_num ::= PLUS INTEGER|FLOAT",
- /* 245 */ "minus_num ::= MINUS INTEGER|FLOAT",
- /* 246 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
- /* 247 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
- /* 248 */ "trigger_time ::= BEFORE|AFTER",
- /* 249 */ "trigger_time ::= INSTEAD OF",
- /* 250 */ "trigger_time ::=",
- /* 251 */ "trigger_event ::= DELETE|INSERT",
- /* 252 */ "trigger_event ::= UPDATE",
- /* 253 */ "trigger_event ::= UPDATE OF idlist",
- /* 254 */ "when_clause ::=",
- /* 255 */ "when_clause ::= WHEN expr",
- /* 256 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
- /* 257 */ "trigger_cmd_list ::= trigger_cmd SEMI",
- /* 258 */ "trnm ::= nm DOT nm",
- /* 259 */ "tridxby ::= INDEXED BY nm",
- /* 260 */ "tridxby ::= NOT INDEXED",
- /* 261 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
- /* 262 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
- /* 263 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
- /* 264 */ "trigger_cmd ::= scanpt select scanpt",
- /* 265 */ "expr ::= RAISE LP IGNORE RP",
- /* 266 */ "expr ::= RAISE LP raisetype COMMA nm RP",
- /* 267 */ "raisetype ::= ROLLBACK",
- /* 268 */ "raisetype ::= ABORT",
- /* 269 */ "raisetype ::= FAIL",
- /* 270 */ "cmd ::= DROP TRIGGER ifexists fullname",
- /* 271 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
- /* 272 */ "cmd ::= DETACH database_kw_opt expr",
- /* 273 */ "key_opt ::=",
- /* 274 */ "key_opt ::= KEY expr",
- /* 275 */ "cmd ::= REINDEX",
- /* 276 */ "cmd ::= REINDEX nm dbnm",
- /* 277 */ "cmd ::= ANALYZE",
- /* 278 */ "cmd ::= ANALYZE nm dbnm",
- /* 279 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
- /* 280 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
- /* 281 */ "add_column_fullname ::= fullname",
- /* 282 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
- /* 283 */ "cmd ::= create_vtab",
- /* 284 */ "cmd ::= create_vtab LP vtabarglist RP",
- /* 285 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
- /* 286 */ "vtabarg ::=",
- /* 287 */ "vtabargtoken ::= ANY",
- /* 288 */ "vtabargtoken ::= lp anylist RP",
- /* 289 */ "lp ::= LP",
- /* 290 */ "with ::= WITH wqlist",
- /* 291 */ "with ::= WITH RECURSIVE wqlist",
- /* 292 */ "wqlist ::= nm eidlist_opt AS LP select RP",
- /* 293 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
- /* 294 */ "windowdefn_list ::= windowdefn",
- /* 295 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
- /* 296 */ "windowdefn ::= nm AS LP window RP",
- /* 297 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
- /* 298 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
- /* 299 */ "window ::= ORDER BY sortlist frame_opt",
- /* 300 */ "window ::= nm ORDER BY sortlist frame_opt",
- /* 301 */ "window ::= frame_opt",
- /* 302 */ "window ::= nm frame_opt",
- /* 303 */ "frame_opt ::=",
- /* 304 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
- /* 305 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
- /* 306 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
- /* 307 */ "frame_bound_s ::= frame_bound",
- /* 308 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
- /* 309 */ "frame_bound_e ::= frame_bound",
- /* 310 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
- /* 311 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
- /* 312 */ "frame_bound ::= CURRENT ROW",
- /* 313 */ "frame_exclude_opt ::=",
- /* 314 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
- /* 315 */ "frame_exclude ::= NO OTHERS",
- /* 316 */ "frame_exclude ::= CURRENT ROW",
- /* 317 */ "frame_exclude ::= GROUP|TIES",
- /* 318 */ "window_clause ::= WINDOW windowdefn_list",
- /* 319 */ "filter_over ::= filter_clause over_clause",
- /* 320 */ "filter_over ::= over_clause",
- /* 321 */ "filter_over ::= filter_clause",
- /* 322 */ "over_clause ::= OVER LP window RP",
- /* 323 */ "over_clause ::= OVER nm",
- /* 324 */ "filter_clause ::= FILTER LP WHERE expr RP",
- /* 325 */ "input ::= cmdlist",
- /* 326 */ "cmdlist ::= cmdlist ecmd",
- /* 327 */ "cmdlist ::= ecmd",
- /* 328 */ "ecmd ::= SEMI",
- /* 329 */ "ecmd ::= cmdx SEMI",
- /* 330 */ "ecmd ::= explain cmdx SEMI",
- /* 331 */ "trans_opt ::=",
- /* 332 */ "trans_opt ::= TRANSACTION",
- /* 333 */ "trans_opt ::= TRANSACTION nm",
- /* 334 */ "savepoint_opt ::= SAVEPOINT",
- /* 335 */ "savepoint_opt ::=",
- /* 336 */ "cmd ::= create_table create_table_args",
- /* 337 */ "columnlist ::= columnlist COMMA columnname carglist",
- /* 338 */ "columnlist ::= columnname carglist",
- /* 339 */ "nm ::= ID|INDEXED",
- /* 340 */ "nm ::= STRING",
- /* 341 */ "nm ::= JOIN_KW",
- /* 342 */ "typetoken ::= typename",
- /* 343 */ "typename ::= ID|STRING",
- /* 344 */ "signed ::= plus_num",
- /* 345 */ "signed ::= minus_num",
- /* 346 */ "carglist ::= carglist ccons",
- /* 347 */ "carglist ::=",
- /* 348 */ "ccons ::= NULL onconf",
- /* 349 */ "ccons ::= GENERATED ALWAYS AS generated",
- /* 350 */ "ccons ::= AS generated",
- /* 351 */ "conslist_opt ::= COMMA conslist",
- /* 352 */ "conslist ::= conslist tconscomma tcons",
- /* 353 */ "conslist ::= tcons",
- /* 354 */ "tconscomma ::=",
- /* 355 */ "defer_subclause_opt ::= defer_subclause",
- /* 356 */ "resolvetype ::= raisetype",
- /* 357 */ "selectnowith ::= oneselect",
- /* 358 */ "oneselect ::= values",
- /* 359 */ "sclp ::= selcollist COMMA",
- /* 360 */ "as ::= ID|STRING",
- /* 361 */ "expr ::= term",
- /* 362 */ "likeop ::= LIKE_KW|MATCH",
- /* 363 */ "exprlist ::= nexprlist",
- /* 364 */ "nmnum ::= plus_num",
- /* 365 */ "nmnum ::= nm",
- /* 366 */ "nmnum ::= ON",
- /* 367 */ "nmnum ::= DELETE",
- /* 368 */ "nmnum ::= DEFAULT",
- /* 369 */ "plus_num ::= INTEGER|FLOAT",
- /* 370 */ "foreach_clause ::=",
- /* 371 */ "foreach_clause ::= FOR EACH ROW",
- /* 372 */ "trnm ::= nm",
- /* 373 */ "tridxby ::=",
- /* 374 */ "database_kw_opt ::= DATABASE",
- /* 375 */ "database_kw_opt ::=",
- /* 376 */ "kwcolumn_opt ::=",
- /* 377 */ "kwcolumn_opt ::= COLUMNKW",
- /* 378 */ "vtabarglist ::= vtabarg",
- /* 379 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
- /* 380 */ "vtabarg ::= vtabarg vtabargtoken",
- /* 381 */ "anylist ::=",
- /* 382 */ "anylist ::= anylist LP anylist RP",
- /* 383 */ "anylist ::= anylist ANY",
- /* 384 */ "with ::=",
+ /*  21 */ "table_option_set ::=",
+ /*  22 */ "table_option_set ::= table_option_set COMMA table_option",
+ /*  23 */ "table_option ::= WITHOUT nm",
+ /*  24 */ "table_option ::= nm",
+ /*  25 */ "columnname ::= nm typetoken",
+ /*  26 */ "typetoken ::=",
+ /*  27 */ "typetoken ::= typename LP signed RP",
+ /*  28 */ "typetoken ::= typename LP signed COMMA signed RP",
+ /*  29 */ "typename ::= typename ID|STRING",
+ /*  30 */ "scanpt ::=",
+ /*  31 */ "scantok ::=",
+ /*  32 */ "ccons ::= CONSTRAINT nm",
+ /*  33 */ "ccons ::= DEFAULT scantok term",
+ /*  34 */ "ccons ::= DEFAULT LP expr RP",
+ /*  35 */ "ccons ::= DEFAULT PLUS scantok term",
+ /*  36 */ "ccons ::= DEFAULT MINUS scantok term",
+ /*  37 */ "ccons ::= DEFAULT scantok ID|INDEXED",
+ /*  38 */ "ccons ::= NOT NULL onconf",
+ /*  39 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
+ /*  40 */ "ccons ::= UNIQUE onconf",
+ /*  41 */ "ccons ::= CHECK LP expr RP",
+ /*  42 */ "ccons ::= REFERENCES nm eidlist_opt refargs",
+ /*  43 */ "ccons ::= defer_subclause",
+ /*  44 */ "ccons ::= COLLATE ID|STRING",
+ /*  45 */ "generated ::= LP expr RP",
+ /*  46 */ "generated ::= LP expr RP ID",
+ /*  47 */ "autoinc ::=",
+ /*  48 */ "autoinc ::= AUTOINCR",
+ /*  49 */ "refargs ::=",
+ /*  50 */ "refargs ::= refargs refarg",
+ /*  51 */ "refarg ::= MATCH nm",
+ /*  52 */ "refarg ::= ON INSERT refact",
+ /*  53 */ "refarg ::= ON DELETE refact",
+ /*  54 */ "refarg ::= ON UPDATE refact",
+ /*  55 */ "refact ::= SET NULL",
+ /*  56 */ "refact ::= SET DEFAULT",
+ /*  57 */ "refact ::= CASCADE",
+ /*  58 */ "refact ::= RESTRICT",
+ /*  59 */ "refact ::= NO ACTION",
+ /*  60 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
+ /*  61 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
+ /*  62 */ "init_deferred_pred_opt ::=",
+ /*  63 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
+ /*  64 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
+ /*  65 */ "conslist_opt ::=",
+ /*  66 */ "tconscomma ::= COMMA",
+ /*  67 */ "tcons ::= CONSTRAINT nm",
+ /*  68 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf",
+ /*  69 */ "tcons ::= UNIQUE LP sortlist RP onconf",
+ /*  70 */ "tcons ::= CHECK LP expr RP onconf",
+ /*  71 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt",
+ /*  72 */ "defer_subclause_opt ::=",
+ /*  73 */ "onconf ::=",
+ /*  74 */ "onconf ::= ON CONFLICT resolvetype",
+ /*  75 */ "orconf ::=",
+ /*  76 */ "orconf ::= OR resolvetype",
+ /*  77 */ "resolvetype ::= IGNORE",
+ /*  78 */ "resolvetype ::= REPLACE",
+ /*  79 */ "cmd ::= DROP TABLE ifexists fullname",
+ /*  80 */ "ifexists ::= IF EXISTS",
+ /*  81 */ "ifexists ::=",
+ /*  82 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select",
+ /*  83 */ "cmd ::= DROP VIEW ifexists fullname",
+ /*  84 */ "cmd ::= select",
+ /*  85 */ "select ::= WITH wqlist selectnowith",
+ /*  86 */ "select ::= WITH RECURSIVE wqlist selectnowith",
+ /*  87 */ "select ::= selectnowith",
+ /*  88 */ "selectnowith ::= selectnowith multiselect_op oneselect",
+ /*  89 */ "multiselect_op ::= UNION",
+ /*  90 */ "multiselect_op ::= UNION ALL",
+ /*  91 */ "multiselect_op ::= EXCEPT|INTERSECT",
+ /*  92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
+ /*  93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
+ /*  94 */ "values ::= VALUES LP nexprlist RP",
+ /*  95 */ "values ::= values COMMA LP nexprlist RP",
+ /*  96 */ "distinct ::= DISTINCT",
+ /*  97 */ "distinct ::= ALL",
+ /*  98 */ "distinct ::=",
+ /*  99 */ "sclp ::=",
+ /* 100 */ "selcollist ::= sclp scanpt expr scanpt as",
+ /* 101 */ "selcollist ::= sclp scanpt STAR",
+ /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR",
+ /* 103 */ "as ::= AS nm",
+ /* 104 */ "as ::=",
+ /* 105 */ "from ::=",
+ /* 106 */ "from ::= FROM seltablist",
+ /* 107 */ "stl_prefix ::= seltablist joinop",
+ /* 108 */ "stl_prefix ::=",
+ /* 109 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
+ /* 110 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt",
+ /* 111 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
+ /* 112 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
+ /* 113 */ "dbnm ::=",
+ /* 114 */ "dbnm ::= DOT nm",
+ /* 115 */ "fullname ::= nm",
+ /* 116 */ "fullname ::= nm DOT nm",
+ /* 117 */ "xfullname ::= nm",
+ /* 118 */ "xfullname ::= nm DOT nm",
+ /* 119 */ "xfullname ::= nm DOT nm AS nm",
+ /* 120 */ "xfullname ::= nm AS nm",
+ /* 121 */ "joinop ::= COMMA|JOIN",
+ /* 122 */ "joinop ::= JOIN_KW JOIN",
+ /* 123 */ "joinop ::= JOIN_KW nm JOIN",
+ /* 124 */ "joinop ::= JOIN_KW nm nm JOIN",
+ /* 125 */ "on_opt ::= ON expr",
+ /* 126 */ "on_opt ::=",
+ /* 127 */ "indexed_opt ::=",
+ /* 128 */ "indexed_opt ::= INDEXED BY nm",
+ /* 129 */ "indexed_opt ::= NOT INDEXED",
+ /* 130 */ "using_opt ::= USING LP idlist RP",
+ /* 131 */ "using_opt ::=",
+ /* 132 */ "orderby_opt ::=",
+ /* 133 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
+ /* 135 */ "sortlist ::= expr sortorder nulls",
+ /* 136 */ "sortorder ::= ASC",
+ /* 137 */ "sortorder ::= DESC",
+ /* 138 */ "sortorder ::=",
+ /* 139 */ "nulls ::= NULLS FIRST",
+ /* 140 */ "nulls ::= NULLS LAST",
+ /* 141 */ "nulls ::=",
+ /* 142 */ "groupby_opt ::=",
+ /* 143 */ "groupby_opt ::= GROUP BY nexprlist",
+ /* 144 */ "having_opt ::=",
+ /* 145 */ "having_opt ::= HAVING expr",
+ /* 146 */ "limit_opt ::=",
+ /* 147 */ "limit_opt ::= LIMIT expr",
+ /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr",
+ /* 149 */ "limit_opt ::= LIMIT expr COMMA expr",
+ /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
+ /* 151 */ "where_opt ::=",
+ /* 152 */ "where_opt ::= WHERE expr",
+ /* 153 */ "where_opt_ret ::=",
+ /* 154 */ "where_opt_ret ::= WHERE expr",
+ /* 155 */ "where_opt_ret ::= RETURNING selcollist",
+ /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
+ /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
+ /* 158 */ "setlist ::= setlist COMMA nm EQ expr",
+ /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
+ /* 160 */ "setlist ::= nm EQ expr",
+ /* 161 */ "setlist ::= LP idlist RP EQ expr",
+ /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
+ /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
+ /* 164 */ "upsert ::=",
+ /* 165 */ "upsert ::= RETURNING selcollist",
+ /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
+ /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
+ /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning",
+ /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
+ /* 170 */ "returning ::= RETURNING selcollist",
+ /* 171 */ "insert_cmd ::= INSERT orconf",
+ /* 172 */ "insert_cmd ::= REPLACE",
+ /* 173 */ "idlist_opt ::=",
+ /* 174 */ "idlist_opt ::= LP idlist RP",
+ /* 175 */ "idlist ::= idlist COMMA nm",
+ /* 176 */ "idlist ::= nm",
+ /* 177 */ "expr ::= LP expr RP",
+ /* 178 */ "expr ::= ID|INDEXED",
+ /* 179 */ "expr ::= JOIN_KW",
+ /* 180 */ "expr ::= nm DOT nm",
+ /* 181 */ "expr ::= nm DOT nm DOT nm",
+ /* 182 */ "term ::= NULL|FLOAT|BLOB",
+ /* 183 */ "term ::= STRING",
+ /* 184 */ "term ::= INTEGER",
+ /* 185 */ "expr ::= VARIABLE",
+ /* 186 */ "expr ::= expr COLLATE ID|STRING",
+ /* 187 */ "expr ::= CAST LP expr AS typetoken RP",
+ /* 188 */ "expr ::= ID|INDEXED LP distinct exprlist RP",
+ /* 189 */ "expr ::= ID|INDEXED LP STAR RP",
+ /* 190 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over",
+ /* 191 */ "expr ::= ID|INDEXED LP STAR RP filter_over",
+ /* 192 */ "term ::= CTIME_KW",
+ /* 193 */ "expr ::= LP nexprlist COMMA expr RP",
+ /* 194 */ "expr ::= expr AND expr",
+ /* 195 */ "expr ::= expr OR expr",
+ /* 196 */ "expr ::= expr LT|GT|GE|LE expr",
+ /* 197 */ "expr ::= expr EQ|NE expr",
+ /* 198 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
+ /* 199 */ "expr ::= expr PLUS|MINUS expr",
+ /* 200 */ "expr ::= expr STAR|SLASH|REM expr",
+ /* 201 */ "expr ::= expr CONCAT expr",
+ /* 202 */ "likeop ::= NOT LIKE_KW|MATCH",
+ /* 203 */ "expr ::= expr likeop expr",
+ /* 204 */ "expr ::= expr likeop expr ESCAPE expr",
+ /* 205 */ "expr ::= expr ISNULL|NOTNULL",
+ /* 206 */ "expr ::= expr NOT NULL",
+ /* 207 */ "expr ::= expr IS expr",
+ /* 208 */ "expr ::= expr IS NOT expr",
+ /* 209 */ "expr ::= NOT expr",
+ /* 210 */ "expr ::= BITNOT expr",
+ /* 211 */ "expr ::= PLUS|MINUS expr",
+ /* 212 */ "between_op ::= BETWEEN",
+ /* 213 */ "between_op ::= NOT BETWEEN",
+ /* 214 */ "expr ::= expr between_op expr AND expr",
+ /* 215 */ "in_op ::= IN",
+ /* 216 */ "in_op ::= NOT IN",
+ /* 217 */ "expr ::= expr in_op LP exprlist RP",
+ /* 218 */ "expr ::= LP select RP",
+ /* 219 */ "expr ::= expr in_op LP select RP",
+ /* 220 */ "expr ::= expr in_op nm dbnm paren_exprlist",
+ /* 221 */ "expr ::= EXISTS LP select RP",
+ /* 222 */ "expr ::= CASE case_operand case_exprlist case_else END",
+ /* 223 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
+ /* 224 */ "case_exprlist ::= WHEN expr THEN expr",
+ /* 225 */ "case_else ::= ELSE expr",
+ /* 226 */ "case_else ::=",
+ /* 227 */ "case_operand ::= expr",
+ /* 228 */ "case_operand ::=",
+ /* 229 */ "exprlist ::=",
+ /* 230 */ "nexprlist ::= nexprlist COMMA expr",
+ /* 231 */ "nexprlist ::= expr",
+ /* 232 */ "paren_exprlist ::=",
+ /* 233 */ "paren_exprlist ::= LP exprlist RP",
+ /* 234 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
+ /* 235 */ "uniqueflag ::= UNIQUE",
+ /* 236 */ "uniqueflag ::=",
+ /* 237 */ "eidlist_opt ::=",
+ /* 238 */ "eidlist_opt ::= LP eidlist RP",
+ /* 239 */ "eidlist ::= eidlist COMMA nm collate sortorder",
+ /* 240 */ "eidlist ::= nm collate sortorder",
+ /* 241 */ "collate ::=",
+ /* 242 */ "collate ::= COLLATE ID|STRING",
+ /* 243 */ "cmd ::= DROP INDEX ifexists fullname",
+ /* 244 */ "cmd ::= VACUUM vinto",
+ /* 245 */ "cmd ::= VACUUM nm vinto",
+ /* 246 */ "vinto ::= INTO expr",
+ /* 247 */ "vinto ::=",
+ /* 248 */ "cmd ::= PRAGMA nm dbnm",
+ /* 249 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
+ /* 250 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
+ /* 251 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
+ /* 252 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
+ /* 253 */ "plus_num ::= PLUS INTEGER|FLOAT",
+ /* 254 */ "minus_num ::= MINUS INTEGER|FLOAT",
+ /* 255 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
+ /* 256 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
+ /* 257 */ "trigger_time ::= BEFORE|AFTER",
+ /* 258 */ "trigger_time ::= INSTEAD OF",
+ /* 259 */ "trigger_time ::=",
+ /* 260 */ "trigger_event ::= DELETE|INSERT",
+ /* 261 */ "trigger_event ::= UPDATE",
+ /* 262 */ "trigger_event ::= UPDATE OF idlist",
+ /* 263 */ "when_clause ::=",
+ /* 264 */ "when_clause ::= WHEN expr",
+ /* 265 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
+ /* 266 */ "trigger_cmd_list ::= trigger_cmd SEMI",
+ /* 267 */ "trnm ::= nm DOT nm",
+ /* 268 */ "tridxby ::= INDEXED BY nm",
+ /* 269 */ "tridxby ::= NOT INDEXED",
+ /* 270 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
+ /* 271 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
+ /* 272 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
+ /* 273 */ "trigger_cmd ::= scanpt select scanpt",
+ /* 274 */ "expr ::= RAISE LP IGNORE RP",
+ /* 275 */ "expr ::= RAISE LP raisetype COMMA nm RP",
+ /* 276 */ "raisetype ::= ROLLBACK",
+ /* 277 */ "raisetype ::= ABORT",
+ /* 278 */ "raisetype ::= FAIL",
+ /* 279 */ "cmd ::= DROP TRIGGER ifexists fullname",
+ /* 280 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
+ /* 281 */ "cmd ::= DETACH database_kw_opt expr",
+ /* 282 */ "key_opt ::=",
+ /* 283 */ "key_opt ::= KEY expr",
+ /* 284 */ "cmd ::= REINDEX",
+ /* 285 */ "cmd ::= REINDEX nm dbnm",
+ /* 286 */ "cmd ::= ANALYZE",
+ /* 287 */ "cmd ::= ANALYZE nm dbnm",
+ /* 288 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
+ /* 289 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
+ /* 290 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
+ /* 291 */ "add_column_fullname ::= fullname",
+ /* 292 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
+ /* 293 */ "cmd ::= create_vtab",
+ /* 294 */ "cmd ::= create_vtab LP vtabarglist RP",
+ /* 295 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
+ /* 296 */ "vtabarg ::=",
+ /* 297 */ "vtabargtoken ::= ANY",
+ /* 298 */ "vtabargtoken ::= lp anylist RP",
+ /* 299 */ "lp ::= LP",
+ /* 300 */ "with ::= WITH wqlist",
+ /* 301 */ "with ::= WITH RECURSIVE wqlist",
+ /* 302 */ "wqas ::= AS",
+ /* 303 */ "wqas ::= AS MATERIALIZED",
+ /* 304 */ "wqas ::= AS NOT MATERIALIZED",
+ /* 305 */ "wqitem ::= nm eidlist_opt wqas LP select RP",
+ /* 306 */ "wqlist ::= wqitem",
+ /* 307 */ "wqlist ::= wqlist COMMA wqitem",
+ /* 308 */ "windowdefn_list ::= windowdefn",
+ /* 309 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
+ /* 310 */ "windowdefn ::= nm AS LP window RP",
+ /* 311 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
+ /* 312 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
+ /* 313 */ "window ::= ORDER BY sortlist frame_opt",
+ /* 314 */ "window ::= nm ORDER BY sortlist frame_opt",
+ /* 315 */ "window ::= frame_opt",
+ /* 316 */ "window ::= nm frame_opt",
+ /* 317 */ "frame_opt ::=",
+ /* 318 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
+ /* 319 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
+ /* 320 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
+ /* 321 */ "frame_bound_s ::= frame_bound",
+ /* 322 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
+ /* 323 */ "frame_bound_e ::= frame_bound",
+ /* 324 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
+ /* 325 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
+ /* 326 */ "frame_bound ::= CURRENT ROW",
+ /* 327 */ "frame_exclude_opt ::=",
+ /* 328 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
+ /* 329 */ "frame_exclude ::= NO OTHERS",
+ /* 330 */ "frame_exclude ::= CURRENT ROW",
+ /* 331 */ "frame_exclude ::= GROUP|TIES",
+ /* 332 */ "window_clause ::= WINDOW windowdefn_list",
+ /* 333 */ "filter_over ::= filter_clause over_clause",
+ /* 334 */ "filter_over ::= over_clause",
+ /* 335 */ "filter_over ::= filter_clause",
+ /* 336 */ "over_clause ::= OVER LP window RP",
+ /* 337 */ "over_clause ::= OVER nm",
+ /* 338 */ "filter_clause ::= FILTER LP WHERE expr RP",
+ /* 339 */ "input ::= cmdlist",
+ /* 340 */ "cmdlist ::= cmdlist ecmd",
+ /* 341 */ "cmdlist ::= ecmd",
+ /* 342 */ "ecmd ::= SEMI",
+ /* 343 */ "ecmd ::= cmdx SEMI",
+ /* 344 */ "ecmd ::= explain cmdx SEMI",
+ /* 345 */ "trans_opt ::=",
+ /* 346 */ "trans_opt ::= TRANSACTION",
+ /* 347 */ "trans_opt ::= TRANSACTION nm",
+ /* 348 */ "savepoint_opt ::= SAVEPOINT",
+ /* 349 */ "savepoint_opt ::=",
+ /* 350 */ "cmd ::= create_table create_table_args",
+ /* 351 */ "table_option_set ::= table_option",
+ /* 352 */ "columnlist ::= columnlist COMMA columnname carglist",
+ /* 353 */ "columnlist ::= columnname carglist",
+ /* 354 */ "nm ::= ID|INDEXED",
+ /* 355 */ "nm ::= STRING",
+ /* 356 */ "nm ::= JOIN_KW",
+ /* 357 */ "typetoken ::= typename",
+ /* 358 */ "typename ::= ID|STRING",
+ /* 359 */ "signed ::= plus_num",
+ /* 360 */ "signed ::= minus_num",
+ /* 361 */ "carglist ::= carglist ccons",
+ /* 362 */ "carglist ::=",
+ /* 363 */ "ccons ::= NULL onconf",
+ /* 364 */ "ccons ::= GENERATED ALWAYS AS generated",
+ /* 365 */ "ccons ::= AS generated",
+ /* 366 */ "conslist_opt ::= COMMA conslist",
+ /* 367 */ "conslist ::= conslist tconscomma tcons",
+ /* 368 */ "conslist ::= tcons",
+ /* 369 */ "tconscomma ::=",
+ /* 370 */ "defer_subclause_opt ::= defer_subclause",
+ /* 371 */ "resolvetype ::= raisetype",
+ /* 372 */ "selectnowith ::= oneselect",
+ /* 373 */ "oneselect ::= values",
+ /* 374 */ "sclp ::= selcollist COMMA",
+ /* 375 */ "as ::= ID|STRING",
+ /* 376 */ "returning ::=",
+ /* 377 */ "expr ::= term",
+ /* 378 */ "likeop ::= LIKE_KW|MATCH",
+ /* 379 */ "exprlist ::= nexprlist",
+ /* 380 */ "nmnum ::= plus_num",
+ /* 381 */ "nmnum ::= nm",
+ /* 382 */ "nmnum ::= ON",
+ /* 383 */ "nmnum ::= DELETE",
+ /* 384 */ "nmnum ::= DEFAULT",
+ /* 385 */ "plus_num ::= INTEGER|FLOAT",
+ /* 386 */ "foreach_clause ::=",
+ /* 387 */ "foreach_clause ::= FOR EACH ROW",
+ /* 388 */ "trnm ::= nm",
+ /* 389 */ "tridxby ::=",
+ /* 390 */ "database_kw_opt ::= DATABASE",
+ /* 391 */ "database_kw_opt ::=",
+ /* 392 */ "kwcolumn_opt ::=",
+ /* 393 */ "kwcolumn_opt ::= COLUMNKW",
+ /* 394 */ "vtabarglist ::= vtabarg",
+ /* 395 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
+ /* 396 */ "vtabarg ::= vtabarg vtabargtoken",
+ /* 397 */ "anylist ::=",
+ /* 398 */ "anylist ::= anylist LP anylist RP",
+ /* 399 */ "anylist ::= anylist ANY",
+ /* 400 */ "with ::=",
 };
 #endif /* NDEBUG */
 
@@ -157095,98 +161762,99 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 200: /* select */
-    case 234: /* selectnowith */
-    case 235: /* oneselect */
-    case 247: /* values */
+    case 203: /* select */
+    case 238: /* selectnowith */
+    case 239: /* oneselect */
+    case 251: /* values */
 {
-sqlite3SelectDelete(pParse->db, (yypminor->yy539));
-}
-      break;
-    case 211: /* term */
-    case 212: /* expr */
-    case 241: /* where_opt */
-    case 243: /* having_opt */
-    case 255: /* on_opt */
-    case 271: /* case_operand */
-    case 273: /* case_else */
-    case 276: /* vinto */
-    case 283: /* when_clause */
-    case 288: /* key_opt */
-    case 302: /* filter_clause */
+sqlite3SelectDelete(pParse->db, (yypminor->yy303));
+}
+      break;
+    case 215: /* term */
+    case 216: /* expr */
+    case 245: /* where_opt */
+    case 247: /* having_opt */
+    case 259: /* on_opt */
+    case 266: /* where_opt_ret */
+    case 277: /* case_operand */
+    case 279: /* case_else */
+    case 282: /* vinto */
+    case 289: /* when_clause */
+    case 294: /* key_opt */
+    case 310: /* filter_clause */
 {
-sqlite3ExprDelete(pParse->db, (yypminor->yy202));
-}
-      break;
-    case 216: /* eidlist_opt */
-    case 226: /* sortlist */
-    case 227: /* eidlist */
-    case 239: /* selcollist */
-    case 242: /* groupby_opt */
-    case 244: /* orderby_opt */
-    case 248: /* nexprlist */
-    case 249: /* sclp */
-    case 257: /* exprlist */
-    case 262: /* setlist */
-    case 270: /* paren_exprlist */
-    case 272: /* case_exprlist */
-    case 301: /* part_opt */
+sqlite3ExprDelete(pParse->db, (yypminor->yy626));
+}
+      break;
+    case 220: /* eidlist_opt */
+    case 230: /* sortlist */
+    case 231: /* eidlist */
+    case 243: /* selcollist */
+    case 246: /* groupby_opt */
+    case 248: /* orderby_opt */
+    case 252: /* nexprlist */
+    case 253: /* sclp */
+    case 261: /* exprlist */
+    case 267: /* setlist */
+    case 276: /* paren_exprlist */
+    case 278: /* case_exprlist */
+    case 309: /* part_opt */
 {
-sqlite3ExprListDelete(pParse->db, (yypminor->yy242));
+sqlite3ExprListDelete(pParse->db, (yypminor->yy562));
 }
       break;
-    case 233: /* fullname */
-    case 240: /* from */
-    case 251: /* seltablist */
-    case 252: /* stl_prefix */
-    case 258: /* xfullname */
+    case 237: /* fullname */
+    case 244: /* from */
+    case 255: /* seltablist */
+    case 256: /* stl_prefix */
+    case 262: /* xfullname */
 {
-sqlite3SrcListDelete(pParse->db, (yypminor->yy47));
+sqlite3SrcListDelete(pParse->db, (yypminor->yy607));
 }
       break;
-    case 236: /* wqlist */
+    case 240: /* wqlist */
 {
-sqlite3WithDelete(pParse->db, (yypminor->yy131));
+sqlite3WithDelete(pParse->db, (yypminor->yy43));
 }
       break;
-    case 246: /* window_clause */
-    case 297: /* windowdefn_list */
+    case 250: /* window_clause */
+    case 305: /* windowdefn_list */
 {
-sqlite3WindowListDelete(pParse->db, (yypminor->yy303));
+sqlite3WindowListDelete(pParse->db, (yypminor->yy375));
 }
       break;
-    case 256: /* using_opt */
-    case 259: /* idlist */
-    case 264: /* idlist_opt */
+    case 260: /* using_opt */
+    case 263: /* idlist */
+    case 269: /* idlist_opt */
 {
-sqlite3IdListDelete(pParse->db, (yypminor->yy600));
+sqlite3IdListDelete(pParse->db, (yypminor->yy240));
 }
       break;
-    case 266: /* filter_over */
-    case 298: /* windowdefn */
-    case 299: /* window */
-    case 300: /* frame_opt */
-    case 303: /* over_clause */
+    case 272: /* filter_over */
+    case 306: /* windowdefn */
+    case 307: /* window */
+    case 308: /* frame_opt */
+    case 311: /* over_clause */
 {
-sqlite3WindowDelete(pParse->db, (yypminor->yy303));
+sqlite3WindowDelete(pParse->db, (yypminor->yy375));
 }
       break;
-    case 279: /* trigger_cmd_list */
-    case 284: /* trigger_cmd */
+    case 285: /* trigger_cmd_list */
+    case 290: /* trigger_cmd */
 {
-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy447));
+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy95));
 }
       break;
-    case 281: /* trigger_event */
+    case 287: /* trigger_event */
 {
-sqlite3IdListDelete(pParse->db, (yypminor->yy230).b);
+sqlite3IdListDelete(pParse->db, (yypminor->yy570).b);
 }
       break;
-    case 305: /* frame_bound */
-    case 306: /* frame_bound_s */
-    case 307: /* frame_bound_e */
+    case 313: /* frame_bound */
+    case 314: /* frame_bound_s */
+    case 315: /* frame_bound_e */
 {
-sqlite3ExprDelete(pParse->db, (yypminor->yy77).pExpr);
+sqlite3ExprDelete(pParse->db, (yypminor->yy81).pExpr);
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -157477,391 +162145,407 @@ static void yy_shift(
 /* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
 ** of that rule */
 static const YYCODETYPE yyRuleInfoLhs[] = {
-   185,  /* (0) explain ::= EXPLAIN */
-   185,  /* (1) explain ::= EXPLAIN QUERY PLAN */
-   184,  /* (2) cmdx ::= cmd */
-   186,  /* (3) cmd ::= BEGIN transtype trans_opt */
-   187,  /* (4) transtype ::= */
-   187,  /* (5) transtype ::= DEFERRED */
-   187,  /* (6) transtype ::= IMMEDIATE */
-   187,  /* (7) transtype ::= EXCLUSIVE */
-   186,  /* (8) cmd ::= COMMIT|END trans_opt */
-   186,  /* (9) cmd ::= ROLLBACK trans_opt */
-   186,  /* (10) cmd ::= SAVEPOINT nm */
-   186,  /* (11) cmd ::= RELEASE savepoint_opt nm */
-   186,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
-   191,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
-   193,  /* (14) createkw ::= CREATE */
-   195,  /* (15) ifnotexists ::= */
-   195,  /* (16) ifnotexists ::= IF NOT EXISTS */
-   194,  /* (17) temp ::= TEMP */
-   194,  /* (18) temp ::= */
-   192,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
-   192,  /* (20) create_table_args ::= AS select */
-   199,  /* (21) table_options ::= */
-   199,  /* (22) table_options ::= WITHOUT nm */
-   201,  /* (23) columnname ::= nm typetoken */
-   203,  /* (24) typetoken ::= */
-   203,  /* (25) typetoken ::= typename LP signed RP */
-   203,  /* (26) typetoken ::= typename LP signed COMMA signed RP */
-   204,  /* (27) typename ::= typename ID|STRING */
-   208,  /* (28) scanpt ::= */
-   209,  /* (29) scantok ::= */
-   210,  /* (30) ccons ::= CONSTRAINT nm */
-   210,  /* (31) ccons ::= DEFAULT scantok term */
-   210,  /* (32) ccons ::= DEFAULT LP expr RP */
-   210,  /* (33) ccons ::= DEFAULT PLUS scantok term */
-   210,  /* (34) ccons ::= DEFAULT MINUS scantok term */
-   210,  /* (35) ccons ::= DEFAULT scantok ID|INDEXED */
-   210,  /* (36) ccons ::= NOT NULL onconf */
-   210,  /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
-   210,  /* (38) ccons ::= UNIQUE onconf */
-   210,  /* (39) ccons ::= CHECK LP expr RP */
-   210,  /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
-   210,  /* (41) ccons ::= defer_subclause */
-   210,  /* (42) ccons ::= COLLATE ID|STRING */
-   219,  /* (43) generated ::= LP expr RP */
-   219,  /* (44) generated ::= LP expr RP ID */
-   215,  /* (45) autoinc ::= */
-   215,  /* (46) autoinc ::= AUTOINCR */
-   217,  /* (47) refargs ::= */
-   217,  /* (48) refargs ::= refargs refarg */
-   220,  /* (49) refarg ::= MATCH nm */
-   220,  /* (50) refarg ::= ON INSERT refact */
-   220,  /* (51) refarg ::= ON DELETE refact */
-   220,  /* (52) refarg ::= ON UPDATE refact */
-   221,  /* (53) refact ::= SET NULL */
-   221,  /* (54) refact ::= SET DEFAULT */
-   221,  /* (55) refact ::= CASCADE */
-   221,  /* (56) refact ::= RESTRICT */
-   221,  /* (57) refact ::= NO ACTION */
-   218,  /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-   218,  /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-   222,  /* (60) init_deferred_pred_opt ::= */
-   222,  /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
-   222,  /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-   198,  /* (63) conslist_opt ::= */
-   224,  /* (64) tconscomma ::= COMMA */
-   225,  /* (65) tcons ::= CONSTRAINT nm */
-   225,  /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-   225,  /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
-   225,  /* (68) tcons ::= CHECK LP expr RP onconf */
-   225,  /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
-   228,  /* (70) defer_subclause_opt ::= */
-   213,  /* (71) onconf ::= */
-   213,  /* (72) onconf ::= ON CONFLICT resolvetype */
-   229,  /* (73) orconf ::= */
-   229,  /* (74) orconf ::= OR resolvetype */
-   230,  /* (75) resolvetype ::= IGNORE */
-   230,  /* (76) resolvetype ::= REPLACE */
-   186,  /* (77) cmd ::= DROP TABLE ifexists fullname */
-   232,  /* (78) ifexists ::= IF EXISTS */
-   232,  /* (79) ifexists ::= */
-   186,  /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
-   186,  /* (81) cmd ::= DROP VIEW ifexists fullname */
-   186,  /* (82) cmd ::= select */
-   200,  /* (83) select ::= WITH wqlist selectnowith */
-   200,  /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
-   200,  /* (85) select ::= selectnowith */
-   234,  /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
-   237,  /* (87) multiselect_op ::= UNION */
-   237,  /* (88) multiselect_op ::= UNION ALL */
-   237,  /* (89) multiselect_op ::= EXCEPT|INTERSECT */
-   235,  /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
-   235,  /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-   247,  /* (92) values ::= VALUES LP nexprlist RP */
-   247,  /* (93) values ::= values COMMA LP nexprlist RP */
-   238,  /* (94) distinct ::= DISTINCT */
-   238,  /* (95) distinct ::= ALL */
-   238,  /* (96) distinct ::= */
-   249,  /* (97) sclp ::= */
-   239,  /* (98) selcollist ::= sclp scanpt expr scanpt as */
-   239,  /* (99) selcollist ::= sclp scanpt STAR */
-   239,  /* (100) selcollist ::= sclp scanpt nm DOT STAR */
-   250,  /* (101) as ::= AS nm */
-   250,  /* (102) as ::= */
-   240,  /* (103) from ::= */
-   240,  /* (104) from ::= FROM seltablist */
-   252,  /* (105) stl_prefix ::= seltablist joinop */
-   252,  /* (106) stl_prefix ::= */
-   251,  /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
-   251,  /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
-   251,  /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
-   251,  /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
-   196,  /* (111) dbnm ::= */
-   196,  /* (112) dbnm ::= DOT nm */
-   233,  /* (113) fullname ::= nm */
-   233,  /* (114) fullname ::= nm DOT nm */
-   258,  /* (115) xfullname ::= nm */
-   258,  /* (116) xfullname ::= nm DOT nm */
-   258,  /* (117) xfullname ::= nm DOT nm AS nm */
-   258,  /* (118) xfullname ::= nm AS nm */
-   253,  /* (119) joinop ::= COMMA|JOIN */
-   253,  /* (120) joinop ::= JOIN_KW JOIN */
-   253,  /* (121) joinop ::= JOIN_KW nm JOIN */
-   253,  /* (122) joinop ::= JOIN_KW nm nm JOIN */
-   255,  /* (123) on_opt ::= ON expr */
-   255,  /* (124) on_opt ::= */
-   254,  /* (125) indexed_opt ::= */
-   254,  /* (126) indexed_opt ::= INDEXED BY nm */
-   254,  /* (127) indexed_opt ::= NOT INDEXED */
-   256,  /* (128) using_opt ::= USING LP idlist RP */
-   256,  /* (129) using_opt ::= */
-   244,  /* (130) orderby_opt ::= */
-   244,  /* (131) orderby_opt ::= ORDER BY sortlist */
-   226,  /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
-   226,  /* (133) sortlist ::= expr sortorder nulls */
-   214,  /* (134) sortorder ::= ASC */
-   214,  /* (135) sortorder ::= DESC */
-   214,  /* (136) sortorder ::= */
-   260,  /* (137) nulls ::= NULLS FIRST */
-   260,  /* (138) nulls ::= NULLS LAST */
-   260,  /* (139) nulls ::= */
-   242,  /* (140) groupby_opt ::= */
-   242,  /* (141) groupby_opt ::= GROUP BY nexprlist */
-   243,  /* (142) having_opt ::= */
-   243,  /* (143) having_opt ::= HAVING expr */
-   245,  /* (144) limit_opt ::= */
-   245,  /* (145) limit_opt ::= LIMIT expr */
-   245,  /* (146) limit_opt ::= LIMIT expr OFFSET expr */
-   245,  /* (147) limit_opt ::= LIMIT expr COMMA expr */
-   186,  /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
-   241,  /* (149) where_opt ::= */
-   241,  /* (150) where_opt ::= WHERE expr */
-   186,  /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
-   262,  /* (152) setlist ::= setlist COMMA nm EQ expr */
-   262,  /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   262,  /* (154) setlist ::= nm EQ expr */
-   262,  /* (155) setlist ::= LP idlist RP EQ expr */
-   186,  /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   186,  /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
-   265,  /* (158) upsert ::= */
-   265,  /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
-   265,  /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
-   265,  /* (161) upsert ::= ON CONFLICT DO NOTHING */
-   263,  /* (162) insert_cmd ::= INSERT orconf */
-   263,  /* (163) insert_cmd ::= REPLACE */
-   264,  /* (164) idlist_opt ::= */
-   264,  /* (165) idlist_opt ::= LP idlist RP */
-   259,  /* (166) idlist ::= idlist COMMA nm */
-   259,  /* (167) idlist ::= nm */
-   212,  /* (168) expr ::= LP expr RP */
-   212,  /* (169) expr ::= ID|INDEXED */
-   212,  /* (170) expr ::= JOIN_KW */
-   212,  /* (171) expr ::= nm DOT nm */
-   212,  /* (172) expr ::= nm DOT nm DOT nm */
-   211,  /* (173) term ::= NULL|FLOAT|BLOB */
-   211,  /* (174) term ::= STRING */
-   211,  /* (175) term ::= INTEGER */
-   212,  /* (176) expr ::= VARIABLE */
-   212,  /* (177) expr ::= expr COLLATE ID|STRING */
-   212,  /* (178) expr ::= CAST LP expr AS typetoken RP */
-   212,  /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */
-   212,  /* (180) expr ::= ID|INDEXED LP STAR RP */
-   212,  /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
-   212,  /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */
-   211,  /* (183) term ::= CTIME_KW */
-   212,  /* (184) expr ::= LP nexprlist COMMA expr RP */
-   212,  /* (185) expr ::= expr AND expr */
-   212,  /* (186) expr ::= expr OR expr */
-   212,  /* (187) expr ::= expr LT|GT|GE|LE expr */
-   212,  /* (188) expr ::= expr EQ|NE expr */
-   212,  /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   212,  /* (190) expr ::= expr PLUS|MINUS expr */
-   212,  /* (191) expr ::= expr STAR|SLASH|REM expr */
-   212,  /* (192) expr ::= expr CONCAT expr */
-   267,  /* (193) likeop ::= NOT LIKE_KW|MATCH */
-   212,  /* (194) expr ::= expr likeop expr */
-   212,  /* (195) expr ::= expr likeop expr ESCAPE expr */
-   212,  /* (196) expr ::= expr ISNULL|NOTNULL */
-   212,  /* (197) expr ::= expr NOT NULL */
-   212,  /* (198) expr ::= expr IS expr */
-   212,  /* (199) expr ::= expr IS NOT expr */
-   212,  /* (200) expr ::= NOT expr */
-   212,  /* (201) expr ::= BITNOT expr */
-   212,  /* (202) expr ::= PLUS|MINUS expr */
-   268,  /* (203) between_op ::= BETWEEN */
-   268,  /* (204) between_op ::= NOT BETWEEN */
-   212,  /* (205) expr ::= expr between_op expr AND expr */
-   269,  /* (206) in_op ::= IN */
-   269,  /* (207) in_op ::= NOT IN */
-   212,  /* (208) expr ::= expr in_op LP exprlist RP */
-   212,  /* (209) expr ::= LP select RP */
-   212,  /* (210) expr ::= expr in_op LP select RP */
-   212,  /* (211) expr ::= expr in_op nm dbnm paren_exprlist */
-   212,  /* (212) expr ::= EXISTS LP select RP */
-   212,  /* (213) expr ::= CASE case_operand case_exprlist case_else END */
-   272,  /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   272,  /* (215) case_exprlist ::= WHEN expr THEN expr */
-   273,  /* (216) case_else ::= ELSE expr */
-   273,  /* (217) case_else ::= */
-   271,  /* (218) case_operand ::= expr */
-   271,  /* (219) case_operand ::= */
-   257,  /* (220) exprlist ::= */
-   248,  /* (221) nexprlist ::= nexprlist COMMA expr */
-   248,  /* (222) nexprlist ::= expr */
-   270,  /* (223) paren_exprlist ::= */
-   270,  /* (224) paren_exprlist ::= LP exprlist RP */
-   186,  /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   274,  /* (226) uniqueflag ::= UNIQUE */
-   274,  /* (227) uniqueflag ::= */
-   216,  /* (228) eidlist_opt ::= */
-   216,  /* (229) eidlist_opt ::= LP eidlist RP */
-   227,  /* (230) eidlist ::= eidlist COMMA nm collate sortorder */
-   227,  /* (231) eidlist ::= nm collate sortorder */
-   275,  /* (232) collate ::= */
-   275,  /* (233) collate ::= COLLATE ID|STRING */
-   186,  /* (234) cmd ::= DROP INDEX ifexists fullname */
-   186,  /* (235) cmd ::= VACUUM vinto */
-   186,  /* (236) cmd ::= VACUUM nm vinto */
-   276,  /* (237) vinto ::= INTO expr */
-   276,  /* (238) vinto ::= */
-   186,  /* (239) cmd ::= PRAGMA nm dbnm */
-   186,  /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   186,  /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   186,  /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   186,  /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   206,  /* (244) plus_num ::= PLUS INTEGER|FLOAT */
-   207,  /* (245) minus_num ::= MINUS INTEGER|FLOAT */
-   186,  /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-   278,  /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   280,  /* (248) trigger_time ::= BEFORE|AFTER */
-   280,  /* (249) trigger_time ::= INSTEAD OF */
-   280,  /* (250) trigger_time ::= */
-   281,  /* (251) trigger_event ::= DELETE|INSERT */
-   281,  /* (252) trigger_event ::= UPDATE */
-   281,  /* (253) trigger_event ::= UPDATE OF idlist */
-   283,  /* (254) when_clause ::= */
-   283,  /* (255) when_clause ::= WHEN expr */
-   279,  /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   279,  /* (257) trigger_cmd_list ::= trigger_cmd SEMI */
-   285,  /* (258) trnm ::= nm DOT nm */
-   286,  /* (259) tridxby ::= INDEXED BY nm */
-   286,  /* (260) tridxby ::= NOT INDEXED */
-   284,  /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-   284,  /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
-   284,  /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-   284,  /* (264) trigger_cmd ::= scanpt select scanpt */
-   212,  /* (265) expr ::= RAISE LP IGNORE RP */
-   212,  /* (266) expr ::= RAISE LP raisetype COMMA nm RP */
-   231,  /* (267) raisetype ::= ROLLBACK */
-   231,  /* (268) raisetype ::= ABORT */
-   231,  /* (269) raisetype ::= FAIL */
-   186,  /* (270) cmd ::= DROP TRIGGER ifexists fullname */
-   186,  /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   186,  /* (272) cmd ::= DETACH database_kw_opt expr */
-   288,  /* (273) key_opt ::= */
-   288,  /* (274) key_opt ::= KEY expr */
-   186,  /* (275) cmd ::= REINDEX */
-   186,  /* (276) cmd ::= REINDEX nm dbnm */
-   186,  /* (277) cmd ::= ANALYZE */
-   186,  /* (278) cmd ::= ANALYZE nm dbnm */
-   186,  /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   186,  /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
-   289,  /* (281) add_column_fullname ::= fullname */
-   186,  /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   186,  /* (283) cmd ::= create_vtab */
-   186,  /* (284) cmd ::= create_vtab LP vtabarglist RP */
-   291,  /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-   293,  /* (286) vtabarg ::= */
-   294,  /* (287) vtabargtoken ::= ANY */
-   294,  /* (288) vtabargtoken ::= lp anylist RP */
-   295,  /* (289) lp ::= LP */
-   261,  /* (290) with ::= WITH wqlist */
-   261,  /* (291) with ::= WITH RECURSIVE wqlist */
-   236,  /* (292) wqlist ::= nm eidlist_opt AS LP select RP */
-   236,  /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
-   297,  /* (294) windowdefn_list ::= windowdefn */
-   297,  /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   298,  /* (296) windowdefn ::= nm AS LP window RP */
-   299,  /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   299,  /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   299,  /* (299) window ::= ORDER BY sortlist frame_opt */
-   299,  /* (300) window ::= nm ORDER BY sortlist frame_opt */
-   299,  /* (301) window ::= frame_opt */
-   299,  /* (302) window ::= nm frame_opt */
-   300,  /* (303) frame_opt ::= */
-   300,  /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   300,  /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   304,  /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */
-   306,  /* (307) frame_bound_s ::= frame_bound */
-   306,  /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */
-   307,  /* (309) frame_bound_e ::= frame_bound */
-   307,  /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   305,  /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */
-   305,  /* (312) frame_bound ::= CURRENT ROW */
-   308,  /* (313) frame_exclude_opt ::= */
-   308,  /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   309,  /* (315) frame_exclude ::= NO OTHERS */
-   309,  /* (316) frame_exclude ::= CURRENT ROW */
-   309,  /* (317) frame_exclude ::= GROUP|TIES */
-   246,  /* (318) window_clause ::= WINDOW windowdefn_list */
-   266,  /* (319) filter_over ::= filter_clause over_clause */
-   266,  /* (320) filter_over ::= over_clause */
-   266,  /* (321) filter_over ::= filter_clause */
-   303,  /* (322) over_clause ::= OVER LP window RP */
-   303,  /* (323) over_clause ::= OVER nm */
-   302,  /* (324) filter_clause ::= FILTER LP WHERE expr RP */
-   181,  /* (325) input ::= cmdlist */
-   182,  /* (326) cmdlist ::= cmdlist ecmd */
-   182,  /* (327) cmdlist ::= ecmd */
-   183,  /* (328) ecmd ::= SEMI */
-   183,  /* (329) ecmd ::= cmdx SEMI */
-   183,  /* (330) ecmd ::= explain cmdx SEMI */
-   188,  /* (331) trans_opt ::= */
-   188,  /* (332) trans_opt ::= TRANSACTION */
-   188,  /* (333) trans_opt ::= TRANSACTION nm */
-   190,  /* (334) savepoint_opt ::= SAVEPOINT */
-   190,  /* (335) savepoint_opt ::= */
-   186,  /* (336) cmd ::= create_table create_table_args */
-   197,  /* (337) columnlist ::= columnlist COMMA columnname carglist */
-   197,  /* (338) columnlist ::= columnname carglist */
-   189,  /* (339) nm ::= ID|INDEXED */
-   189,  /* (340) nm ::= STRING */
-   189,  /* (341) nm ::= JOIN_KW */
-   203,  /* (342) typetoken ::= typename */
-   204,  /* (343) typename ::= ID|STRING */
-   205,  /* (344) signed ::= plus_num */
-   205,  /* (345) signed ::= minus_num */
-   202,  /* (346) carglist ::= carglist ccons */
-   202,  /* (347) carglist ::= */
-   210,  /* (348) ccons ::= NULL onconf */
-   210,  /* (349) ccons ::= GENERATED ALWAYS AS generated */
-   210,  /* (350) ccons ::= AS generated */
-   198,  /* (351) conslist_opt ::= COMMA conslist */
-   223,  /* (352) conslist ::= conslist tconscomma tcons */
-   223,  /* (353) conslist ::= tcons */
-   224,  /* (354) tconscomma ::= */
-   228,  /* (355) defer_subclause_opt ::= defer_subclause */
-   230,  /* (356) resolvetype ::= raisetype */
-   234,  /* (357) selectnowith ::= oneselect */
-   235,  /* (358) oneselect ::= values */
-   249,  /* (359) sclp ::= selcollist COMMA */
-   250,  /* (360) as ::= ID|STRING */
-   212,  /* (361) expr ::= term */
-   267,  /* (362) likeop ::= LIKE_KW|MATCH */
-   257,  /* (363) exprlist ::= nexprlist */
-   277,  /* (364) nmnum ::= plus_num */
-   277,  /* (365) nmnum ::= nm */
-   277,  /* (366) nmnum ::= ON */
-   277,  /* (367) nmnum ::= DELETE */
-   277,  /* (368) nmnum ::= DEFAULT */
-   206,  /* (369) plus_num ::= INTEGER|FLOAT */
-   282,  /* (370) foreach_clause ::= */
-   282,  /* (371) foreach_clause ::= FOR EACH ROW */
-   285,  /* (372) trnm ::= nm */
-   286,  /* (373) tridxby ::= */
-   287,  /* (374) database_kw_opt ::= DATABASE */
-   287,  /* (375) database_kw_opt ::= */
-   290,  /* (376) kwcolumn_opt ::= */
-   290,  /* (377) kwcolumn_opt ::= COLUMNKW */
-   292,  /* (378) vtabarglist ::= vtabarg */
-   292,  /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */
-   293,  /* (380) vtabarg ::= vtabarg vtabargtoken */
-   296,  /* (381) anylist ::= */
-   296,  /* (382) anylist ::= anylist LP anylist RP */
-   296,  /* (383) anylist ::= anylist ANY */
-   261,  /* (384) with ::= */
+   188,  /* (0) explain ::= EXPLAIN */
+   188,  /* (1) explain ::= EXPLAIN QUERY PLAN */
+   187,  /* (2) cmdx ::= cmd */
+   189,  /* (3) cmd ::= BEGIN transtype trans_opt */
+   190,  /* (4) transtype ::= */
+   190,  /* (5) transtype ::= DEFERRED */
+   190,  /* (6) transtype ::= IMMEDIATE */
+   190,  /* (7) transtype ::= EXCLUSIVE */
+   189,  /* (8) cmd ::= COMMIT|END trans_opt */
+   189,  /* (9) cmd ::= ROLLBACK trans_opt */
+   189,  /* (10) cmd ::= SAVEPOINT nm */
+   189,  /* (11) cmd ::= RELEASE savepoint_opt nm */
+   189,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
+   194,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
+   196,  /* (14) createkw ::= CREATE */
+   198,  /* (15) ifnotexists ::= */
+   198,  /* (16) ifnotexists ::= IF NOT EXISTS */
+   197,  /* (17) temp ::= TEMP */
+   197,  /* (18) temp ::= */
+   195,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
+   195,  /* (20) create_table_args ::= AS select */
+   202,  /* (21) table_option_set ::= */
+   202,  /* (22) table_option_set ::= table_option_set COMMA table_option */
+   204,  /* (23) table_option ::= WITHOUT nm */
+   204,  /* (24) table_option ::= nm */
+   205,  /* (25) columnname ::= nm typetoken */
+   207,  /* (26) typetoken ::= */
+   207,  /* (27) typetoken ::= typename LP signed RP */
+   207,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
+   208,  /* (29) typename ::= typename ID|STRING */
+   212,  /* (30) scanpt ::= */
+   213,  /* (31) scantok ::= */
+   214,  /* (32) ccons ::= CONSTRAINT nm */
+   214,  /* (33) ccons ::= DEFAULT scantok term */
+   214,  /* (34) ccons ::= DEFAULT LP expr RP */
+   214,  /* (35) ccons ::= DEFAULT PLUS scantok term */
+   214,  /* (36) ccons ::= DEFAULT MINUS scantok term */
+   214,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
+   214,  /* (38) ccons ::= NOT NULL onconf */
+   214,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
+   214,  /* (40) ccons ::= UNIQUE onconf */
+   214,  /* (41) ccons ::= CHECK LP expr RP */
+   214,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
+   214,  /* (43) ccons ::= defer_subclause */
+   214,  /* (44) ccons ::= COLLATE ID|STRING */
+   223,  /* (45) generated ::= LP expr RP */
+   223,  /* (46) generated ::= LP expr RP ID */
+   219,  /* (47) autoinc ::= */
+   219,  /* (48) autoinc ::= AUTOINCR */
+   221,  /* (49) refargs ::= */
+   221,  /* (50) refargs ::= refargs refarg */
+   224,  /* (51) refarg ::= MATCH nm */
+   224,  /* (52) refarg ::= ON INSERT refact */
+   224,  /* (53) refarg ::= ON DELETE refact */
+   224,  /* (54) refarg ::= ON UPDATE refact */
+   225,  /* (55) refact ::= SET NULL */
+   225,  /* (56) refact ::= SET DEFAULT */
+   225,  /* (57) refact ::= CASCADE */
+   225,  /* (58) refact ::= RESTRICT */
+   225,  /* (59) refact ::= NO ACTION */
+   222,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
+   222,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
+   226,  /* (62) init_deferred_pred_opt ::= */
+   226,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
+   226,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
+   201,  /* (65) conslist_opt ::= */
+   228,  /* (66) tconscomma ::= COMMA */
+   229,  /* (67) tcons ::= CONSTRAINT nm */
+   229,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
+   229,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
+   229,  /* (70) tcons ::= CHECK LP expr RP onconf */
+   229,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
+   232,  /* (72) defer_subclause_opt ::= */
+   217,  /* (73) onconf ::= */
+   217,  /* (74) onconf ::= ON CONFLICT resolvetype */
+   233,  /* (75) orconf ::= */
+   233,  /* (76) orconf ::= OR resolvetype */
+   234,  /* (77) resolvetype ::= IGNORE */
+   234,  /* (78) resolvetype ::= REPLACE */
+   189,  /* (79) cmd ::= DROP TABLE ifexists fullname */
+   236,  /* (80) ifexists ::= IF EXISTS */
+   236,  /* (81) ifexists ::= */
+   189,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
+   189,  /* (83) cmd ::= DROP VIEW ifexists fullname */
+   189,  /* (84) cmd ::= select */
+   203,  /* (85) select ::= WITH wqlist selectnowith */
+   203,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
+   203,  /* (87) select ::= selectnowith */
+   238,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
+   241,  /* (89) multiselect_op ::= UNION */
+   241,  /* (90) multiselect_op ::= UNION ALL */
+   241,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
+   239,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
+   239,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
+   251,  /* (94) values ::= VALUES LP nexprlist RP */
+   251,  /* (95) values ::= values COMMA LP nexprlist RP */
+   242,  /* (96) distinct ::= DISTINCT */
+   242,  /* (97) distinct ::= ALL */
+   242,  /* (98) distinct ::= */
+   253,  /* (99) sclp ::= */
+   243,  /* (100) selcollist ::= sclp scanpt expr scanpt as */
+   243,  /* (101) selcollist ::= sclp scanpt STAR */
+   243,  /* (102) selcollist ::= sclp scanpt nm DOT STAR */
+   254,  /* (103) as ::= AS nm */
+   254,  /* (104) as ::= */
+   244,  /* (105) from ::= */
+   244,  /* (106) from ::= FROM seltablist */
+   256,  /* (107) stl_prefix ::= seltablist joinop */
+   256,  /* (108) stl_prefix ::= */
+   255,  /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
+   255,  /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
+   255,  /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
+   255,  /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
+   199,  /* (113) dbnm ::= */
+   199,  /* (114) dbnm ::= DOT nm */
+   237,  /* (115) fullname ::= nm */
+   237,  /* (116) fullname ::= nm DOT nm */
+   262,  /* (117) xfullname ::= nm */
+   262,  /* (118) xfullname ::= nm DOT nm */
+   262,  /* (119) xfullname ::= nm DOT nm AS nm */
+   262,  /* (120) xfullname ::= nm AS nm */
+   257,  /* (121) joinop ::= COMMA|JOIN */
+   257,  /* (122) joinop ::= JOIN_KW JOIN */
+   257,  /* (123) joinop ::= JOIN_KW nm JOIN */
+   257,  /* (124) joinop ::= JOIN_KW nm nm JOIN */
+   259,  /* (125) on_opt ::= ON expr */
+   259,  /* (126) on_opt ::= */
+   258,  /* (127) indexed_opt ::= */
+   258,  /* (128) indexed_opt ::= INDEXED BY nm */
+   258,  /* (129) indexed_opt ::= NOT INDEXED */
+   260,  /* (130) using_opt ::= USING LP idlist RP */
+   260,  /* (131) using_opt ::= */
+   248,  /* (132) orderby_opt ::= */
+   248,  /* (133) orderby_opt ::= ORDER BY sortlist */
+   230,  /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
+   230,  /* (135) sortlist ::= expr sortorder nulls */
+   218,  /* (136) sortorder ::= ASC */
+   218,  /* (137) sortorder ::= DESC */
+   218,  /* (138) sortorder ::= */
+   264,  /* (139) nulls ::= NULLS FIRST */
+   264,  /* (140) nulls ::= NULLS LAST */
+   264,  /* (141) nulls ::= */
+   246,  /* (142) groupby_opt ::= */
+   246,  /* (143) groupby_opt ::= GROUP BY nexprlist */
+   247,  /* (144) having_opt ::= */
+   247,  /* (145) having_opt ::= HAVING expr */
+   249,  /* (146) limit_opt ::= */
+   249,  /* (147) limit_opt ::= LIMIT expr */
+   249,  /* (148) limit_opt ::= LIMIT expr OFFSET expr */
+   249,  /* (149) limit_opt ::= LIMIT expr COMMA expr */
+   189,  /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
+   245,  /* (151) where_opt ::= */
+   245,  /* (152) where_opt ::= WHERE expr */
+   266,  /* (153) where_opt_ret ::= */
+   266,  /* (154) where_opt_ret ::= WHERE expr */
+   266,  /* (155) where_opt_ret ::= RETURNING selcollist */
+   266,  /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
+   189,  /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
+   267,  /* (158) setlist ::= setlist COMMA nm EQ expr */
+   267,  /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
+   267,  /* (160) setlist ::= nm EQ expr */
+   267,  /* (161) setlist ::= LP idlist RP EQ expr */
+   189,  /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+   189,  /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
+   270,  /* (164) upsert ::= */
+   270,  /* (165) upsert ::= RETURNING selcollist */
+   270,  /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+   270,  /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+   270,  /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
+   270,  /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+   271,  /* (170) returning ::= RETURNING selcollist */
+   268,  /* (171) insert_cmd ::= INSERT orconf */
+   268,  /* (172) insert_cmd ::= REPLACE */
+   269,  /* (173) idlist_opt ::= */
+   269,  /* (174) idlist_opt ::= LP idlist RP */
+   263,  /* (175) idlist ::= idlist COMMA nm */
+   263,  /* (176) idlist ::= nm */
+   216,  /* (177) expr ::= LP expr RP */
+   216,  /* (178) expr ::= ID|INDEXED */
+   216,  /* (179) expr ::= JOIN_KW */
+   216,  /* (180) expr ::= nm DOT nm */
+   216,  /* (181) expr ::= nm DOT nm DOT nm */
+   215,  /* (182) term ::= NULL|FLOAT|BLOB */
+   215,  /* (183) term ::= STRING */
+   215,  /* (184) term ::= INTEGER */
+   216,  /* (185) expr ::= VARIABLE */
+   216,  /* (186) expr ::= expr COLLATE ID|STRING */
+   216,  /* (187) expr ::= CAST LP expr AS typetoken RP */
+   216,  /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */
+   216,  /* (189) expr ::= ID|INDEXED LP STAR RP */
+   216,  /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
+   216,  /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */
+   215,  /* (192) term ::= CTIME_KW */
+   216,  /* (193) expr ::= LP nexprlist COMMA expr RP */
+   216,  /* (194) expr ::= expr AND expr */
+   216,  /* (195) expr ::= expr OR expr */
+   216,  /* (196) expr ::= expr LT|GT|GE|LE expr */
+   216,  /* (197) expr ::= expr EQ|NE expr */
+   216,  /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
+   216,  /* (199) expr ::= expr PLUS|MINUS expr */
+   216,  /* (200) expr ::= expr STAR|SLASH|REM expr */
+   216,  /* (201) expr ::= expr CONCAT expr */
+   273,  /* (202) likeop ::= NOT LIKE_KW|MATCH */
+   216,  /* (203) expr ::= expr likeop expr */
+   216,  /* (204) expr ::= expr likeop expr ESCAPE expr */
+   216,  /* (205) expr ::= expr ISNULL|NOTNULL */
+   216,  /* (206) expr ::= expr NOT NULL */
+   216,  /* (207) expr ::= expr IS expr */
+   216,  /* (208) expr ::= expr IS NOT expr */
+   216,  /* (209) expr ::= NOT expr */
+   216,  /* (210) expr ::= BITNOT expr */
+   216,  /* (211) expr ::= PLUS|MINUS expr */
+   274,  /* (212) between_op ::= BETWEEN */
+   274,  /* (213) between_op ::= NOT BETWEEN */
+   216,  /* (214) expr ::= expr between_op expr AND expr */
+   275,  /* (215) in_op ::= IN */
+   275,  /* (216) in_op ::= NOT IN */
+   216,  /* (217) expr ::= expr in_op LP exprlist RP */
+   216,  /* (218) expr ::= LP select RP */
+   216,  /* (219) expr ::= expr in_op LP select RP */
+   216,  /* (220) expr ::= expr in_op nm dbnm paren_exprlist */
+   216,  /* (221) expr ::= EXISTS LP select RP */
+   216,  /* (222) expr ::= CASE case_operand case_exprlist case_else END */
+   278,  /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */
+   278,  /* (224) case_exprlist ::= WHEN expr THEN expr */
+   279,  /* (225) case_else ::= ELSE expr */
+   279,  /* (226) case_else ::= */
+   277,  /* (227) case_operand ::= expr */
+   277,  /* (228) case_operand ::= */
+   261,  /* (229) exprlist ::= */
+   252,  /* (230) nexprlist ::= nexprlist COMMA expr */
+   252,  /* (231) nexprlist ::= expr */
+   276,  /* (232) paren_exprlist ::= */
+   276,  /* (233) paren_exprlist ::= LP exprlist RP */
+   189,  /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+   280,  /* (235) uniqueflag ::= UNIQUE */
+   280,  /* (236) uniqueflag ::= */
+   220,  /* (237) eidlist_opt ::= */
+   220,  /* (238) eidlist_opt ::= LP eidlist RP */
+   231,  /* (239) eidlist ::= eidlist COMMA nm collate sortorder */
+   231,  /* (240) eidlist ::= nm collate sortorder */
+   281,  /* (241) collate ::= */
+   281,  /* (242) collate ::= COLLATE ID|STRING */
+   189,  /* (243) cmd ::= DROP INDEX ifexists fullname */
+   189,  /* (244) cmd ::= VACUUM vinto */
+   189,  /* (245) cmd ::= VACUUM nm vinto */
+   282,  /* (246) vinto ::= INTO expr */
+   282,  /* (247) vinto ::= */
+   189,  /* (248) cmd ::= PRAGMA nm dbnm */
+   189,  /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */
+   189,  /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */
+   189,  /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */
+   189,  /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */
+   210,  /* (253) plus_num ::= PLUS INTEGER|FLOAT */
+   211,  /* (254) minus_num ::= MINUS INTEGER|FLOAT */
+   189,  /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+   284,  /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+   286,  /* (257) trigger_time ::= BEFORE|AFTER */
+   286,  /* (258) trigger_time ::= INSTEAD OF */
+   286,  /* (259) trigger_time ::= */
+   287,  /* (260) trigger_event ::= DELETE|INSERT */
+   287,  /* (261) trigger_event ::= UPDATE */
+   287,  /* (262) trigger_event ::= UPDATE OF idlist */
+   289,  /* (263) when_clause ::= */
+   289,  /* (264) when_clause ::= WHEN expr */
+   285,  /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+   285,  /* (266) trigger_cmd_list ::= trigger_cmd SEMI */
+   291,  /* (267) trnm ::= nm DOT nm */
+   292,  /* (268) tridxby ::= INDEXED BY nm */
+   292,  /* (269) tridxby ::= NOT INDEXED */
+   290,  /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+   290,  /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+   290,  /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+   290,  /* (273) trigger_cmd ::= scanpt select scanpt */
+   216,  /* (274) expr ::= RAISE LP IGNORE RP */
+   216,  /* (275) expr ::= RAISE LP raisetype COMMA nm RP */
+   235,  /* (276) raisetype ::= ROLLBACK */
+   235,  /* (277) raisetype ::= ABORT */
+   235,  /* (278) raisetype ::= FAIL */
+   189,  /* (279) cmd ::= DROP TRIGGER ifexists fullname */
+   189,  /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+   189,  /* (281) cmd ::= DETACH database_kw_opt expr */
+   294,  /* (282) key_opt ::= */
+   294,  /* (283) key_opt ::= KEY expr */
+   189,  /* (284) cmd ::= REINDEX */
+   189,  /* (285) cmd ::= REINDEX nm dbnm */
+   189,  /* (286) cmd ::= ANALYZE */
+   189,  /* (287) cmd ::= ANALYZE nm dbnm */
+   189,  /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */
+   189,  /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+   189,  /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+   295,  /* (291) add_column_fullname ::= fullname */
+   189,  /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+   189,  /* (293) cmd ::= create_vtab */
+   189,  /* (294) cmd ::= create_vtab LP vtabarglist RP */
+   297,  /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+   299,  /* (296) vtabarg ::= */
+   300,  /* (297) vtabargtoken ::= ANY */
+   300,  /* (298) vtabargtoken ::= lp anylist RP */
+   301,  /* (299) lp ::= LP */
+   265,  /* (300) with ::= WITH wqlist */
+   265,  /* (301) with ::= WITH RECURSIVE wqlist */
+   304,  /* (302) wqas ::= AS */
+   304,  /* (303) wqas ::= AS MATERIALIZED */
+   304,  /* (304) wqas ::= AS NOT MATERIALIZED */
+   303,  /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */
+   240,  /* (306) wqlist ::= wqitem */
+   240,  /* (307) wqlist ::= wqlist COMMA wqitem */
+   305,  /* (308) windowdefn_list ::= windowdefn */
+   305,  /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */
+   306,  /* (310) windowdefn ::= nm AS LP window RP */
+   307,  /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+   307,  /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+   307,  /* (313) window ::= ORDER BY sortlist frame_opt */
+   307,  /* (314) window ::= nm ORDER BY sortlist frame_opt */
+   307,  /* (315) window ::= frame_opt */
+   307,  /* (316) window ::= nm frame_opt */
+   308,  /* (317) frame_opt ::= */
+   308,  /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+   308,  /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+   312,  /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */
+   314,  /* (321) frame_bound_s ::= frame_bound */
+   314,  /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */
+   315,  /* (323) frame_bound_e ::= frame_bound */
+   315,  /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */
+   313,  /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */
+   313,  /* (326) frame_bound ::= CURRENT ROW */
+   316,  /* (327) frame_exclude_opt ::= */
+   316,  /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */
+   317,  /* (329) frame_exclude ::= NO OTHERS */
+   317,  /* (330) frame_exclude ::= CURRENT ROW */
+   317,  /* (331) frame_exclude ::= GROUP|TIES */
+   250,  /* (332) window_clause ::= WINDOW windowdefn_list */
+   272,  /* (333) filter_over ::= filter_clause over_clause */
+   272,  /* (334) filter_over ::= over_clause */
+   272,  /* (335) filter_over ::= filter_clause */
+   311,  /* (336) over_clause ::= OVER LP window RP */
+   311,  /* (337) over_clause ::= OVER nm */
+   310,  /* (338) filter_clause ::= FILTER LP WHERE expr RP */
+   184,  /* (339) input ::= cmdlist */
+   185,  /* (340) cmdlist ::= cmdlist ecmd */
+   185,  /* (341) cmdlist ::= ecmd */
+   186,  /* (342) ecmd ::= SEMI */
+   186,  /* (343) ecmd ::= cmdx SEMI */
+   186,  /* (344) ecmd ::= explain cmdx SEMI */
+   191,  /* (345) trans_opt ::= */
+   191,  /* (346) trans_opt ::= TRANSACTION */
+   191,  /* (347) trans_opt ::= TRANSACTION nm */
+   193,  /* (348) savepoint_opt ::= SAVEPOINT */
+   193,  /* (349) savepoint_opt ::= */
+   189,  /* (350) cmd ::= create_table create_table_args */
+   202,  /* (351) table_option_set ::= table_option */
+   200,  /* (352) columnlist ::= columnlist COMMA columnname carglist */
+   200,  /* (353) columnlist ::= columnname carglist */
+   192,  /* (354) nm ::= ID|INDEXED */
+   192,  /* (355) nm ::= STRING */
+   192,  /* (356) nm ::= JOIN_KW */
+   207,  /* (357) typetoken ::= typename */
+   208,  /* (358) typename ::= ID|STRING */
+   209,  /* (359) signed ::= plus_num */
+   209,  /* (360) signed ::= minus_num */
+   206,  /* (361) carglist ::= carglist ccons */
+   206,  /* (362) carglist ::= */
+   214,  /* (363) ccons ::= NULL onconf */
+   214,  /* (364) ccons ::= GENERATED ALWAYS AS generated */
+   214,  /* (365) ccons ::= AS generated */
+   201,  /* (366) conslist_opt ::= COMMA conslist */
+   227,  /* (367) conslist ::= conslist tconscomma tcons */
+   227,  /* (368) conslist ::= tcons */
+   228,  /* (369) tconscomma ::= */
+   232,  /* (370) defer_subclause_opt ::= defer_subclause */
+   234,  /* (371) resolvetype ::= raisetype */
+   238,  /* (372) selectnowith ::= oneselect */
+   239,  /* (373) oneselect ::= values */
+   253,  /* (374) sclp ::= selcollist COMMA */
+   254,  /* (375) as ::= ID|STRING */
+   271,  /* (376) returning ::= */
+   216,  /* (377) expr ::= term */
+   273,  /* (378) likeop ::= LIKE_KW|MATCH */
+   261,  /* (379) exprlist ::= nexprlist */
+   283,  /* (380) nmnum ::= plus_num */
+   283,  /* (381) nmnum ::= nm */
+   283,  /* (382) nmnum ::= ON */
+   283,  /* (383) nmnum ::= DELETE */
+   283,  /* (384) nmnum ::= DEFAULT */
+   210,  /* (385) plus_num ::= INTEGER|FLOAT */
+   288,  /* (386) foreach_clause ::= */
+   288,  /* (387) foreach_clause ::= FOR EACH ROW */
+   291,  /* (388) trnm ::= nm */
+   292,  /* (389) tridxby ::= */
+   293,  /* (390) database_kw_opt ::= DATABASE */
+   293,  /* (391) database_kw_opt ::= */
+   296,  /* (392) kwcolumn_opt ::= */
+   296,  /* (393) kwcolumn_opt ::= COLUMNKW */
+   298,  /* (394) vtabarglist ::= vtabarg */
+   298,  /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */
+   299,  /* (396) vtabarg ::= vtabarg vtabargtoken */
+   302,  /* (397) anylist ::= */
+   302,  /* (398) anylist ::= anylist LP anylist RP */
+   302,  /* (399) anylist ::= anylist ANY */
+   265,  /* (400) with ::= */
 };
 
 /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
@@ -157886,372 +162570,388 @@ static const signed char yyRuleInfoNRhs[] = {
    -3,  /* (16) ifnotexists ::= IF NOT EXISTS */
    -1,  /* (17) temp ::= TEMP */
     0,  /* (18) temp ::= */
-   -5,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
+   -5,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
    -2,  /* (20) create_table_args ::= AS select */
-    0,  /* (21) table_options ::= */
-   -2,  /* (22) table_options ::= WITHOUT nm */
-   -2,  /* (23) columnname ::= nm typetoken */
-    0,  /* (24) typetoken ::= */
-   -4,  /* (25) typetoken ::= typename LP signed RP */
-   -6,  /* (26) typetoken ::= typename LP signed COMMA signed RP */
-   -2,  /* (27) typename ::= typename ID|STRING */
-    0,  /* (28) scanpt ::= */
-    0,  /* (29) scantok ::= */
-   -2,  /* (30) ccons ::= CONSTRAINT nm */
-   -3,  /* (31) ccons ::= DEFAULT scantok term */
-   -4,  /* (32) ccons ::= DEFAULT LP expr RP */
-   -4,  /* (33) ccons ::= DEFAULT PLUS scantok term */
-   -4,  /* (34) ccons ::= DEFAULT MINUS scantok term */
-   -3,  /* (35) ccons ::= DEFAULT scantok ID|INDEXED */
-   -3,  /* (36) ccons ::= NOT NULL onconf */
-   -5,  /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
-   -2,  /* (38) ccons ::= UNIQUE onconf */
-   -4,  /* (39) ccons ::= CHECK LP expr RP */
-   -4,  /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
-   -1,  /* (41) ccons ::= defer_subclause */
-   -2,  /* (42) ccons ::= COLLATE ID|STRING */
-   -3,  /* (43) generated ::= LP expr RP */
-   -4,  /* (44) generated ::= LP expr RP ID */
-    0,  /* (45) autoinc ::= */
-   -1,  /* (46) autoinc ::= AUTOINCR */
-    0,  /* (47) refargs ::= */
-   -2,  /* (48) refargs ::= refargs refarg */
-   -2,  /* (49) refarg ::= MATCH nm */
-   -3,  /* (50) refarg ::= ON INSERT refact */
-   -3,  /* (51) refarg ::= ON DELETE refact */
-   -3,  /* (52) refarg ::= ON UPDATE refact */
-   -2,  /* (53) refact ::= SET NULL */
-   -2,  /* (54) refact ::= SET DEFAULT */
-   -1,  /* (55) refact ::= CASCADE */
-   -1,  /* (56) refact ::= RESTRICT */
-   -2,  /* (57) refact ::= NO ACTION */
-   -3,  /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-   -2,  /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-    0,  /* (60) init_deferred_pred_opt ::= */
-   -2,  /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
-   -2,  /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-    0,  /* (63) conslist_opt ::= */
-   -1,  /* (64) tconscomma ::= COMMA */
-   -2,  /* (65) tcons ::= CONSTRAINT nm */
-   -7,  /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-   -5,  /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
-   -5,  /* (68) tcons ::= CHECK LP expr RP onconf */
-  -10,  /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
-    0,  /* (70) defer_subclause_opt ::= */
-    0,  /* (71) onconf ::= */
-   -3,  /* (72) onconf ::= ON CONFLICT resolvetype */
-    0,  /* (73) orconf ::= */
-   -2,  /* (74) orconf ::= OR resolvetype */
-   -1,  /* (75) resolvetype ::= IGNORE */
-   -1,  /* (76) resolvetype ::= REPLACE */
-   -4,  /* (77) cmd ::= DROP TABLE ifexists fullname */
-   -2,  /* (78) ifexists ::= IF EXISTS */
-    0,  /* (79) ifexists ::= */
-   -9,  /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
-   -4,  /* (81) cmd ::= DROP VIEW ifexists fullname */
-   -1,  /* (82) cmd ::= select */
-   -3,  /* (83) select ::= WITH wqlist selectnowith */
-   -4,  /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
-   -1,  /* (85) select ::= selectnowith */
-   -3,  /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
-   -1,  /* (87) multiselect_op ::= UNION */
-   -2,  /* (88) multiselect_op ::= UNION ALL */
-   -1,  /* (89) multiselect_op ::= EXCEPT|INTERSECT */
-   -9,  /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
-  -10,  /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-   -4,  /* (92) values ::= VALUES LP nexprlist RP */
-   -5,  /* (93) values ::= values COMMA LP nexprlist RP */
-   -1,  /* (94) distinct ::= DISTINCT */
-   -1,  /* (95) distinct ::= ALL */
-    0,  /* (96) distinct ::= */
-    0,  /* (97) sclp ::= */
-   -5,  /* (98) selcollist ::= sclp scanpt expr scanpt as */
-   -3,  /* (99) selcollist ::= sclp scanpt STAR */
-   -5,  /* (100) selcollist ::= sclp scanpt nm DOT STAR */
-   -2,  /* (101) as ::= AS nm */
-    0,  /* (102) as ::= */
-    0,  /* (103) from ::= */
-   -2,  /* (104) from ::= FROM seltablist */
-   -2,  /* (105) stl_prefix ::= seltablist joinop */
-    0,  /* (106) stl_prefix ::= */
-   -7,  /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
-   -9,  /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
-   -7,  /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
-   -7,  /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
-    0,  /* (111) dbnm ::= */
-   -2,  /* (112) dbnm ::= DOT nm */
-   -1,  /* (113) fullname ::= nm */
-   -3,  /* (114) fullname ::= nm DOT nm */
-   -1,  /* (115) xfullname ::= nm */
-   -3,  /* (116) xfullname ::= nm DOT nm */
-   -5,  /* (117) xfullname ::= nm DOT nm AS nm */
-   -3,  /* (118) xfullname ::= nm AS nm */
-   -1,  /* (119) joinop ::= COMMA|JOIN */
-   -2,  /* (120) joinop ::= JOIN_KW JOIN */
-   -3,  /* (121) joinop ::= JOIN_KW nm JOIN */
-   -4,  /* (122) joinop ::= JOIN_KW nm nm JOIN */
-   -2,  /* (123) on_opt ::= ON expr */
-    0,  /* (124) on_opt ::= */
-    0,  /* (125) indexed_opt ::= */
-   -3,  /* (126) indexed_opt ::= INDEXED BY nm */
-   -2,  /* (127) indexed_opt ::= NOT INDEXED */
-   -4,  /* (128) using_opt ::= USING LP idlist RP */
-    0,  /* (129) using_opt ::= */
-    0,  /* (130) orderby_opt ::= */
-   -3,  /* (131) orderby_opt ::= ORDER BY sortlist */
-   -5,  /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
-   -3,  /* (133) sortlist ::= expr sortorder nulls */
-   -1,  /* (134) sortorder ::= ASC */
-   -1,  /* (135) sortorder ::= DESC */
-    0,  /* (136) sortorder ::= */
-   -2,  /* (137) nulls ::= NULLS FIRST */
-   -2,  /* (138) nulls ::= NULLS LAST */
-    0,  /* (139) nulls ::= */
-    0,  /* (140) groupby_opt ::= */
-   -3,  /* (141) groupby_opt ::= GROUP BY nexprlist */
-    0,  /* (142) having_opt ::= */
-   -2,  /* (143) having_opt ::= HAVING expr */
-    0,  /* (144) limit_opt ::= */
-   -2,  /* (145) limit_opt ::= LIMIT expr */
-   -4,  /* (146) limit_opt ::= LIMIT expr OFFSET expr */
-   -4,  /* (147) limit_opt ::= LIMIT expr COMMA expr */
-   -6,  /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
-    0,  /* (149) where_opt ::= */
-   -2,  /* (150) where_opt ::= WHERE expr */
-   -9,  /* (151) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
-   -5,  /* (152) setlist ::= setlist COMMA nm EQ expr */
-   -7,  /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */
-   -3,  /* (154) setlist ::= nm EQ expr */
-   -5,  /* (155) setlist ::= LP idlist RP EQ expr */
-   -7,  /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
-   -7,  /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
-    0,  /* (158) upsert ::= */
-  -11,  /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
-   -8,  /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
-   -4,  /* (161) upsert ::= ON CONFLICT DO NOTHING */
-   -2,  /* (162) insert_cmd ::= INSERT orconf */
-   -1,  /* (163) insert_cmd ::= REPLACE */
-    0,  /* (164) idlist_opt ::= */
-   -3,  /* (165) idlist_opt ::= LP idlist RP */
-   -3,  /* (166) idlist ::= idlist COMMA nm */
-   -1,  /* (167) idlist ::= nm */
-   -3,  /* (168) expr ::= LP expr RP */
-   -1,  /* (169) expr ::= ID|INDEXED */
-   -1,  /* (170) expr ::= JOIN_KW */
-   -3,  /* (171) expr ::= nm DOT nm */
-   -5,  /* (172) expr ::= nm DOT nm DOT nm */
-   -1,  /* (173) term ::= NULL|FLOAT|BLOB */
-   -1,  /* (174) term ::= STRING */
-   -1,  /* (175) term ::= INTEGER */
-   -1,  /* (176) expr ::= VARIABLE */
-   -3,  /* (177) expr ::= expr COLLATE ID|STRING */
-   -6,  /* (178) expr ::= CAST LP expr AS typetoken RP */
-   -5,  /* (179) expr ::= ID|INDEXED LP distinct exprlist RP */
-   -4,  /* (180) expr ::= ID|INDEXED LP STAR RP */
-   -6,  /* (181) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
-   -5,  /* (182) expr ::= ID|INDEXED LP STAR RP filter_over */
-   -1,  /* (183) term ::= CTIME_KW */
-   -5,  /* (184) expr ::= LP nexprlist COMMA expr RP */
-   -3,  /* (185) expr ::= expr AND expr */
-   -3,  /* (186) expr ::= expr OR expr */
-   -3,  /* (187) expr ::= expr LT|GT|GE|LE expr */
-   -3,  /* (188) expr ::= expr EQ|NE expr */
-   -3,  /* (189) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
-   -3,  /* (190) expr ::= expr PLUS|MINUS expr */
-   -3,  /* (191) expr ::= expr STAR|SLASH|REM expr */
-   -3,  /* (192) expr ::= expr CONCAT expr */
-   -2,  /* (193) likeop ::= NOT LIKE_KW|MATCH */
-   -3,  /* (194) expr ::= expr likeop expr */
-   -5,  /* (195) expr ::= expr likeop expr ESCAPE expr */
-   -2,  /* (196) expr ::= expr ISNULL|NOTNULL */
-   -3,  /* (197) expr ::= expr NOT NULL */
-   -3,  /* (198) expr ::= expr IS expr */
-   -4,  /* (199) expr ::= expr IS NOT expr */
-   -2,  /* (200) expr ::= NOT expr */
-   -2,  /* (201) expr ::= BITNOT expr */
-   -2,  /* (202) expr ::= PLUS|MINUS expr */
-   -1,  /* (203) between_op ::= BETWEEN */
-   -2,  /* (204) between_op ::= NOT BETWEEN */
-   -5,  /* (205) expr ::= expr between_op expr AND expr */
-   -1,  /* (206) in_op ::= IN */
-   -2,  /* (207) in_op ::= NOT IN */
-   -5,  /* (208) expr ::= expr in_op LP exprlist RP */
-   -3,  /* (209) expr ::= LP select RP */
-   -5,  /* (210) expr ::= expr in_op LP select RP */
-   -5,  /* (211) expr ::= expr in_op nm dbnm paren_exprlist */
-   -4,  /* (212) expr ::= EXISTS LP select RP */
-   -5,  /* (213) expr ::= CASE case_operand case_exprlist case_else END */
-   -5,  /* (214) case_exprlist ::= case_exprlist WHEN expr THEN expr */
-   -4,  /* (215) case_exprlist ::= WHEN expr THEN expr */
-   -2,  /* (216) case_else ::= ELSE expr */
-    0,  /* (217) case_else ::= */
-   -1,  /* (218) case_operand ::= expr */
-    0,  /* (219) case_operand ::= */
-    0,  /* (220) exprlist ::= */
-   -3,  /* (221) nexprlist ::= nexprlist COMMA expr */
-   -1,  /* (222) nexprlist ::= expr */
-    0,  /* (223) paren_exprlist ::= */
-   -3,  /* (224) paren_exprlist ::= LP exprlist RP */
-  -12,  /* (225) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
-   -1,  /* (226) uniqueflag ::= UNIQUE */
-    0,  /* (227) uniqueflag ::= */
-    0,  /* (228) eidlist_opt ::= */
-   -3,  /* (229) eidlist_opt ::= LP eidlist RP */
-   -5,  /* (230) eidlist ::= eidlist COMMA nm collate sortorder */
-   -3,  /* (231) eidlist ::= nm collate sortorder */
-    0,  /* (232) collate ::= */
-   -2,  /* (233) collate ::= COLLATE ID|STRING */
-   -4,  /* (234) cmd ::= DROP INDEX ifexists fullname */
-   -2,  /* (235) cmd ::= VACUUM vinto */
-   -3,  /* (236) cmd ::= VACUUM nm vinto */
-   -2,  /* (237) vinto ::= INTO expr */
-    0,  /* (238) vinto ::= */
-   -3,  /* (239) cmd ::= PRAGMA nm dbnm */
-   -5,  /* (240) cmd ::= PRAGMA nm dbnm EQ nmnum */
-   -6,  /* (241) cmd ::= PRAGMA nm dbnm LP nmnum RP */
-   -5,  /* (242) cmd ::= PRAGMA nm dbnm EQ minus_num */
-   -6,  /* (243) cmd ::= PRAGMA nm dbnm LP minus_num RP */
-   -2,  /* (244) plus_num ::= PLUS INTEGER|FLOAT */
-   -2,  /* (245) minus_num ::= MINUS INTEGER|FLOAT */
-   -5,  /* (246) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
-  -11,  /* (247) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
-   -1,  /* (248) trigger_time ::= BEFORE|AFTER */
-   -2,  /* (249) trigger_time ::= INSTEAD OF */
-    0,  /* (250) trigger_time ::= */
-   -1,  /* (251) trigger_event ::= DELETE|INSERT */
-   -1,  /* (252) trigger_event ::= UPDATE */
-   -3,  /* (253) trigger_event ::= UPDATE OF idlist */
-    0,  /* (254) when_clause ::= */
-   -2,  /* (255) when_clause ::= WHEN expr */
-   -3,  /* (256) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-   -2,  /* (257) trigger_cmd_list ::= trigger_cmd SEMI */
-   -3,  /* (258) trnm ::= nm DOT nm */
-   -3,  /* (259) tridxby ::= INDEXED BY nm */
-   -2,  /* (260) tridxby ::= NOT INDEXED */
-   -9,  /* (261) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-   -8,  /* (262) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
-   -6,  /* (263) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-   -3,  /* (264) trigger_cmd ::= scanpt select scanpt */
-   -4,  /* (265) expr ::= RAISE LP IGNORE RP */
-   -6,  /* (266) expr ::= RAISE LP raisetype COMMA nm RP */
-   -1,  /* (267) raisetype ::= ROLLBACK */
-   -1,  /* (268) raisetype ::= ABORT */
-   -1,  /* (269) raisetype ::= FAIL */
-   -4,  /* (270) cmd ::= DROP TRIGGER ifexists fullname */
-   -6,  /* (271) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
-   -3,  /* (272) cmd ::= DETACH database_kw_opt expr */
-    0,  /* (273) key_opt ::= */
-   -2,  /* (274) key_opt ::= KEY expr */
-   -1,  /* (275) cmd ::= REINDEX */
-   -3,  /* (276) cmd ::= REINDEX nm dbnm */
-   -1,  /* (277) cmd ::= ANALYZE */
-   -3,  /* (278) cmd ::= ANALYZE nm dbnm */
-   -6,  /* (279) cmd ::= ALTER TABLE fullname RENAME TO nm */
-   -7,  /* (280) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
-   -1,  /* (281) add_column_fullname ::= fullname */
-   -8,  /* (282) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-   -1,  /* (283) cmd ::= create_vtab */
-   -4,  /* (284) cmd ::= create_vtab LP vtabarglist RP */
-   -8,  /* (285) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
-    0,  /* (286) vtabarg ::= */
-   -1,  /* (287) vtabargtoken ::= ANY */
-   -3,  /* (288) vtabargtoken ::= lp anylist RP */
-   -1,  /* (289) lp ::= LP */
-   -2,  /* (290) with ::= WITH wqlist */
-   -3,  /* (291) with ::= WITH RECURSIVE wqlist */
-   -6,  /* (292) wqlist ::= nm eidlist_opt AS LP select RP */
-   -8,  /* (293) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
-   -1,  /* (294) windowdefn_list ::= windowdefn */
-   -3,  /* (295) windowdefn_list ::= windowdefn_list COMMA windowdefn */
-   -5,  /* (296) windowdefn ::= nm AS LP window RP */
-   -5,  /* (297) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-   -6,  /* (298) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-   -4,  /* (299) window ::= ORDER BY sortlist frame_opt */
-   -5,  /* (300) window ::= nm ORDER BY sortlist frame_opt */
-   -1,  /* (301) window ::= frame_opt */
-   -2,  /* (302) window ::= nm frame_opt */
-    0,  /* (303) frame_opt ::= */
-   -3,  /* (304) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
-   -6,  /* (305) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
-   -1,  /* (306) range_or_rows ::= RANGE|ROWS|GROUPS */
-   -1,  /* (307) frame_bound_s ::= frame_bound */
-   -2,  /* (308) frame_bound_s ::= UNBOUNDED PRECEDING */
-   -1,  /* (309) frame_bound_e ::= frame_bound */
-   -2,  /* (310) frame_bound_e ::= UNBOUNDED FOLLOWING */
-   -2,  /* (311) frame_bound ::= expr PRECEDING|FOLLOWING */
-   -2,  /* (312) frame_bound ::= CURRENT ROW */
-    0,  /* (313) frame_exclude_opt ::= */
-   -2,  /* (314) frame_exclude_opt ::= EXCLUDE frame_exclude */
-   -2,  /* (315) frame_exclude ::= NO OTHERS */
-   -2,  /* (316) frame_exclude ::= CURRENT ROW */
-   -1,  /* (317) frame_exclude ::= GROUP|TIES */
-   -2,  /* (318) window_clause ::= WINDOW windowdefn_list */
-   -2,  /* (319) filter_over ::= filter_clause over_clause */
-   -1,  /* (320) filter_over ::= over_clause */
-   -1,  /* (321) filter_over ::= filter_clause */
-   -4,  /* (322) over_clause ::= OVER LP window RP */
-   -2,  /* (323) over_clause ::= OVER nm */
-   -5,  /* (324) filter_clause ::= FILTER LP WHERE expr RP */
-   -1,  /* (325) input ::= cmdlist */
-   -2,  /* (326) cmdlist ::= cmdlist ecmd */
-   -1,  /* (327) cmdlist ::= ecmd */
-   -1,  /* (328) ecmd ::= SEMI */
-   -2,  /* (329) ecmd ::= cmdx SEMI */
-   -3,  /* (330) ecmd ::= explain cmdx SEMI */
-    0,  /* (331) trans_opt ::= */
-   -1,  /* (332) trans_opt ::= TRANSACTION */
-   -2,  /* (333) trans_opt ::= TRANSACTION nm */
-   -1,  /* (334) savepoint_opt ::= SAVEPOINT */
-    0,  /* (335) savepoint_opt ::= */
-   -2,  /* (336) cmd ::= create_table create_table_args */
-   -4,  /* (337) columnlist ::= columnlist COMMA columnname carglist */
-   -2,  /* (338) columnlist ::= columnname carglist */
-   -1,  /* (339) nm ::= ID|INDEXED */
-   -1,  /* (340) nm ::= STRING */
-   -1,  /* (341) nm ::= JOIN_KW */
-   -1,  /* (342) typetoken ::= typename */
-   -1,  /* (343) typename ::= ID|STRING */
-   -1,  /* (344) signed ::= plus_num */
-   -1,  /* (345) signed ::= minus_num */
-   -2,  /* (346) carglist ::= carglist ccons */
-    0,  /* (347) carglist ::= */
-   -2,  /* (348) ccons ::= NULL onconf */
-   -4,  /* (349) ccons ::= GENERATED ALWAYS AS generated */
-   -2,  /* (350) ccons ::= AS generated */
-   -2,  /* (351) conslist_opt ::= COMMA conslist */
-   -3,  /* (352) conslist ::= conslist tconscomma tcons */
-   -1,  /* (353) conslist ::= tcons */
-    0,  /* (354) tconscomma ::= */
-   -1,  /* (355) defer_subclause_opt ::= defer_subclause */
-   -1,  /* (356) resolvetype ::= raisetype */
-   -1,  /* (357) selectnowith ::= oneselect */
-   -1,  /* (358) oneselect ::= values */
-   -2,  /* (359) sclp ::= selcollist COMMA */
-   -1,  /* (360) as ::= ID|STRING */
-   -1,  /* (361) expr ::= term */
-   -1,  /* (362) likeop ::= LIKE_KW|MATCH */
-   -1,  /* (363) exprlist ::= nexprlist */
-   -1,  /* (364) nmnum ::= plus_num */
-   -1,  /* (365) nmnum ::= nm */
-   -1,  /* (366) nmnum ::= ON */
-   -1,  /* (367) nmnum ::= DELETE */
-   -1,  /* (368) nmnum ::= DEFAULT */
-   -1,  /* (369) plus_num ::= INTEGER|FLOAT */
-    0,  /* (370) foreach_clause ::= */
-   -3,  /* (371) foreach_clause ::= FOR EACH ROW */
-   -1,  /* (372) trnm ::= nm */
-    0,  /* (373) tridxby ::= */
-   -1,  /* (374) database_kw_opt ::= DATABASE */
-    0,  /* (375) database_kw_opt ::= */
-    0,  /* (376) kwcolumn_opt ::= */
-   -1,  /* (377) kwcolumn_opt ::= COLUMNKW */
-   -1,  /* (378) vtabarglist ::= vtabarg */
-   -3,  /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */
-   -2,  /* (380) vtabarg ::= vtabarg vtabargtoken */
-    0,  /* (381) anylist ::= */
-   -4,  /* (382) anylist ::= anylist LP anylist RP */
-   -2,  /* (383) anylist ::= anylist ANY */
-    0,  /* (384) with ::= */
+    0,  /* (21) table_option_set ::= */
+   -3,  /* (22) table_option_set ::= table_option_set COMMA table_option */
+   -2,  /* (23) table_option ::= WITHOUT nm */
+   -1,  /* (24) table_option ::= nm */
+   -2,  /* (25) columnname ::= nm typetoken */
+    0,  /* (26) typetoken ::= */
+   -4,  /* (27) typetoken ::= typename LP signed RP */
+   -6,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
+   -2,  /* (29) typename ::= typename ID|STRING */
+    0,  /* (30) scanpt ::= */
+    0,  /* (31) scantok ::= */
+   -2,  /* (32) ccons ::= CONSTRAINT nm */
+   -3,  /* (33) ccons ::= DEFAULT scantok term */
+   -4,  /* (34) ccons ::= DEFAULT LP expr RP */
+   -4,  /* (35) ccons ::= DEFAULT PLUS scantok term */
+   -4,  /* (36) ccons ::= DEFAULT MINUS scantok term */
+   -3,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
+   -3,  /* (38) ccons ::= NOT NULL onconf */
+   -5,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
+   -2,  /* (40) ccons ::= UNIQUE onconf */
+   -4,  /* (41) ccons ::= CHECK LP expr RP */
+   -4,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
+   -1,  /* (43) ccons ::= defer_subclause */
+   -2,  /* (44) ccons ::= COLLATE ID|STRING */
+   -3,  /* (45) generated ::= LP expr RP */
+   -4,  /* (46) generated ::= LP expr RP ID */
+    0,  /* (47) autoinc ::= */
+   -1,  /* (48) autoinc ::= AUTOINCR */
+    0,  /* (49) refargs ::= */
+   -2,  /* (50) refargs ::= refargs refarg */
+   -2,  /* (51) refarg ::= MATCH nm */
+   -3,  /* (52) refarg ::= ON INSERT refact */
+   -3,  /* (53) refarg ::= ON DELETE refact */
+   -3,  /* (54) refarg ::= ON UPDATE refact */
+   -2,  /* (55) refact ::= SET NULL */
+   -2,  /* (56) refact ::= SET DEFAULT */
+   -1,  /* (57) refact ::= CASCADE */
+   -1,  /* (58) refact ::= RESTRICT */
+   -2,  /* (59) refact ::= NO ACTION */
+   -3,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
+   -2,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
+    0,  /* (62) init_deferred_pred_opt ::= */
+   -2,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
+   -2,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
+    0,  /* (65) conslist_opt ::= */
+   -1,  /* (66) tconscomma ::= COMMA */
+   -2,  /* (67) tcons ::= CONSTRAINT nm */
+   -7,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
+   -5,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
+   -5,  /* (70) tcons ::= CHECK LP expr RP onconf */
+  -10,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
+    0,  /* (72) defer_subclause_opt ::= */
+    0,  /* (73) onconf ::= */
+   -3,  /* (74) onconf ::= ON CONFLICT resolvetype */
+    0,  /* (75) orconf ::= */
+   -2,  /* (76) orconf ::= OR resolvetype */
+   -1,  /* (77) resolvetype ::= IGNORE */
+   -1,  /* (78) resolvetype ::= REPLACE */
+   -4,  /* (79) cmd ::= DROP TABLE ifexists fullname */
+   -2,  /* (80) ifexists ::= IF EXISTS */
+    0,  /* (81) ifexists ::= */
+   -9,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
+   -4,  /* (83) cmd ::= DROP VIEW ifexists fullname */
+   -1,  /* (84) cmd ::= select */
+   -3,  /* (85) select ::= WITH wqlist selectnowith */
+   -4,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
+   -1,  /* (87) select ::= selectnowith */
+   -3,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
+   -1,  /* (89) multiselect_op ::= UNION */
+   -2,  /* (90) multiselect_op ::= UNION ALL */
+   -1,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
+   -9,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
+  -10,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
+   -4,  /* (94) values ::= VALUES LP nexprlist RP */
+   -5,  /* (95) values ::= values COMMA LP nexprlist RP */
+   -1,  /* (96) distinct ::= DISTINCT */
+   -1,  /* (97) distinct ::= ALL */
+    0,  /* (98) distinct ::= */
+    0,  /* (99) sclp ::= */
+   -5,  /* (100) selcollist ::= sclp scanpt expr scanpt as */
+   -3,  /* (101) selcollist ::= sclp scanpt STAR */
+   -5,  /* (102) selcollist ::= sclp scanpt nm DOT STAR */
+   -2,  /* (103) as ::= AS nm */
+    0,  /* (104) as ::= */
+    0,  /* (105) from ::= */
+   -2,  /* (106) from ::= FROM seltablist */
+   -2,  /* (107) stl_prefix ::= seltablist joinop */
+    0,  /* (108) stl_prefix ::= */
+   -7,  /* (109) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
+   -9,  /* (110) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
+   -7,  /* (111) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
+   -7,  /* (112) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
+    0,  /* (113) dbnm ::= */
+   -2,  /* (114) dbnm ::= DOT nm */
+   -1,  /* (115) fullname ::= nm */
+   -3,  /* (116) fullname ::= nm DOT nm */
+   -1,  /* (117) xfullname ::= nm */
+   -3,  /* (118) xfullname ::= nm DOT nm */
+   -5,  /* (119) xfullname ::= nm DOT nm AS nm */
+   -3,  /* (120) xfullname ::= nm AS nm */
+   -1,  /* (121) joinop ::= COMMA|JOIN */
+   -2,  /* (122) joinop ::= JOIN_KW JOIN */
+   -3,  /* (123) joinop ::= JOIN_KW nm JOIN */
+   -4,  /* (124) joinop ::= JOIN_KW nm nm JOIN */
+   -2,  /* (125) on_opt ::= ON expr */
+    0,  /* (126) on_opt ::= */
+    0,  /* (127) indexed_opt ::= */
+   -3,  /* (128) indexed_opt ::= INDEXED BY nm */
+   -2,  /* (129) indexed_opt ::= NOT INDEXED */
+   -4,  /* (130) using_opt ::= USING LP idlist RP */
+    0,  /* (131) using_opt ::= */
+    0,  /* (132) orderby_opt ::= */
+   -3,  /* (133) orderby_opt ::= ORDER BY sortlist */
+   -5,  /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */
+   -3,  /* (135) sortlist ::= expr sortorder nulls */
+   -1,  /* (136) sortorder ::= ASC */
+   -1,  /* (137) sortorder ::= DESC */
+    0,  /* (138) sortorder ::= */
+   -2,  /* (139) nulls ::= NULLS FIRST */
+   -2,  /* (140) nulls ::= NULLS LAST */
+    0,  /* (141) nulls ::= */
+    0,  /* (142) groupby_opt ::= */
+   -3,  /* (143) groupby_opt ::= GROUP BY nexprlist */
+    0,  /* (144) having_opt ::= */
+   -2,  /* (145) having_opt ::= HAVING expr */
+    0,  /* (146) limit_opt ::= */
+   -2,  /* (147) limit_opt ::= LIMIT expr */
+   -4,  /* (148) limit_opt ::= LIMIT expr OFFSET expr */
+   -4,  /* (149) limit_opt ::= LIMIT expr COMMA expr */
+   -6,  /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
+    0,  /* (151) where_opt ::= */
+   -2,  /* (152) where_opt ::= WHERE expr */
+    0,  /* (153) where_opt_ret ::= */
+   -2,  /* (154) where_opt_ret ::= WHERE expr */
+   -2,  /* (155) where_opt_ret ::= RETURNING selcollist */
+   -4,  /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */
+   -9,  /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
+   -5,  /* (158) setlist ::= setlist COMMA nm EQ expr */
+   -7,  /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */
+   -3,  /* (160) setlist ::= nm EQ expr */
+   -5,  /* (161) setlist ::= LP idlist RP EQ expr */
+   -7,  /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+   -8,  /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
+    0,  /* (164) upsert ::= */
+   -2,  /* (165) upsert ::= RETURNING selcollist */
+  -12,  /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+   -9,  /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+   -5,  /* (168) upsert ::= ON CONFLICT DO NOTHING returning */
+   -8,  /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+   -2,  /* (170) returning ::= RETURNING selcollist */
+   -2,  /* (171) insert_cmd ::= INSERT orconf */
+   -1,  /* (172) insert_cmd ::= REPLACE */
+    0,  /* (173) idlist_opt ::= */
+   -3,  /* (174) idlist_opt ::= LP idlist RP */
+   -3,  /* (175) idlist ::= idlist COMMA nm */
+   -1,  /* (176) idlist ::= nm */
+   -3,  /* (177) expr ::= LP expr RP */
+   -1,  /* (178) expr ::= ID|INDEXED */
+   -1,  /* (179) expr ::= JOIN_KW */
+   -3,  /* (180) expr ::= nm DOT nm */
+   -5,  /* (181) expr ::= nm DOT nm DOT nm */
+   -1,  /* (182) term ::= NULL|FLOAT|BLOB */
+   -1,  /* (183) term ::= STRING */
+   -1,  /* (184) term ::= INTEGER */
+   -1,  /* (185) expr ::= VARIABLE */
+   -3,  /* (186) expr ::= expr COLLATE ID|STRING */
+   -6,  /* (187) expr ::= CAST LP expr AS typetoken RP */
+   -5,  /* (188) expr ::= ID|INDEXED LP distinct exprlist RP */
+   -4,  /* (189) expr ::= ID|INDEXED LP STAR RP */
+   -6,  /* (190) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
+   -5,  /* (191) expr ::= ID|INDEXED LP STAR RP filter_over */
+   -1,  /* (192) term ::= CTIME_KW */
+   -5,  /* (193) expr ::= LP nexprlist COMMA expr RP */
+   -3,  /* (194) expr ::= expr AND expr */
+   -3,  /* (195) expr ::= expr OR expr */
+   -3,  /* (196) expr ::= expr LT|GT|GE|LE expr */
+   -3,  /* (197) expr ::= expr EQ|NE expr */
+   -3,  /* (198) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
+   -3,  /* (199) expr ::= expr PLUS|MINUS expr */
+   -3,  /* (200) expr ::= expr STAR|SLASH|REM expr */
+   -3,  /* (201) expr ::= expr CONCAT expr */
+   -2,  /* (202) likeop ::= NOT LIKE_KW|MATCH */
+   -3,  /* (203) expr ::= expr likeop expr */
+   -5,  /* (204) expr ::= expr likeop expr ESCAPE expr */
+   -2,  /* (205) expr ::= expr ISNULL|NOTNULL */
+   -3,  /* (206) expr ::= expr NOT NULL */
+   -3,  /* (207) expr ::= expr IS expr */
+   -4,  /* (208) expr ::= expr IS NOT expr */
+   -2,  /* (209) expr ::= NOT expr */
+   -2,  /* (210) expr ::= BITNOT expr */
+   -2,  /* (211) expr ::= PLUS|MINUS expr */
+   -1,  /* (212) between_op ::= BETWEEN */
+   -2,  /* (213) between_op ::= NOT BETWEEN */
+   -5,  /* (214) expr ::= expr between_op expr AND expr */
+   -1,  /* (215) in_op ::= IN */
+   -2,  /* (216) in_op ::= NOT IN */
+   -5,  /* (217) expr ::= expr in_op LP exprlist RP */
+   -3,  /* (218) expr ::= LP select RP */
+   -5,  /* (219) expr ::= expr in_op LP select RP */
+   -5,  /* (220) expr ::= expr in_op nm dbnm paren_exprlist */
+   -4,  /* (221) expr ::= EXISTS LP select RP */
+   -5,  /* (222) expr ::= CASE case_operand case_exprlist case_else END */
+   -5,  /* (223) case_exprlist ::= case_exprlist WHEN expr THEN expr */
+   -4,  /* (224) case_exprlist ::= WHEN expr THEN expr */
+   -2,  /* (225) case_else ::= ELSE expr */
+    0,  /* (226) case_else ::= */
+   -1,  /* (227) case_operand ::= expr */
+    0,  /* (228) case_operand ::= */
+    0,  /* (229) exprlist ::= */
+   -3,  /* (230) nexprlist ::= nexprlist COMMA expr */
+   -1,  /* (231) nexprlist ::= expr */
+    0,  /* (232) paren_exprlist ::= */
+   -3,  /* (233) paren_exprlist ::= LP exprlist RP */
+  -12,  /* (234) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+   -1,  /* (235) uniqueflag ::= UNIQUE */
+    0,  /* (236) uniqueflag ::= */
+    0,  /* (237) eidlist_opt ::= */
+   -3,  /* (238) eidlist_opt ::= LP eidlist RP */
+   -5,  /* (239) eidlist ::= eidlist COMMA nm collate sortorder */
+   -3,  /* (240) eidlist ::= nm collate sortorder */
+    0,  /* (241) collate ::= */
+   -2,  /* (242) collate ::= COLLATE ID|STRING */
+   -4,  /* (243) cmd ::= DROP INDEX ifexists fullname */
+   -2,  /* (244) cmd ::= VACUUM vinto */
+   -3,  /* (245) cmd ::= VACUUM nm vinto */
+   -2,  /* (246) vinto ::= INTO expr */
+    0,  /* (247) vinto ::= */
+   -3,  /* (248) cmd ::= PRAGMA nm dbnm */
+   -5,  /* (249) cmd ::= PRAGMA nm dbnm EQ nmnum */
+   -6,  /* (250) cmd ::= PRAGMA nm dbnm LP nmnum RP */
+   -5,  /* (251) cmd ::= PRAGMA nm dbnm EQ minus_num */
+   -6,  /* (252) cmd ::= PRAGMA nm dbnm LP minus_num RP */
+   -2,  /* (253) plus_num ::= PLUS INTEGER|FLOAT */
+   -2,  /* (254) minus_num ::= MINUS INTEGER|FLOAT */
+   -5,  /* (255) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+  -11,  /* (256) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+   -1,  /* (257) trigger_time ::= BEFORE|AFTER */
+   -2,  /* (258) trigger_time ::= INSTEAD OF */
+    0,  /* (259) trigger_time ::= */
+   -1,  /* (260) trigger_event ::= DELETE|INSERT */
+   -1,  /* (261) trigger_event ::= UPDATE */
+   -3,  /* (262) trigger_event ::= UPDATE OF idlist */
+    0,  /* (263) when_clause ::= */
+   -2,  /* (264) when_clause ::= WHEN expr */
+   -3,  /* (265) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+   -2,  /* (266) trigger_cmd_list ::= trigger_cmd SEMI */
+   -3,  /* (267) trnm ::= nm DOT nm */
+   -3,  /* (268) tridxby ::= INDEXED BY nm */
+   -2,  /* (269) tridxby ::= NOT INDEXED */
+   -9,  /* (270) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+   -8,  /* (271) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+   -6,  /* (272) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+   -3,  /* (273) trigger_cmd ::= scanpt select scanpt */
+   -4,  /* (274) expr ::= RAISE LP IGNORE RP */
+   -6,  /* (275) expr ::= RAISE LP raisetype COMMA nm RP */
+   -1,  /* (276) raisetype ::= ROLLBACK */
+   -1,  /* (277) raisetype ::= ABORT */
+   -1,  /* (278) raisetype ::= FAIL */
+   -4,  /* (279) cmd ::= DROP TRIGGER ifexists fullname */
+   -6,  /* (280) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+   -3,  /* (281) cmd ::= DETACH database_kw_opt expr */
+    0,  /* (282) key_opt ::= */
+   -2,  /* (283) key_opt ::= KEY expr */
+   -1,  /* (284) cmd ::= REINDEX */
+   -3,  /* (285) cmd ::= REINDEX nm dbnm */
+   -1,  /* (286) cmd ::= ANALYZE */
+   -3,  /* (287) cmd ::= ANALYZE nm dbnm */
+   -6,  /* (288) cmd ::= ALTER TABLE fullname RENAME TO nm */
+   -7,  /* (289) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+   -6,  /* (290) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+   -1,  /* (291) add_column_fullname ::= fullname */
+   -8,  /* (292) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+   -1,  /* (293) cmd ::= create_vtab */
+   -4,  /* (294) cmd ::= create_vtab LP vtabarglist RP */
+   -8,  /* (295) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+    0,  /* (296) vtabarg ::= */
+   -1,  /* (297) vtabargtoken ::= ANY */
+   -3,  /* (298) vtabargtoken ::= lp anylist RP */
+   -1,  /* (299) lp ::= LP */
+   -2,  /* (300) with ::= WITH wqlist */
+   -3,  /* (301) with ::= WITH RECURSIVE wqlist */
+   -1,  /* (302) wqas ::= AS */
+   -2,  /* (303) wqas ::= AS MATERIALIZED */
+   -3,  /* (304) wqas ::= AS NOT MATERIALIZED */
+   -6,  /* (305) wqitem ::= nm eidlist_opt wqas LP select RP */
+   -1,  /* (306) wqlist ::= wqitem */
+   -3,  /* (307) wqlist ::= wqlist COMMA wqitem */
+   -1,  /* (308) windowdefn_list ::= windowdefn */
+   -3,  /* (309) windowdefn_list ::= windowdefn_list COMMA windowdefn */
+   -5,  /* (310) windowdefn ::= nm AS LP window RP */
+   -5,  /* (311) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+   -6,  /* (312) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+   -4,  /* (313) window ::= ORDER BY sortlist frame_opt */
+   -5,  /* (314) window ::= nm ORDER BY sortlist frame_opt */
+   -1,  /* (315) window ::= frame_opt */
+   -2,  /* (316) window ::= nm frame_opt */
+    0,  /* (317) frame_opt ::= */
+   -3,  /* (318) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+   -6,  /* (319) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+   -1,  /* (320) range_or_rows ::= RANGE|ROWS|GROUPS */
+   -1,  /* (321) frame_bound_s ::= frame_bound */
+   -2,  /* (322) frame_bound_s ::= UNBOUNDED PRECEDING */
+   -1,  /* (323) frame_bound_e ::= frame_bound */
+   -2,  /* (324) frame_bound_e ::= UNBOUNDED FOLLOWING */
+   -2,  /* (325) frame_bound ::= expr PRECEDING|FOLLOWING */
+   -2,  /* (326) frame_bound ::= CURRENT ROW */
+    0,  /* (327) frame_exclude_opt ::= */
+   -2,  /* (328) frame_exclude_opt ::= EXCLUDE frame_exclude */
+   -2,  /* (329) frame_exclude ::= NO OTHERS */
+   -2,  /* (330) frame_exclude ::= CURRENT ROW */
+   -1,  /* (331) frame_exclude ::= GROUP|TIES */
+   -2,  /* (332) window_clause ::= WINDOW windowdefn_list */
+   -2,  /* (333) filter_over ::= filter_clause over_clause */
+   -1,  /* (334) filter_over ::= over_clause */
+   -1,  /* (335) filter_over ::= filter_clause */
+   -4,  /* (336) over_clause ::= OVER LP window RP */
+   -2,  /* (337) over_clause ::= OVER nm */
+   -5,  /* (338) filter_clause ::= FILTER LP WHERE expr RP */
+   -1,  /* (339) input ::= cmdlist */
+   -2,  /* (340) cmdlist ::= cmdlist ecmd */
+   -1,  /* (341) cmdlist ::= ecmd */
+   -1,  /* (342) ecmd ::= SEMI */
+   -2,  /* (343) ecmd ::= cmdx SEMI */
+   -3,  /* (344) ecmd ::= explain cmdx SEMI */
+    0,  /* (345) trans_opt ::= */
+   -1,  /* (346) trans_opt ::= TRANSACTION */
+   -2,  /* (347) trans_opt ::= TRANSACTION nm */
+   -1,  /* (348) savepoint_opt ::= SAVEPOINT */
+    0,  /* (349) savepoint_opt ::= */
+   -2,  /* (350) cmd ::= create_table create_table_args */
+   -1,  /* (351) table_option_set ::= table_option */
+   -4,  /* (352) columnlist ::= columnlist COMMA columnname carglist */
+   -2,  /* (353) columnlist ::= columnname carglist */
+   -1,  /* (354) nm ::= ID|INDEXED */
+   -1,  /* (355) nm ::= STRING */
+   -1,  /* (356) nm ::= JOIN_KW */
+   -1,  /* (357) typetoken ::= typename */
+   -1,  /* (358) typename ::= ID|STRING */
+   -1,  /* (359) signed ::= plus_num */
+   -1,  /* (360) signed ::= minus_num */
+   -2,  /* (361) carglist ::= carglist ccons */
+    0,  /* (362) carglist ::= */
+   -2,  /* (363) ccons ::= NULL onconf */
+   -4,  /* (364) ccons ::= GENERATED ALWAYS AS generated */
+   -2,  /* (365) ccons ::= AS generated */
+   -2,  /* (366) conslist_opt ::= COMMA conslist */
+   -3,  /* (367) conslist ::= conslist tconscomma tcons */
+   -1,  /* (368) conslist ::= tcons */
+    0,  /* (369) tconscomma ::= */
+   -1,  /* (370) defer_subclause_opt ::= defer_subclause */
+   -1,  /* (371) resolvetype ::= raisetype */
+   -1,  /* (372) selectnowith ::= oneselect */
+   -1,  /* (373) oneselect ::= values */
+   -2,  /* (374) sclp ::= selcollist COMMA */
+   -1,  /* (375) as ::= ID|STRING */
+    0,  /* (376) returning ::= */
+   -1,  /* (377) expr ::= term */
+   -1,  /* (378) likeop ::= LIKE_KW|MATCH */
+   -1,  /* (379) exprlist ::= nexprlist */
+   -1,  /* (380) nmnum ::= plus_num */
+   -1,  /* (381) nmnum ::= nm */
+   -1,  /* (382) nmnum ::= ON */
+   -1,  /* (383) nmnum ::= DELETE */
+   -1,  /* (384) nmnum ::= DEFAULT */
+   -1,  /* (385) plus_num ::= INTEGER|FLOAT */
+    0,  /* (386) foreach_clause ::= */
+   -3,  /* (387) foreach_clause ::= FOR EACH ROW */
+   -1,  /* (388) trnm ::= nm */
+    0,  /* (389) tridxby ::= */
+   -1,  /* (390) database_kw_opt ::= DATABASE */
+    0,  /* (391) database_kw_opt ::= */
+    0,  /* (392) kwcolumn_opt ::= */
+   -1,  /* (393) kwcolumn_opt ::= COLUMNKW */
+   -1,  /* (394) vtabarglist ::= vtabarg */
+   -3,  /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */
+   -2,  /* (396) vtabarg ::= vtabarg vtabargtoken */
+    0,  /* (397) anylist ::= */
+   -4,  /* (398) anylist ::= anylist LP anylist RP */
+   -2,  /* (399) anylist ::= anylist ANY */
+    0,  /* (400) with ::= */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -158281,55 +162981,6 @@ static YYACTIONTYPE yy_reduce(
   (void)yyLookahead;
   (void)yyLookaheadToken;
   yymsp = yypParser->yytos;
-  assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
-#ifndef NDEBUG
-  if( yyTraceFILE ){
-    yysize = yyRuleInfoNRhs[yyruleno];
-    if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
-        yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno],
-        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
-        yymsp[yysize].stateno);
-    }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
-        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
-    }
-  }
-#endif /* NDEBUG */
-
-  /* Check that the stack is large enough to grow by a single entry
-  ** if the RHS of the rule is empty.  This ensures that there is room
-  ** enough on the stack to push the LHS value */
-  if( yyRuleInfoNRhs[yyruleno]==0 ){
-#ifdef YYTRACKMAXSTACKDEPTH
-    if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
-      yypParser->yyhwm++;
-      assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
-    }
-#endif
-#if YYSTACKDEPTH>0
-    if( yypParser->yytos>=yypParser->yystackEnd ){
-      yyStackOverflow(yypParser);
-      /* The call to yyStackOverflow() above pops the stack until it is
-      ** empty, causing the main parser loop to exit.  So the return value
-      ** is never used and does not matter. */
-      return 0;
-    }
-#else
-    if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
-      if( yyGrowStack(yypParser) ){
-        yyStackOverflow(yypParser);
-        /* The call to yyStackOverflow() above pops the stack until it is
-        ** empty, causing the main parser loop to exit.  So the return value
-        ** is never used and does not matter. */
-        return 0;
-      }
-      yymsp = yypParser->yytos;
-    }
-#endif
-  }
 
   switch( yyruleno ){
   /* Beginning here are the reduction cases.  A typical example
@@ -158352,16 +163003,16 @@ static YYACTIONTYPE yy_reduce(
 { sqlite3FinishCoding(pParse); }
         break;
       case 3: /* cmd ::= BEGIN transtype trans_opt */
-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy192);}
+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy64);}
         break;
       case 4: /* transtype ::= */
-{yymsp[1].minor.yy192 = TK_DEFERRED;}
+{yymsp[1].minor.yy64 = TK_DEFERRED;}
         break;
       case 5: /* transtype ::= DEFERRED */
       case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
       case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
-      case 306: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==306);
-{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/}
+      case 320: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==320);
+{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/}
         break;
       case 8: /* cmd ::= COMMIT|END trans_opt */
       case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
@@ -158384,7 +163035,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
 {
-   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy192,0,0,yymsp[-2].minor.yy192);
+   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy64,0,0,yymsp[-2].minor.yy64);
 }
         break;
       case 14: /* createkw ::= CREATE */
@@ -158392,96 +163043,112 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 15: /* ifnotexists ::= */
       case 18: /* temp ::= */ yytestcase(yyruleno==18);
-      case 21: /* table_options ::= */ yytestcase(yyruleno==21);
-      case 45: /* autoinc ::= */ yytestcase(yyruleno==45);
-      case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60);
-      case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70);
-      case 79: /* ifexists ::= */ yytestcase(yyruleno==79);
-      case 96: /* distinct ::= */ yytestcase(yyruleno==96);
-      case 232: /* collate ::= */ yytestcase(yyruleno==232);
-{yymsp[1].minor.yy192 = 0;}
+      case 47: /* autoinc ::= */ yytestcase(yyruleno==47);
+      case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
+      case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
+      case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
+      case 98: /* distinct ::= */ yytestcase(yyruleno==98);
+      case 241: /* collate ::= */ yytestcase(yyruleno==241);
+{yymsp[1].minor.yy64 = 0;}
         break;
       case 16: /* ifnotexists ::= IF NOT EXISTS */
-{yymsp[-2].minor.yy192 = 1;}
+{yymsp[-2].minor.yy64 = 1;}
         break;
       case 17: /* temp ::= TEMP */
-      case 46: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==46);
-{yymsp[0].minor.yy192 = 1;}
+{yymsp[0].minor.yy64 = pParse->db->init.busy==0;}
         break;
-      case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
+      case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
 {
-  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy192,0);
+  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy51,0);
 }
         break;
       case 20: /* create_table_args ::= AS select */
 {
-  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy539);
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539);
+  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy303);
+  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303);
 }
         break;
-      case 22: /* table_options ::= WITHOUT nm */
+      case 21: /* table_option_set ::= */
+{yymsp[1].minor.yy51 = 0;}
+        break;
+      case 22: /* table_option_set ::= table_option_set COMMA table_option */
+{yylhsminor.yy51 = yymsp[-2].minor.yy51|yymsp[0].minor.yy51;}
+  yymsp[-2].minor.yy51 = yylhsminor.yy51;
+        break;
+      case 23: /* table_option ::= WITHOUT nm */
 {
   if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
-    yymsp[-1].minor.yy192 = TF_WithoutRowid | TF_NoVisibleRowid;
+    yymsp[-1].minor.yy51 = TF_WithoutRowid | TF_NoVisibleRowid;
+  }else{
+    yymsp[-1].minor.yy51 = 0;
+    sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
+  }
+}
+        break;
+      case 24: /* table_option ::= nm */
+{
+  if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
+    yylhsminor.yy51 = TF_Strict;
   }else{
-    yymsp[-1].minor.yy192 = 0;
+    yylhsminor.yy51 = 0;
     sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
   }
 }
+  yymsp[0].minor.yy51 = yylhsminor.yy51;
         break;
-      case 23: /* columnname ::= nm typetoken */
-{sqlite3AddColumn(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
+      case 25: /* columnname ::= nm typetoken */
+{sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
         break;
-      case 24: /* typetoken ::= */
-      case 63: /* conslist_opt ::= */ yytestcase(yyruleno==63);
-      case 102: /* as ::= */ yytestcase(yyruleno==102);
+      case 26: /* typetoken ::= */
+      case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
+      case 104: /* as ::= */ yytestcase(yyruleno==104);
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
         break;
-      case 25: /* typetoken ::= typename LP signed RP */
+      case 27: /* typetoken ::= typename LP signed RP */
 {
   yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
 }
         break;
-      case 26: /* typetoken ::= typename LP signed COMMA signed RP */
+      case 28: /* typetoken ::= typename LP signed COMMA signed RP */
 {
   yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
 }
         break;
-      case 27: /* typename ::= typename ID|STRING */
+      case 29: /* typename ::= typename ID|STRING */
 {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
         break;
-      case 28: /* scanpt ::= */
+      case 30: /* scanpt ::= */
 {
   assert( yyLookahead!=YYNOCODE );
-  yymsp[1].minor.yy436 = yyLookaheadToken.z;
+  yymsp[1].minor.yy600 = yyLookaheadToken.z;
 }
         break;
-      case 29: /* scantok ::= */
+      case 31: /* scantok ::= */
 {
   assert( yyLookahead!=YYNOCODE );
   yymsp[1].minor.yy0 = yyLookaheadToken;
 }
         break;
-      case 30: /* ccons ::= CONSTRAINT nm */
-      case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65);
+      case 32: /* ccons ::= CONSTRAINT nm */
+      case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
 {pParse->constraintName = yymsp[0].minor.yy0;}
         break;
-      case 31: /* ccons ::= DEFAULT scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
+      case 33: /* ccons ::= DEFAULT scantok term */
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
         break;
-      case 32: /* ccons ::= DEFAULT LP expr RP */
-{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
+      case 34: /* ccons ::= DEFAULT LP expr RP */
+{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
         break;
-      case 33: /* ccons ::= DEFAULT PLUS scantok term */
-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy202,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
+      case 35: /* ccons ::= DEFAULT PLUS scantok term */
+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy626,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
         break;
-      case 34: /* ccons ::= DEFAULT MINUS scantok term */
+      case 36: /* ccons ::= DEFAULT MINUS scantok term */
 {
-  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy202, 0);
+  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy626, 0);
   sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
 }
         break;
-      case 35: /* ccons ::= DEFAULT scantok ID|INDEXED */
+      case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
 {
   Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0);
   if( p ){
@@ -158491,177 +163158,162 @@ static YYACTIONTYPE yy_reduce(
     sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
 }
         break;
-      case 36: /* ccons ::= NOT NULL onconf */
-{sqlite3AddNotNull(pParse, yymsp[0].minor.yy192);}
+      case 38: /* ccons ::= NOT NULL onconf */
+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy64);}
         break;
-      case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy192,yymsp[0].minor.yy192,yymsp[-2].minor.yy192);}
+      case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy64,yymsp[0].minor.yy64,yymsp[-2].minor.yy64);}
         break;
-      case 38: /* ccons ::= UNIQUE onconf */
-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy192,0,0,0,0,
+      case 40: /* ccons ::= UNIQUE onconf */
+{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy64,0,0,0,0,
                                    SQLITE_IDXTYPE_UNIQUE);}
         break;
-      case 39: /* ccons ::= CHECK LP expr RP */
-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy202,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
+      case 41: /* ccons ::= CHECK LP expr RP */
+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy626,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
         break;
-      case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */
-{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy242,yymsp[0].minor.yy192);}
+      case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy562,yymsp[0].minor.yy64);}
         break;
-      case 41: /* ccons ::= defer_subclause */
-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy192);}
+      case 43: /* ccons ::= defer_subclause */
+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy64);}
         break;
-      case 42: /* ccons ::= COLLATE ID|STRING */
+      case 44: /* ccons ::= COLLATE ID|STRING */
 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
         break;
-      case 43: /* generated ::= LP expr RP */
-{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy202,0);}
+      case 45: /* generated ::= LP expr RP */
+{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy626,0);}
+        break;
+      case 46: /* generated ::= LP expr RP ID */
+{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy626,&yymsp[0].minor.yy0);}
         break;
-      case 44: /* generated ::= LP expr RP ID */
-{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy202,&yymsp[0].minor.yy0);}
+      case 48: /* autoinc ::= AUTOINCR */
+{yymsp[0].minor.yy64 = 1;}
         break;
-      case 47: /* refargs ::= */
-{ yymsp[1].minor.yy192 = OE_None*0x0101; /* EV: R-19803-45884 */}
+      case 49: /* refargs ::= */
+{ yymsp[1].minor.yy64 = OE_None*0x0101; /* EV: R-19803-45884 */}
         break;
-      case 48: /* refargs ::= refargs refarg */
-{ yymsp[-1].minor.yy192 = (yymsp[-1].minor.yy192 & ~yymsp[0].minor.yy207.mask) | yymsp[0].minor.yy207.value; }
+      case 50: /* refargs ::= refargs refarg */
+{ yymsp[-1].minor.yy64 = (yymsp[-1].minor.yy64 & ~yymsp[0].minor.yy83.mask) | yymsp[0].minor.yy83.value; }
         break;
-      case 49: /* refarg ::= MATCH nm */
-{ yymsp[-1].minor.yy207.value = 0;     yymsp[-1].minor.yy207.mask = 0x000000; }
+      case 51: /* refarg ::= MATCH nm */
+{ yymsp[-1].minor.yy83.value = 0;     yymsp[-1].minor.yy83.mask = 0x000000; }
         break;
-      case 50: /* refarg ::= ON INSERT refact */
-{ yymsp[-2].minor.yy207.value = 0;     yymsp[-2].minor.yy207.mask = 0x000000; }
+      case 52: /* refarg ::= ON INSERT refact */
+{ yymsp[-2].minor.yy83.value = 0;     yymsp[-2].minor.yy83.mask = 0x000000; }
         break;
-      case 51: /* refarg ::= ON DELETE refact */
-{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192;     yymsp[-2].minor.yy207.mask = 0x0000ff; }
+      case 53: /* refarg ::= ON DELETE refact */
+{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64;     yymsp[-2].minor.yy83.mask = 0x0000ff; }
         break;
-      case 52: /* refarg ::= ON UPDATE refact */
-{ yymsp[-2].minor.yy207.value = yymsp[0].minor.yy192<<8;  yymsp[-2].minor.yy207.mask = 0x00ff00; }
+      case 54: /* refarg ::= ON UPDATE refact */
+{ yymsp[-2].minor.yy83.value = yymsp[0].minor.yy64<<8;  yymsp[-2].minor.yy83.mask = 0x00ff00; }
         break;
-      case 53: /* refact ::= SET NULL */
-{ yymsp[-1].minor.yy192 = OE_SetNull;  /* EV: R-33326-45252 */}
+      case 55: /* refact ::= SET NULL */
+{ yymsp[-1].minor.yy64 = OE_SetNull;  /* EV: R-33326-45252 */}
         break;
-      case 54: /* refact ::= SET DEFAULT */
-{ yymsp[-1].minor.yy192 = OE_SetDflt;  /* EV: R-33326-45252 */}
+      case 56: /* refact ::= SET DEFAULT */
+{ yymsp[-1].minor.yy64 = OE_SetDflt;  /* EV: R-33326-45252 */}
         break;
-      case 55: /* refact ::= CASCADE */
-{ yymsp[0].minor.yy192 = OE_Cascade;  /* EV: R-33326-45252 */}
+      case 57: /* refact ::= CASCADE */
+{ yymsp[0].minor.yy64 = OE_Cascade;  /* EV: R-33326-45252 */}
         break;
-      case 56: /* refact ::= RESTRICT */
-{ yymsp[0].minor.yy192 = OE_Restrict; /* EV: R-33326-45252 */}
+      case 58: /* refact ::= RESTRICT */
+{ yymsp[0].minor.yy64 = OE_Restrict; /* EV: R-33326-45252 */}
         break;
-      case 57: /* refact ::= NO ACTION */
-{ yymsp[-1].minor.yy192 = OE_None;     /* EV: R-33326-45252 */}
+      case 59: /* refact ::= NO ACTION */
+{ yymsp[-1].minor.yy64 = OE_None;     /* EV: R-33326-45252 */}
         break;
-      case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
-{yymsp[-2].minor.yy192 = 0;}
+      case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
+{yymsp[-2].minor.yy64 = 0;}
         break;
-      case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
-      case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74);
-      case 162: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==162);
-{yymsp[-1].minor.yy192 = yymsp[0].minor.yy192;}
+      case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
+      case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
+      case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171);
+{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;}
         break;
-      case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
-      case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78);
-      case 204: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==204);
-      case 207: /* in_op ::= NOT IN */ yytestcase(yyruleno==207);
-      case 233: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==233);
-{yymsp[-1].minor.yy192 = 1;}
+      case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
+      case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
+      case 213: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==213);
+      case 216: /* in_op ::= NOT IN */ yytestcase(yyruleno==216);
+      case 242: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==242);
+{yymsp[-1].minor.yy64 = 1;}
         break;
-      case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
-{yymsp[-1].minor.yy192 = 0;}
+      case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
+{yymsp[-1].minor.yy64 = 0;}
         break;
-      case 64: /* tconscomma ::= COMMA */
+      case 66: /* tconscomma ::= COMMA */
 {pParse->constraintName.n = 0;}
         break;
-      case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy242,yymsp[0].minor.yy192,yymsp[-2].minor.yy192,0);}
+      case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy562,yymsp[0].minor.yy64,yymsp[-2].minor.yy64,0);}
         break;
-      case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */
-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy242,yymsp[0].minor.yy192,0,0,0,0,
+      case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
+{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy562,yymsp[0].minor.yy64,0,0,0,0,
                                        SQLITE_IDXTYPE_UNIQUE);}
         break;
-      case 68: /* tcons ::= CHECK LP expr RP onconf */
-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy202,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
+      case 70: /* tcons ::= CHECK LP expr RP onconf */
+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy626,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
         break;
-      case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
+      case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
 {
-    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy242, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[-1].minor.yy192);
-    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy192);
+    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy562, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[-1].minor.yy64);
+    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy64);
 }
         break;
-      case 71: /* onconf ::= */
-      case 73: /* orconf ::= */ yytestcase(yyruleno==73);
-{yymsp[1].minor.yy192 = OE_Default;}
+      case 73: /* onconf ::= */
+      case 75: /* orconf ::= */ yytestcase(yyruleno==75);
+{yymsp[1].minor.yy64 = OE_Default;}
         break;
-      case 72: /* onconf ::= ON CONFLICT resolvetype */
-{yymsp[-2].minor.yy192 = yymsp[0].minor.yy192;}
+      case 74: /* onconf ::= ON CONFLICT resolvetype */
+{yymsp[-2].minor.yy64 = yymsp[0].minor.yy64;}
         break;
-      case 75: /* resolvetype ::= IGNORE */
-{yymsp[0].minor.yy192 = OE_Ignore;}
+      case 77: /* resolvetype ::= IGNORE */
+{yymsp[0].minor.yy64 = OE_Ignore;}
         break;
-      case 76: /* resolvetype ::= REPLACE */
-      case 163: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==163);
-{yymsp[0].minor.yy192 = OE_Replace;}
+      case 78: /* resolvetype ::= REPLACE */
+      case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172);
+{yymsp[0].minor.yy64 = OE_Replace;}
         break;
-      case 77: /* cmd ::= DROP TABLE ifexists fullname */
+      case 79: /* cmd ::= DROP TABLE ifexists fullname */
 {
-  sqlite3DropTable(pParse, yymsp[0].minor.yy47, 0, yymsp[-1].minor.yy192);
+  sqlite3DropTable(pParse, yymsp[0].minor.yy607, 0, yymsp[-1].minor.yy64);
 }
         break;
-      case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
+      case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
 {
-  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy242, yymsp[0].minor.yy539, yymsp[-7].minor.yy192, yymsp[-5].minor.yy192);
+  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy562, yymsp[0].minor.yy303, yymsp[-7].minor.yy64, yymsp[-5].minor.yy64);
 }
         break;
-      case 81: /* cmd ::= DROP VIEW ifexists fullname */
+      case 83: /* cmd ::= DROP VIEW ifexists fullname */
 {
-  sqlite3DropTable(pParse, yymsp[0].minor.yy47, 1, yymsp[-1].minor.yy192);
+  sqlite3DropTable(pParse, yymsp[0].minor.yy607, 1, yymsp[-1].minor.yy64);
 }
         break;
-      case 82: /* cmd ::= select */
+      case 84: /* cmd ::= select */
 {
   SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
-  sqlite3Select(pParse, yymsp[0].minor.yy539, &dest);
-  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy539);
+  sqlite3Select(pParse, yymsp[0].minor.yy303, &dest);
+  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy303);
 }
         break;
-      case 83: /* select ::= WITH wqlist selectnowith */
-{
-  Select *p = yymsp[0].minor.yy539;
-  if( p ){
-    p->pWith = yymsp[-1].minor.yy131;
-    parserDoubleLinkSelect(pParse, p);
-  }else{
-    sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131);
-  }
-  yymsp[-2].minor.yy539 = p;
-}
+      case 85: /* select ::= WITH wqlist selectnowith */
+{yymsp[-2].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);}
         break;
-      case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */
-{
-  Select *p = yymsp[0].minor.yy539;
-  if( p ){
-    p->pWith = yymsp[-1].minor.yy131;
-    parserDoubleLinkSelect(pParse, p);
-  }else{
-    sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy131);
-  }
-  yymsp[-3].minor.yy539 = p;
-}
+      case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
+{yymsp[-3].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);}
         break;
-      case 85: /* select ::= selectnowith */
+      case 87: /* select ::= selectnowith */
 {
-  Select *p = yymsp[0].minor.yy539;
+  Select *p = yymsp[0].minor.yy303;
   if( p ){
     parserDoubleLinkSelect(pParse, p);
   }
-  yymsp[0].minor.yy539 = p; /*A-overwrites-X*/
+  yymsp[0].minor.yy303 = p; /*A-overwrites-X*/
 }
         break;
-      case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */
+      case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
 {
-  Select *pRhs = yymsp[0].minor.yy539;
-  Select *pLhs = yymsp[-2].minor.yy539;
+  Select *pRhs = yymsp[0].minor.yy303;
+  Select *pLhs = yymsp[-2].minor.yy303;
   if( pRhs && pRhs->pPrior ){
     SrcList *pFrom;
     Token x;
@@ -158671,140 +163323,140 @@ static YYACTIONTYPE yy_reduce(
     pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
   }
   if( pRhs ){
-    pRhs->op = (u8)yymsp[-1].minor.yy192;
+    pRhs->op = (u8)yymsp[-1].minor.yy64;
     pRhs->pPrior = pLhs;
     if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
     pRhs->selFlags &= ~SF_MultiValue;
-    if( yymsp[-1].minor.yy192!=TK_ALL ) pParse->hasCompound = 1;
+    if( yymsp[-1].minor.yy64!=TK_ALL ) pParse->hasCompound = 1;
   }else{
     sqlite3SelectDelete(pParse->db, pLhs);
   }
-  yymsp[-2].minor.yy539 = pRhs;
+  yymsp[-2].minor.yy303 = pRhs;
 }
         break;
-      case 87: /* multiselect_op ::= UNION */
-      case 89: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==89);
-{yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-OP*/}
+      case 89: /* multiselect_op ::= UNION */
+      case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
+{yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-OP*/}
         break;
-      case 88: /* multiselect_op ::= UNION ALL */
-{yymsp[-1].minor.yy192 = TK_ALL;}
+      case 90: /* multiselect_op ::= UNION ALL */
+{yymsp[-1].minor.yy64 = TK_ALL;}
         break;
-      case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
+      case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
 {
-  yymsp[-8].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy242,yymsp[-5].minor.yy47,yymsp[-4].minor.yy202,yymsp[-3].minor.yy242,yymsp[-2].minor.yy202,yymsp[-1].minor.yy242,yymsp[-7].minor.yy192,yymsp[0].minor.yy202);
+  yymsp[-8].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy562,yymsp[-5].minor.yy607,yymsp[-4].minor.yy626,yymsp[-3].minor.yy562,yymsp[-2].minor.yy626,yymsp[-1].minor.yy562,yymsp[-7].minor.yy64,yymsp[0].minor.yy626);
 }
         break;
-      case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
+      case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
 {
-  yymsp[-9].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy242,yymsp[-6].minor.yy47,yymsp[-5].minor.yy202,yymsp[-4].minor.yy242,yymsp[-3].minor.yy202,yymsp[-1].minor.yy242,yymsp[-8].minor.yy192,yymsp[0].minor.yy202);
-  if( yymsp[-9].minor.yy539 ){
-    yymsp[-9].minor.yy539->pWinDefn = yymsp[-2].minor.yy303;
+  yymsp[-9].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy562,yymsp[-6].minor.yy607,yymsp[-5].minor.yy626,yymsp[-4].minor.yy562,yymsp[-3].minor.yy626,yymsp[-1].minor.yy562,yymsp[-8].minor.yy64,yymsp[0].minor.yy626);
+  if( yymsp[-9].minor.yy303 ){
+    yymsp[-9].minor.yy303->pWinDefn = yymsp[-2].minor.yy375;
   }else{
-    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy303);
+    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy375);
   }
 }
         break;
-      case 92: /* values ::= VALUES LP nexprlist RP */
+      case 94: /* values ::= VALUES LP nexprlist RP */
 {
-  yymsp[-3].minor.yy539 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values,0);
+  yymsp[-3].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values,0);
 }
         break;
-      case 93: /* values ::= values COMMA LP nexprlist RP */
+      case 95: /* values ::= values COMMA LP nexprlist RP */
 {
-  Select *pRight, *pLeft = yymsp[-4].minor.yy539;
-  pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy242,0,0,0,0,0,SF_Values|SF_MultiValue,0);
+  Select *pRight, *pLeft = yymsp[-4].minor.yy303;
+  pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy562,0,0,0,0,0,SF_Values|SF_MultiValue,0);
   if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
   if( pRight ){
     pRight->op = TK_ALL;
     pRight->pPrior = pLeft;
-    yymsp[-4].minor.yy539 = pRight;
+    yymsp[-4].minor.yy303 = pRight;
   }else{
-    yymsp[-4].minor.yy539 = pLeft;
+    yymsp[-4].minor.yy303 = pLeft;
   }
 }
         break;
-      case 94: /* distinct ::= DISTINCT */
-{yymsp[0].minor.yy192 = SF_Distinct;}
+      case 96: /* distinct ::= DISTINCT */
+{yymsp[0].minor.yy64 = SF_Distinct;}
         break;
-      case 95: /* distinct ::= ALL */
-{yymsp[0].minor.yy192 = SF_All;}
+      case 97: /* distinct ::= ALL */
+{yymsp[0].minor.yy64 = SF_All;}
         break;
-      case 97: /* sclp ::= */
-      case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130);
-      case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140);
-      case 220: /* exprlist ::= */ yytestcase(yyruleno==220);
-      case 223: /* paren_exprlist ::= */ yytestcase(yyruleno==223);
-      case 228: /* eidlist_opt ::= */ yytestcase(yyruleno==228);
-{yymsp[1].minor.yy242 = 0;}
+      case 99: /* sclp ::= */
+      case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132);
+      case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142);
+      case 229: /* exprlist ::= */ yytestcase(yyruleno==229);
+      case 232: /* paren_exprlist ::= */ yytestcase(yyruleno==232);
+      case 237: /* eidlist_opt ::= */ yytestcase(yyruleno==237);
+{yymsp[1].minor.yy562 = 0;}
         break;
-      case 98: /* selcollist ::= sclp scanpt expr scanpt as */
+      case 100: /* selcollist ::= sclp scanpt expr scanpt as */
 {
-   yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[-2].minor.yy202);
-   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[0].minor.yy0, 1);
-   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy242,yymsp[-3].minor.yy436,yymsp[-1].minor.yy436);
+   yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[-2].minor.yy626);
+   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[0].minor.yy0, 1);
+   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy562,yymsp[-3].minor.yy600,yymsp[-1].minor.yy600);
 }
         break;
-      case 99: /* selcollist ::= sclp scanpt STAR */
+      case 101: /* selcollist ::= sclp scanpt STAR */
 {
   Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
-  yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy242, p);
+  yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy562, p);
 }
         break;
-      case 100: /* selcollist ::= sclp scanpt nm DOT STAR */
+      case 102: /* selcollist ::= sclp scanpt nm DOT STAR */
 {
   Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
   Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
   Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, pDot);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, pDot);
 }
         break;
-      case 101: /* as ::= AS nm */
-      case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112);
-      case 244: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==244);
-      case 245: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==245);
+      case 103: /* as ::= AS nm */
+      case 114: /* dbnm ::= DOT nm */ yytestcase(yyruleno==114);
+      case 253: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==253);
+      case 254: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==254);
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
         break;
-      case 103: /* from ::= */
-      case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106);
-{yymsp[1].minor.yy47 = 0;}
+      case 105: /* from ::= */
+      case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108);
+{yymsp[1].minor.yy607 = 0;}
         break;
-      case 104: /* from ::= FROM seltablist */
+      case 106: /* from ::= FROM seltablist */
 {
-  yymsp[-1].minor.yy47 = yymsp[0].minor.yy47;
-  sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy47);
+  yymsp[-1].minor.yy607 = yymsp[0].minor.yy607;
+  sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy607);
 }
         break;
-      case 105: /* stl_prefix ::= seltablist joinop */
+      case 107: /* stl_prefix ::= seltablist joinop */
 {
-   if( ALWAYS(yymsp[-1].minor.yy47 && yymsp[-1].minor.yy47->nSrc>0) ) yymsp[-1].minor.yy47->a[yymsp[-1].minor.yy47->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy192;
+   if( ALWAYS(yymsp[-1].minor.yy607 && yymsp[-1].minor.yy607->nSrc>0) ) yymsp[-1].minor.yy607->a[yymsp[-1].minor.yy607->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy64;
 }
         break;
-      case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
+      case 109: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
 {
-  yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
-  sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy47, &yymsp[-2].minor.yy0);
+  yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240);
+  sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy607, &yymsp[-2].minor.yy0);
 }
         break;
-      case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
+      case 110: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
 {
-  yymsp[-8].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy47,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
-  sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy47, yymsp[-4].minor.yy242);
+  yymsp[-8].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy607,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240);
+  sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy607, yymsp[-4].minor.yy562);
 }
         break;
-      case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
+      case 111: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
 {
-    yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy539,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
+    yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy303,yymsp[-1].minor.yy626,yymsp[0].minor.yy240);
   }
         break;
-      case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
+      case 112: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
 {
-    if( yymsp[-6].minor.yy47==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy202==0 && yymsp[0].minor.yy600==0 ){
-      yymsp[-6].minor.yy47 = yymsp[-4].minor.yy47;
-    }else if( yymsp[-4].minor.yy47->nSrc==1 ){
-      yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
-      if( yymsp[-6].minor.yy47 ){
-        struct SrcList_item *pNew = &yymsp[-6].minor.yy47->a[yymsp[-6].minor.yy47->nSrc-1];
-        struct SrcList_item *pOld = yymsp[-4].minor.yy47->a;
+    if( yymsp[-6].minor.yy607==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy626==0 && yymsp[0].minor.yy240==0 ){
+      yymsp[-6].minor.yy607 = yymsp[-4].minor.yy607;
+    }else if( yymsp[-4].minor.yy607->nSrc==1 ){
+      yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy626,yymsp[0].minor.yy240);
+      if( yymsp[-6].minor.yy607 ){
+        SrcItem *pNew = &yymsp[-6].minor.yy607->a[yymsp[-6].minor.yy607->nSrc-1];
+        SrcItem *pOld = yymsp[-4].minor.yy607->a;
         pNew->zName = pOld->zName;
         pNew->zDatabase = pOld->zDatabase;
         pNew->pSelect = pOld->pSelect;
@@ -158817,209 +163469,226 @@ static YYACTIONTYPE yy_reduce(
         pOld->zName = pOld->zDatabase = 0;
         pOld->pSelect = 0;
       }
-      sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy47);
+      sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy607);
     }else{
       Select *pSubquery;
-      sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy47);
-      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy47,0,0,0,0,SF_NestedFrom,0);
-      yymsp[-6].minor.yy47 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy47,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy202,yymsp[0].minor.yy600);
+      sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy607);
+      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy607,0,0,0,0,SF_NestedFrom,0);
+      yymsp[-6].minor.yy607 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy607,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy626,yymsp[0].minor.yy240);
     }
   }
         break;
-      case 111: /* dbnm ::= */
-      case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125);
+      case 113: /* dbnm ::= */
+      case 127: /* indexed_opt ::= */ yytestcase(yyruleno==127);
 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
         break;
-      case 113: /* fullname ::= nm */
+      case 115: /* fullname ::= nm */
 {
-  yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0);
+  yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
+  if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy47 = yylhsminor.yy47;
+  yymsp[0].minor.yy607 = yylhsminor.yy607;
         break;
-      case 114: /* fullname ::= nm DOT nm */
+      case 116: /* fullname ::= nm DOT nm */
 {
-  yylhsminor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
-  if( IN_RENAME_OBJECT && yylhsminor.yy47 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy47->a[0].zName, &yymsp[0].minor.yy0);
+  yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
+  if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy47 = yylhsminor.yy47;
+  yymsp[-2].minor.yy607 = yylhsminor.yy607;
         break;
-      case 115: /* xfullname ::= nm */
-{yymsp[0].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
+      case 117: /* xfullname ::= nm */
+{yymsp[0].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
         break;
-      case 116: /* xfullname ::= nm DOT nm */
-{yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 118: /* xfullname ::= nm DOT nm */
+{yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
-      case 117: /* xfullname ::= nm DOT nm AS nm */
+      case 119: /* xfullname ::= nm DOT nm AS nm */
 {
-   yymsp[-4].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
-   if( yymsp[-4].minor.yy47 ) yymsp[-4].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
+   yymsp[-4].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
+   if( yymsp[-4].minor.yy607 ) yymsp[-4].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
 }
         break;
-      case 118: /* xfullname ::= nm AS nm */
+      case 120: /* xfullname ::= nm AS nm */
 {
-   yymsp[-2].minor.yy47 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
-   if( yymsp[-2].minor.yy47 ) yymsp[-2].minor.yy47->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
+   yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
+   if( yymsp[-2].minor.yy607 ) yymsp[-2].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
 }
         break;
-      case 119: /* joinop ::= COMMA|JOIN */
-{ yymsp[0].minor.yy192 = JT_INNER; }
+      case 121: /* joinop ::= COMMA|JOIN */
+{ yymsp[0].minor.yy64 = JT_INNER; }
         break;
-      case 120: /* joinop ::= JOIN_KW JOIN */
-{yymsp[-1].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
+      case 122: /* joinop ::= JOIN_KW JOIN */
+{yymsp[-1].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
         break;
-      case 121: /* joinop ::= JOIN_KW nm JOIN */
-{yymsp[-2].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
+      case 123: /* joinop ::= JOIN_KW nm JOIN */
+{yymsp[-2].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
         break;
-      case 122: /* joinop ::= JOIN_KW nm nm JOIN */
-{yymsp[-3].minor.yy192 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
+      case 124: /* joinop ::= JOIN_KW nm nm JOIN */
+{yymsp[-3].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
         break;
-      case 123: /* on_opt ::= ON expr */
-      case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143);
-      case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150);
-      case 216: /* case_else ::= ELSE expr */ yytestcase(yyruleno==216);
-      case 237: /* vinto ::= INTO expr */ yytestcase(yyruleno==237);
-{yymsp[-1].minor.yy202 = yymsp[0].minor.yy202;}
+      case 125: /* on_opt ::= ON expr */
+      case 145: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==145);
+      case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152);
+      case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154);
+      case 225: /* case_else ::= ELSE expr */ yytestcase(yyruleno==225);
+      case 246: /* vinto ::= INTO expr */ yytestcase(yyruleno==246);
+{yymsp[-1].minor.yy626 = yymsp[0].minor.yy626;}
         break;
-      case 124: /* on_opt ::= */
-      case 142: /* having_opt ::= */ yytestcase(yyruleno==142);
-      case 144: /* limit_opt ::= */ yytestcase(yyruleno==144);
-      case 149: /* where_opt ::= */ yytestcase(yyruleno==149);
-      case 217: /* case_else ::= */ yytestcase(yyruleno==217);
-      case 219: /* case_operand ::= */ yytestcase(yyruleno==219);
-      case 238: /* vinto ::= */ yytestcase(yyruleno==238);
-{yymsp[1].minor.yy202 = 0;}
+      case 126: /* on_opt ::= */
+      case 144: /* having_opt ::= */ yytestcase(yyruleno==144);
+      case 146: /* limit_opt ::= */ yytestcase(yyruleno==146);
+      case 151: /* where_opt ::= */ yytestcase(yyruleno==151);
+      case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153);
+      case 226: /* case_else ::= */ yytestcase(yyruleno==226);
+      case 228: /* case_operand ::= */ yytestcase(yyruleno==228);
+      case 247: /* vinto ::= */ yytestcase(yyruleno==247);
+{yymsp[1].minor.yy626 = 0;}
         break;
-      case 126: /* indexed_opt ::= INDEXED BY nm */
+      case 128: /* indexed_opt ::= INDEXED BY nm */
 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
         break;
-      case 127: /* indexed_opt ::= NOT INDEXED */
+      case 129: /* indexed_opt ::= NOT INDEXED */
 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
         break;
-      case 128: /* using_opt ::= USING LP idlist RP */
-{yymsp[-3].minor.yy600 = yymsp[-1].minor.yy600;}
+      case 130: /* using_opt ::= USING LP idlist RP */
+{yymsp[-3].minor.yy240 = yymsp[-1].minor.yy240;}
         break;
-      case 129: /* using_opt ::= */
-      case 164: /* idlist_opt ::= */ yytestcase(yyruleno==164);
-{yymsp[1].minor.yy600 = 0;}
+      case 131: /* using_opt ::= */
+      case 173: /* idlist_opt ::= */ yytestcase(yyruleno==173);
+{yymsp[1].minor.yy240 = 0;}
         break;
-      case 131: /* orderby_opt ::= ORDER BY sortlist */
-      case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141);
-{yymsp[-2].minor.yy242 = yymsp[0].minor.yy242;}
+      case 133: /* orderby_opt ::= ORDER BY sortlist */
+      case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143);
+{yymsp[-2].minor.yy562 = yymsp[0].minor.yy562;}
         break;
-      case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */
+      case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */
 {
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202);
-  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562,yymsp[-2].minor.yy626);
+  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64);
 }
         break;
-      case 133: /* sortlist ::= expr sortorder nulls */
+      case 135: /* sortlist ::= expr sortorder nulls */
 {
-  yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy202); /*A-overwrites-Y*/
-  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy242,yymsp[-1].minor.yy192,yymsp[0].minor.yy192);
+  yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy626); /*A-overwrites-Y*/
+  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy562,yymsp[-1].minor.yy64,yymsp[0].minor.yy64);
 }
         break;
-      case 134: /* sortorder ::= ASC */
-{yymsp[0].minor.yy192 = SQLITE_SO_ASC;}
+      case 136: /* sortorder ::= ASC */
+{yymsp[0].minor.yy64 = SQLITE_SO_ASC;}
         break;
-      case 135: /* sortorder ::= DESC */
-{yymsp[0].minor.yy192 = SQLITE_SO_DESC;}
+      case 137: /* sortorder ::= DESC */
+{yymsp[0].minor.yy64 = SQLITE_SO_DESC;}
         break;
-      case 136: /* sortorder ::= */
-      case 139: /* nulls ::= */ yytestcase(yyruleno==139);
-{yymsp[1].minor.yy192 = SQLITE_SO_UNDEFINED;}
+      case 138: /* sortorder ::= */
+      case 141: /* nulls ::= */ yytestcase(yyruleno==141);
+{yymsp[1].minor.yy64 = SQLITE_SO_UNDEFINED;}
         break;
-      case 137: /* nulls ::= NULLS FIRST */
-{yymsp[-1].minor.yy192 = SQLITE_SO_ASC;}
+      case 139: /* nulls ::= NULLS FIRST */
+{yymsp[-1].minor.yy64 = SQLITE_SO_ASC;}
         break;
-      case 138: /* nulls ::= NULLS LAST */
-{yymsp[-1].minor.yy192 = SQLITE_SO_DESC;}
+      case 140: /* nulls ::= NULLS LAST */
+{yymsp[-1].minor.yy64 = SQLITE_SO_DESC;}
         break;
-      case 145: /* limit_opt ::= LIMIT expr */
-{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,0);}
+      case 147: /* limit_opt ::= LIMIT expr */
+{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,0);}
         break;
-      case 146: /* limit_opt ::= LIMIT expr OFFSET expr */
-{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
+      case 148: /* limit_opt ::= LIMIT expr OFFSET expr */
+{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);}
         break;
-      case 147: /* limit_opt ::= LIMIT expr COMMA expr */
-{yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy202,yymsp[-2].minor.yy202);}
+      case 149: /* limit_opt ::= LIMIT expr COMMA expr */
+{yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy626,yymsp[-2].minor.yy626);}
         break;
-      case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
+      case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
 {
-  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy47, &yymsp[-1].minor.yy0);
-  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy47,yymsp[0].minor.yy202,0,0);
+  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy607, &yymsp[-1].minor.yy0);
+  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy607,yymsp[0].minor.yy626,0,0);
 }
         break;
-      case 151: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt */
+      case 155: /* where_opt_ret ::= RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-1].minor.yy626 = 0;}
+        break;
+      case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy562); yymsp[-3].minor.yy626 = yymsp[-2].minor.yy626;}
+        break;
+      case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
 {
-  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy47, &yymsp[-4].minor.yy0);
-  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy242,"set list");
-  yymsp[-5].minor.yy47 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy47, yymsp[-1].minor.yy47);
-  sqlite3Update(pParse,yymsp[-5].minor.yy47,yymsp[-2].minor.yy242,yymsp[0].minor.yy202,yymsp[-6].minor.yy192,0,0,0);
+  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy607, &yymsp[-4].minor.yy0);
+  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy562,"set list");
+  yymsp[-5].minor.yy607 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy607, yymsp[-1].minor.yy607);
+  sqlite3Update(pParse,yymsp[-5].minor.yy607,yymsp[-2].minor.yy562,yymsp[0].minor.yy626,yymsp[-6].minor.yy64,0,0,0);
 }
         break;
-      case 152: /* setlist ::= setlist COMMA nm EQ expr */
+      case 158: /* setlist ::= setlist COMMA nm EQ expr */
 {
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy242, yymsp[0].minor.yy202);
-  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, 1);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy562, yymsp[0].minor.yy626);
+  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, 1);
 }
         break;
-      case 153: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
+      case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
 {
-  yymsp[-6].minor.yy242 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy242, yymsp[-3].minor.yy600, yymsp[0].minor.yy202);
+  yymsp[-6].minor.yy562 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy562, yymsp[-3].minor.yy240, yymsp[0].minor.yy626);
 }
         break;
-      case 154: /* setlist ::= nm EQ expr */
+      case 160: /* setlist ::= nm EQ expr */
 {
-  yylhsminor.yy242 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy202);
-  sqlite3ExprListSetName(pParse, yylhsminor.yy242, &yymsp[-2].minor.yy0, 1);
+  yylhsminor.yy562 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy626);
+  sqlite3ExprListSetName(pParse, yylhsminor.yy562, &yymsp[-2].minor.yy0, 1);
 }
-  yymsp[-2].minor.yy242 = yylhsminor.yy242;
+  yymsp[-2].minor.yy562 = yylhsminor.yy562;
         break;
-      case 155: /* setlist ::= LP idlist RP EQ expr */
+      case 161: /* setlist ::= LP idlist RP EQ expr */
 {
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy600, yymsp[0].minor.yy202);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy240, yymsp[0].minor.yy626);
 }
         break;
-      case 156: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
+      case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
 {
-  sqlite3Insert(pParse, yymsp[-3].minor.yy47, yymsp[-1].minor.yy539, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, yymsp[0].minor.yy318);
+  sqlite3Insert(pParse, yymsp[-3].minor.yy607, yymsp[-1].minor.yy303, yymsp[-2].minor.yy240, yymsp[-5].minor.yy64, yymsp[0].minor.yy138);
 }
         break;
-      case 157: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
+      case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
 {
-  sqlite3Insert(pParse, yymsp[-3].minor.yy47, 0, yymsp[-2].minor.yy600, yymsp[-5].minor.yy192, 0);
+  sqlite3Insert(pParse, yymsp[-4].minor.yy607, 0, yymsp[-3].minor.yy240, yymsp[-6].minor.yy64, 0);
 }
         break;
-      case 158: /* upsert ::= */
-{ yymsp[1].minor.yy318 = 0; }
+      case 164: /* upsert ::= */
+{ yymsp[1].minor.yy138 = 0; }
+        break;
+      case 165: /* upsert ::= RETURNING selcollist */
+{ yymsp[-1].minor.yy138 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy562); }
+        break;
+      case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
+{ yymsp[-11].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy562,yymsp[-6].minor.yy626,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,yymsp[0].minor.yy138);}
         break;
-      case 159: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt */
-{ yymsp[-10].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-7].minor.yy242,yymsp[-5].minor.yy202,yymsp[-1].minor.yy242,yymsp[0].minor.yy202);}
+      case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
+{ yymsp[-8].minor.yy138 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy562,yymsp[-3].minor.yy626,0,0,yymsp[0].minor.yy138); }
         break;
-      case 160: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING */
-{ yymsp[-7].minor.yy318 = sqlite3UpsertNew(pParse->db,yymsp[-4].minor.yy242,yymsp[-2].minor.yy202,0,0); }
+      case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */
+{ yymsp[-4].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
         break;
-      case 161: /* upsert ::= ON CONFLICT DO NOTHING */
-{ yymsp[-3].minor.yy318 = sqlite3UpsertNew(pParse->db,0,0,0,0); }
+      case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
+{ yymsp[-7].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,0);}
         break;
-      case 165: /* idlist_opt ::= LP idlist RP */
-{yymsp[-2].minor.yy600 = yymsp[-1].minor.yy600;}
+      case 170: /* returning ::= RETURNING selcollist */
+{sqlite3AddReturning(pParse,yymsp[0].minor.yy562);}
         break;
-      case 166: /* idlist ::= idlist COMMA nm */
-{yymsp[-2].minor.yy600 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy600,&yymsp[0].minor.yy0);}
+      case 174: /* idlist_opt ::= LP idlist RP */
+{yymsp[-2].minor.yy240 = yymsp[-1].minor.yy240;}
         break;
-      case 167: /* idlist ::= nm */
-{yymsp[0].minor.yy600 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
+      case 175: /* idlist ::= idlist COMMA nm */
+{yymsp[-2].minor.yy240 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy240,&yymsp[0].minor.yy0);}
         break;
-      case 168: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy202 = yymsp[-1].minor.yy202;}
+      case 176: /* idlist ::= nm */
+{yymsp[0].minor.yy240 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
         break;
-      case 169: /* expr ::= ID|INDEXED */
-      case 170: /* expr ::= JOIN_KW */ yytestcase(yyruleno==170);
-{yymsp[0].minor.yy202=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 177: /* expr ::= LP expr RP */
+{yymsp[-2].minor.yy626 = yymsp[-1].minor.yy626;}
         break;
-      case 171: /* expr ::= nm DOT nm */
+      case 178: /* expr ::= ID|INDEXED */
+      case 179: /* expr ::= JOIN_KW */ yytestcase(yyruleno==179);
+{yymsp[0].minor.yy626=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+        break;
+      case 180: /* expr ::= nm DOT nm */
 {
   Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
   Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
@@ -159027,11 +163696,11 @@ static YYACTIONTYPE yy_reduce(
     sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
     sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
   }
-  yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
+  yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
 }
-  yymsp[-2].minor.yy202 = yylhsminor.yy202;
+  yymsp[-2].minor.yy626 = yylhsminor.yy626;
         break;
-      case 172: /* expr ::= nm DOT nm DOT nm */
+      case 181: /* expr ::= nm DOT nm DOT nm */
 {
   Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1);
   Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
@@ -159041,26 +163710,26 @@ static YYACTIONTYPE yy_reduce(
     sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
     sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
   }
-  yylhsminor.yy202 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
+  yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
 }
-  yymsp[-4].minor.yy202 = yylhsminor.yy202;
+  yymsp[-4].minor.yy626 = yylhsminor.yy626;
         break;
-      case 173: /* term ::= NULL|FLOAT|BLOB */
-      case 174: /* term ::= STRING */ yytestcase(yyruleno==174);
-{yymsp[0].minor.yy202=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
+      case 182: /* term ::= NULL|FLOAT|BLOB */
+      case 183: /* term ::= STRING */ yytestcase(yyruleno==183);
+{yymsp[0].minor.yy626=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
-      case 175: /* term ::= INTEGER */
+      case 184: /* term ::= INTEGER */
 {
-  yylhsminor.yy202 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
+  yylhsminor.yy626 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
 }
-  yymsp[0].minor.yy202 = yylhsminor.yy202;
+  yymsp[0].minor.yy626 = yylhsminor.yy626;
         break;
-      case 176: /* expr ::= VARIABLE */
+      case 185: /* expr ::= VARIABLE */
 {
   if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
     u32 n = yymsp[0].minor.yy0.n;
-    yymsp[0].minor.yy202 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
-    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy202, n);
+    yymsp[0].minor.yy626 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
+    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy626, n);
   }else{
     /* When doing a nested parse, one can include terms in an expression
     ** that look like this:   #1 #2 ...  These terms refer to registers
@@ -159069,159 +163738,159 @@ static YYACTIONTYPE yy_reduce(
     assert( t.n>=2 );
     if( pParse->nested==0 ){
       sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
-      yymsp[0].minor.yy202 = 0;
+      yymsp[0].minor.yy626 = 0;
     }else{
-      yymsp[0].minor.yy202 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
-      if( yymsp[0].minor.yy202 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy202->iTable);
+      yymsp[0].minor.yy626 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
+      if( yymsp[0].minor.yy626 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy626->iTable);
     }
   }
 }
         break;
-      case 177: /* expr ::= expr COLLATE ID|STRING */
+      case 186: /* expr ::= expr COLLATE ID|STRING */
 {
-  yymsp[-2].minor.yy202 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy202, &yymsp[0].minor.yy0, 1);
+  yymsp[-2].minor.yy626 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy626, &yymsp[0].minor.yy0, 1);
 }
         break;
-      case 178: /* expr ::= CAST LP expr AS typetoken RP */
+      case 187: /* expr ::= CAST LP expr AS typetoken RP */
 {
-  yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
-  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy202, yymsp[-3].minor.yy202, 0);
+  yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
+  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy626, yymsp[-3].minor.yy626, 0);
 }
         break;
-      case 179: /* expr ::= ID|INDEXED LP distinct exprlist RP */
+      case 188: /* expr ::= ID|INDEXED LP distinct exprlist RP */
 {
-  yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy192);
+  yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy64);
 }
-  yymsp[-4].minor.yy202 = yylhsminor.yy202;
+  yymsp[-4].minor.yy626 = yylhsminor.yy626;
         break;
-      case 180: /* expr ::= ID|INDEXED LP STAR RP */
+      case 189: /* expr ::= ID|INDEXED LP STAR RP */
 {
-  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
+  yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
 }
-  yymsp[-3].minor.yy202 = yylhsminor.yy202;
+  yymsp[-3].minor.yy626 = yylhsminor.yy626;
         break;
-      case 181: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
+      case 190: /* expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
 {
-  yylhsminor.yy202 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy242, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy192);
-  sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303);
+  yylhsminor.yy626 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy562, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy64);
+  sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375);
 }
-  yymsp[-5].minor.yy202 = yylhsminor.yy202;
+  yymsp[-5].minor.yy626 = yylhsminor.yy626;
         break;
-      case 182: /* expr ::= ID|INDEXED LP STAR RP filter_over */
+      case 191: /* expr ::= ID|INDEXED LP STAR RP filter_over */
 {
-  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
-  sqlite3WindowAttach(pParse, yylhsminor.yy202, yymsp[0].minor.yy303);
+  yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
+  sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375);
 }
-  yymsp[-4].minor.yy202 = yylhsminor.yy202;
+  yymsp[-4].minor.yy626 = yylhsminor.yy626;
         break;
-      case 183: /* term ::= CTIME_KW */
+      case 192: /* term ::= CTIME_KW */
 {
-  yylhsminor.yy202 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
+  yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
 }
-  yymsp[0].minor.yy202 = yylhsminor.yy202;
+  yymsp[0].minor.yy626 = yylhsminor.yy626;
         break;
-      case 184: /* expr ::= LP nexprlist COMMA expr RP */
+      case 193: /* expr ::= LP nexprlist COMMA expr RP */
 {
-  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202);
-  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
-  if( yymsp[-4].minor.yy202 ){
-    yymsp[-4].minor.yy202->x.pList = pList;
+  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626);
+  yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
+  if( yymsp[-4].minor.yy626 ){
+    yymsp[-4].minor.yy626->x.pList = pList;
     if( ALWAYS(pList->nExpr) ){
-      yymsp[-4].minor.yy202->flags |= pList->a[0].pExpr->flags & EP_Propagate;
+      yymsp[-4].minor.yy626->flags |= pList->a[0].pExpr->flags & EP_Propagate;
     }
   }else{
     sqlite3ExprListDelete(pParse->db, pList);
   }
 }
         break;
-      case 185: /* expr ::= expr AND expr */
-{yymsp[-2].minor.yy202=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
+      case 194: /* expr ::= expr AND expr */
+{yymsp[-2].minor.yy626=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);}
         break;
-      case 186: /* expr ::= expr OR expr */
-      case 187: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==187);
-      case 188: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==188);
-      case 189: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==189);
-      case 190: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==190);
-      case 191: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==191);
-      case 192: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==192);
-{yymsp[-2].minor.yy202=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);}
+      case 195: /* expr ::= expr OR expr */
+      case 196: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==196);
+      case 197: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==197);
+      case 198: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==198);
+      case 199: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==199);
+      case 200: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==200);
+      case 201: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==201);
+{yymsp[-2].minor.yy626=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);}
         break;
-      case 193: /* likeop ::= NOT LIKE_KW|MATCH */
+      case 202: /* likeop ::= NOT LIKE_KW|MATCH */
 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
         break;
-      case 194: /* expr ::= expr likeop expr */
+      case 203: /* expr ::= expr likeop expr */
 {
   ExprList *pList;
   int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
   yymsp[-1].minor.yy0.n &= 0x7fffffff;
-  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy202);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy202);
-  yymsp[-2].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
-  if( bNot ) yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy202, 0);
-  if( yymsp[-2].minor.yy202 ) yymsp[-2].minor.yy202->flags |= EP_InfixFunc;
+  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy626);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy626);
+  yymsp[-2].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
+  if( bNot ) yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy626, 0);
+  if( yymsp[-2].minor.yy626 ) yymsp[-2].minor.yy626->flags |= EP_InfixFunc;
 }
         break;
-      case 195: /* expr ::= expr likeop expr ESCAPE expr */
+      case 204: /* expr ::= expr likeop expr ESCAPE expr */
 {
   ExprList *pList;
   int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
   yymsp[-3].minor.yy0.n &= 0x7fffffff;
-  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy202);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202);
-  yymsp[-4].minor.yy202 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
-  if( bNot ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
-  if( yymsp[-4].minor.yy202 ) yymsp[-4].minor.yy202->flags |= EP_InfixFunc;
+  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy626);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626);
+  yymsp[-4].minor.yy626 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
+  if( bNot ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0);
+  if( yymsp[-4].minor.yy626 ) yymsp[-4].minor.yy626->flags |= EP_InfixFunc;
 }
         break;
-      case 196: /* expr ::= expr ISNULL|NOTNULL */
-{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy202,0);}
+      case 205: /* expr ::= expr ISNULL|NOTNULL */
+{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy626,0);}
         break;
-      case 197: /* expr ::= expr NOT NULL */
-{yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy202,0);}
+      case 206: /* expr ::= expr NOT NULL */
+{yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy626,0);}
         break;
-      case 198: /* expr ::= expr IS expr */
+      case 207: /* expr ::= expr IS expr */
 {
-  yymsp[-2].minor.yy202 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy202,yymsp[0].minor.yy202);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-2].minor.yy202, TK_ISNULL);
+  yymsp[-2].minor.yy626 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-2].minor.yy626, TK_ISNULL);
 }
         break;
-      case 199: /* expr ::= expr IS NOT expr */
+      case 208: /* expr ::= expr IS NOT expr */
 {
-  yymsp[-3].minor.yy202 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy202,yymsp[0].minor.yy202);
-  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy202, yymsp[-3].minor.yy202, TK_NOTNULL);
+  yymsp[-3].minor.yy626 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy626,yymsp[0].minor.yy626);
+  binaryToUnaryIfNull(pParse, yymsp[0].minor.yy626, yymsp[-3].minor.yy626, TK_NOTNULL);
 }
         break;
-      case 200: /* expr ::= NOT expr */
-      case 201: /* expr ::= BITNOT expr */ yytestcase(yyruleno==201);
-{yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy202, 0);/*A-overwrites-B*/}
+      case 209: /* expr ::= NOT expr */
+      case 210: /* expr ::= BITNOT expr */ yytestcase(yyruleno==210);
+{yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy626, 0);/*A-overwrites-B*/}
         break;
-      case 202: /* expr ::= PLUS|MINUS expr */
+      case 211: /* expr ::= PLUS|MINUS expr */
 {
-  yymsp[-1].minor.yy202 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy202, 0);
+  yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy626, 0);
   /*A-overwrites-B*/
 }
         break;
-      case 203: /* between_op ::= BETWEEN */
-      case 206: /* in_op ::= IN */ yytestcase(yyruleno==206);
-{yymsp[0].minor.yy192 = 0;}
+      case 212: /* between_op ::= BETWEEN */
+      case 215: /* in_op ::= IN */ yytestcase(yyruleno==215);
+{yymsp[0].minor.yy64 = 0;}
         break;
-      case 205: /* expr ::= expr between_op expr AND expr */
+      case 214: /* expr ::= expr between_op expr AND expr */
 {
-  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
-  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy202);
-  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy202, 0);
-  if( yymsp[-4].minor.yy202 ){
-    yymsp[-4].minor.yy202->x.pList = pList;
+  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626);
+  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy626);
+  yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy626, 0);
+  if( yymsp[-4].minor.yy626 ){
+    yymsp[-4].minor.yy626->x.pList = pList;
   }else{
     sqlite3ExprListDelete(pParse->db, pList);
   }
-  if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
+  if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0);
 }
         break;
-      case 208: /* expr ::= expr in_op LP exprlist RP */
+      case 217: /* expr ::= expr in_op LP exprlist RP */
 {
-    if( yymsp[-1].minor.yy242==0 ){
+    if( yymsp[-1].minor.yy562==0 ){
       /* Expressions of the form
       **
       **      expr1 IN ()
@@ -159230,197 +163899,205 @@ static YYACTIONTYPE yy_reduce(
       ** simplify to constants 0 (false) and 1 (true), respectively,
       ** regardless of the value of expr1.
       */
-      sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy202);
-      yymsp[-4].minor.yy202 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy192 ? "1" : "0");
-    }else if( yymsp[-1].minor.yy242->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy242->a[0].pExpr) ){
-      Expr *pRHS = yymsp[-1].minor.yy242->a[0].pExpr;
-      yymsp[-1].minor.yy242->a[0].pExpr = 0;
-      sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242);
-      pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
-      yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy202, pRHS);
-      if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
-    }else{
-      yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
-      if( yymsp[-4].minor.yy202 ){
-        yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy242;
-        sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202);
+      sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy626);
+      yymsp[-4].minor.yy626 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy64 ? "1" : "0");
+    }else{
+      Expr *pRHS = yymsp[-1].minor.yy562->a[0].pExpr;
+      if( yymsp[-1].minor.yy562->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy626->op!=TK_VECTOR ){
+        yymsp[-1].minor.yy562->a[0].pExpr = 0;
+        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562);
+        pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
+        yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy626, pRHS);
       }else{
-        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy242);
+        yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0);
+        if( yymsp[-4].minor.yy626==0 ){
+          sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy562);
+        }else if( yymsp[-4].minor.yy626->pLeft->op==TK_VECTOR ){
+          int nExpr = yymsp[-4].minor.yy626->pLeft->x.pList->nExpr;
+          Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy562);
+          if( pSelectRHS ){
+            parserDoubleLinkSelect(pParse, pSelectRHS);
+            sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelectRHS);
+          }
+        }else{
+          yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy562;
+          sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626);
+        }
       }
-      if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
+      if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0);
     }
   }
         break;
-      case 209: /* expr ::= LP select RP */
+      case 218: /* expr ::= LP select RP */
 {
-    yymsp[-2].minor.yy202 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy202, yymsp[-1].minor.yy539);
+    yymsp[-2].minor.yy626 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy626, yymsp[-1].minor.yy303);
   }
         break;
-      case 210: /* expr ::= expr in_op LP select RP */
+      case 219: /* expr ::= expr in_op LP select RP */
 {
-    yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, yymsp[-1].minor.yy539);
-    if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
+    yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, yymsp[-1].minor.yy303);
+    if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0);
   }
         break;
-      case 211: /* expr ::= expr in_op nm dbnm paren_exprlist */
+      case 220: /* expr ::= expr in_op nm dbnm paren_exprlist */
 {
     SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
     Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
-    if( yymsp[0].minor.yy242 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy242);
-    yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy202, 0);
-    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy202, pSelect);
-    if( yymsp[-3].minor.yy192 ) yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy202, 0);
+    if( yymsp[0].minor.yy562 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy562);
+    yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0);
+    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy626, pSelect);
+    if( yymsp[-3].minor.yy64 ) yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy626, 0);
   }
         break;
-      case 212: /* expr ::= EXISTS LP select RP */
+      case 221: /* expr ::= EXISTS LP select RP */
 {
     Expr *p;
-    p = yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
-    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy539);
+    p = yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
+    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy303);
   }
         break;
-      case 213: /* expr ::= CASE case_operand case_exprlist case_else END */
+      case 222: /* expr ::= CASE case_operand case_exprlist case_else END */
 {
-  yymsp[-4].minor.yy202 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy202, 0);
-  if( yymsp[-4].minor.yy202 ){
-    yymsp[-4].minor.yy202->x.pList = yymsp[-1].minor.yy202 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[-1].minor.yy202) : yymsp[-2].minor.yy242;
-    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy202);
+  yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy626, 0);
+  if( yymsp[-4].minor.yy626 ){
+    yymsp[-4].minor.yy626->x.pList = yymsp[-1].minor.yy626 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626) : yymsp[-2].minor.yy562;
+    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy626);
   }else{
-    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy242);
-    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy202);
+    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy562);
+    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626);
   }
 }
         break;
-      case 214: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
+      case 223: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
 {
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[-2].minor.yy202);
-  yymsp[-4].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy242, yymsp[0].minor.yy202);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[-2].minor.yy626);
+  yymsp[-4].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy562, yymsp[0].minor.yy626);
 }
         break;
-      case 215: /* case_exprlist ::= WHEN expr THEN expr */
+      case 224: /* case_exprlist ::= WHEN expr THEN expr */
 {
-  yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy202);
-  yymsp[-3].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy242, yymsp[0].minor.yy202);
+  yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy626);
+  yymsp[-3].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy562, yymsp[0].minor.yy626);
 }
         break;
-      case 218: /* case_operand ::= expr */
-{yymsp[0].minor.yy202 = yymsp[0].minor.yy202; /*A-overwrites-X*/}
+      case 227: /* case_operand ::= expr */
+{yymsp[0].minor.yy626 = yymsp[0].minor.yy626; /*A-overwrites-X*/}
         break;
-      case 221: /* nexprlist ::= nexprlist COMMA expr */
-{yymsp[-2].minor.yy242 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy242,yymsp[0].minor.yy202);}
+      case 230: /* nexprlist ::= nexprlist COMMA expr */
+{yymsp[-2].minor.yy562 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy562,yymsp[0].minor.yy626);}
         break;
-      case 222: /* nexprlist ::= expr */
-{yymsp[0].minor.yy242 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy202); /*A-overwrites-Y*/}
+      case 231: /* nexprlist ::= expr */
+{yymsp[0].minor.yy562 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy626); /*A-overwrites-Y*/}
         break;
-      case 224: /* paren_exprlist ::= LP exprlist RP */
-      case 229: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==229);
-{yymsp[-2].minor.yy242 = yymsp[-1].minor.yy242;}
+      case 233: /* paren_exprlist ::= LP exprlist RP */
+      case 238: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==238);
+{yymsp[-2].minor.yy562 = yymsp[-1].minor.yy562;}
         break;
-      case 225: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
+      case 234: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
 {
   sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
-                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy242, yymsp[-10].minor.yy192,
-                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy202, SQLITE_SO_ASC, yymsp[-8].minor.yy192, SQLITE_IDXTYPE_APPDEF);
+                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy562, yymsp[-10].minor.yy64,
+                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy626, SQLITE_SO_ASC, yymsp[-8].minor.yy64, SQLITE_IDXTYPE_APPDEF);
   if( IN_RENAME_OBJECT && pParse->pNewIndex ){
     sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
   }
 }
         break;
-      case 226: /* uniqueflag ::= UNIQUE */
-      case 268: /* raisetype ::= ABORT */ yytestcase(yyruleno==268);
-{yymsp[0].minor.yy192 = OE_Abort;}
+      case 235: /* uniqueflag ::= UNIQUE */
+      case 277: /* raisetype ::= ABORT */ yytestcase(yyruleno==277);
+{yymsp[0].minor.yy64 = OE_Abort;}
         break;
-      case 227: /* uniqueflag ::= */
-{yymsp[1].minor.yy192 = OE_None;}
+      case 236: /* uniqueflag ::= */
+{yymsp[1].minor.yy64 = OE_None;}
         break;
-      case 230: /* eidlist ::= eidlist COMMA nm collate sortorder */
+      case 239: /* eidlist ::= eidlist COMMA nm collate sortorder */
 {
-  yymsp[-4].minor.yy242 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy242, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192);
+  yymsp[-4].minor.yy562 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy562, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64);
 }
         break;
-      case 231: /* eidlist ::= nm collate sortorder */
+      case 240: /* eidlist ::= nm collate sortorder */
 {
-  yymsp[-2].minor.yy242 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy192, yymsp[0].minor.yy192); /*A-overwrites-Y*/
+  yymsp[-2].minor.yy562 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy64, yymsp[0].minor.yy64); /*A-overwrites-Y*/
 }
         break;
-      case 234: /* cmd ::= DROP INDEX ifexists fullname */
-{sqlite3DropIndex(pParse, yymsp[0].minor.yy47, yymsp[-1].minor.yy192);}
+      case 243: /* cmd ::= DROP INDEX ifexists fullname */
+{sqlite3DropIndex(pParse, yymsp[0].minor.yy607, yymsp[-1].minor.yy64);}
         break;
-      case 235: /* cmd ::= VACUUM vinto */
-{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy202);}
+      case 244: /* cmd ::= VACUUM vinto */
+{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy626);}
         break;
-      case 236: /* cmd ::= VACUUM nm vinto */
-{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy202);}
+      case 245: /* cmd ::= VACUUM nm vinto */
+{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy626);}
         break;
-      case 239: /* cmd ::= PRAGMA nm dbnm */
+      case 248: /* cmd ::= PRAGMA nm dbnm */
 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
         break;
-      case 240: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
+      case 249: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
         break;
-      case 241: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
+      case 250: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
         break;
-      case 242: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
+      case 251: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
         break;
-      case 243: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
+      case 252: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
         break;
-      case 246: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+      case 255: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
 {
   Token all;
   all.z = yymsp[-3].minor.yy0.z;
   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
-  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy447, &all);
+  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy95, &all);
 }
         break;
-      case 247: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+      case 256: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
 {
-  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy192, yymsp[-4].minor.yy230.a, yymsp[-4].minor.yy230.b, yymsp[-2].minor.yy47, yymsp[0].minor.yy202, yymsp[-10].minor.yy192, yymsp[-8].minor.yy192);
+  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy64, yymsp[-4].minor.yy570.a, yymsp[-4].minor.yy570.b, yymsp[-2].minor.yy607, yymsp[0].minor.yy626, yymsp[-10].minor.yy64, yymsp[-8].minor.yy64);
   yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
 }
         break;
-      case 248: /* trigger_time ::= BEFORE|AFTER */
-{ yymsp[0].minor.yy192 = yymsp[0].major; /*A-overwrites-X*/ }
+      case 257: /* trigger_time ::= BEFORE|AFTER */
+{ yymsp[0].minor.yy64 = yymsp[0].major; /*A-overwrites-X*/ }
         break;
-      case 249: /* trigger_time ::= INSTEAD OF */
-{ yymsp[-1].minor.yy192 = TK_INSTEAD;}
+      case 258: /* trigger_time ::= INSTEAD OF */
+{ yymsp[-1].minor.yy64 = TK_INSTEAD;}
         break;
-      case 250: /* trigger_time ::= */
-{ yymsp[1].minor.yy192 = TK_BEFORE; }
+      case 259: /* trigger_time ::= */
+{ yymsp[1].minor.yy64 = TK_BEFORE; }
         break;
-      case 251: /* trigger_event ::= DELETE|INSERT */
-      case 252: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==252);
-{yymsp[0].minor.yy230.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy230.b = 0;}
+      case 260: /* trigger_event ::= DELETE|INSERT */
+      case 261: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==261);
+{yymsp[0].minor.yy570.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy570.b = 0;}
         break;
-      case 253: /* trigger_event ::= UPDATE OF idlist */
-{yymsp[-2].minor.yy230.a = TK_UPDATE; yymsp[-2].minor.yy230.b = yymsp[0].minor.yy600;}
+      case 262: /* trigger_event ::= UPDATE OF idlist */
+{yymsp[-2].minor.yy570.a = TK_UPDATE; yymsp[-2].minor.yy570.b = yymsp[0].minor.yy240;}
         break;
-      case 254: /* when_clause ::= */
-      case 273: /* key_opt ::= */ yytestcase(yyruleno==273);
-{ yymsp[1].minor.yy202 = 0; }
+      case 263: /* when_clause ::= */
+      case 282: /* key_opt ::= */ yytestcase(yyruleno==282);
+{ yymsp[1].minor.yy626 = 0; }
         break;
-      case 255: /* when_clause ::= WHEN expr */
-      case 274: /* key_opt ::= KEY expr */ yytestcase(yyruleno==274);
-{ yymsp[-1].minor.yy202 = yymsp[0].minor.yy202; }
+      case 264: /* when_clause ::= WHEN expr */
+      case 283: /* key_opt ::= KEY expr */ yytestcase(yyruleno==283);
+{ yymsp[-1].minor.yy626 = yymsp[0].minor.yy626; }
         break;
-      case 256: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+      case 265: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
 {
-  assert( yymsp[-2].minor.yy447!=0 );
-  yymsp[-2].minor.yy447->pLast->pNext = yymsp[-1].minor.yy447;
-  yymsp[-2].minor.yy447->pLast = yymsp[-1].minor.yy447;
+  assert( yymsp[-2].minor.yy95!=0 );
+  yymsp[-2].minor.yy95->pLast->pNext = yymsp[-1].minor.yy95;
+  yymsp[-2].minor.yy95->pLast = yymsp[-1].minor.yy95;
 }
         break;
-      case 257: /* trigger_cmd_list ::= trigger_cmd SEMI */
+      case 266: /* trigger_cmd_list ::= trigger_cmd SEMI */
 {
-  assert( yymsp[-1].minor.yy447!=0 );
-  yymsp[-1].minor.yy447->pLast = yymsp[-1].minor.yy447;
+  assert( yymsp[-1].minor.yy95!=0 );
+  yymsp[-1].minor.yy95->pLast = yymsp[-1].minor.yy95;
 }
         break;
-      case 258: /* trnm ::= nm DOT nm */
+      case 267: /* trnm ::= nm DOT nm */
 {
   yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
   sqlite3ErrorMsg(pParse,
@@ -159428,344 +164105,369 @@ static YYACTIONTYPE yy_reduce(
         "statements within triggers");
 }
         break;
-      case 259: /* tridxby ::= INDEXED BY nm */
+      case 268: /* tridxby ::= INDEXED BY nm */
 {
   sqlite3ErrorMsg(pParse,
         "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
-      case 260: /* tridxby ::= NOT INDEXED */
+      case 269: /* tridxby ::= NOT INDEXED */
 {
   sqlite3ErrorMsg(pParse,
         "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
-      case 261: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
-{yylhsminor.yy447 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy47, yymsp[-3].minor.yy242, yymsp[-1].minor.yy202, yymsp[-7].minor.yy192, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy436);}
-  yymsp[-8].minor.yy447 = yylhsminor.yy447;
+      case 270: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
+{yylhsminor.yy95 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy607, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626, yymsp[-7].minor.yy64, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy600);}
+  yymsp[-8].minor.yy95 = yylhsminor.yy95;
         break;
-      case 262: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
+      case 271: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
 {
-   yylhsminor.yy447 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy600,yymsp[-2].minor.yy539,yymsp[-6].minor.yy192,yymsp[-1].minor.yy318,yymsp[-7].minor.yy436,yymsp[0].minor.yy436);/*yylhsminor.yy447-overwrites-yymsp[-6].minor.yy192*/
+   yylhsminor.yy95 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy240,yymsp[-2].minor.yy303,yymsp[-6].minor.yy64,yymsp[-1].minor.yy138,yymsp[-7].minor.yy600,yymsp[0].minor.yy600);/*yylhsminor.yy95-overwrites-yymsp[-6].minor.yy64*/
 }
-  yymsp[-7].minor.yy447 = yylhsminor.yy447;
+  yymsp[-7].minor.yy95 = yylhsminor.yy95;
         break;
-      case 263: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
-{yylhsminor.yy447 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy202, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy436);}
-  yymsp[-5].minor.yy447 = yylhsminor.yy447;
+      case 272: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
+{yylhsminor.yy95 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy626, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy600);}
+  yymsp[-5].minor.yy95 = yylhsminor.yy95;
         break;
-      case 264: /* trigger_cmd ::= scanpt select scanpt */
-{yylhsminor.yy447 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy539, yymsp[-2].minor.yy436, yymsp[0].minor.yy436); /*yylhsminor.yy447-overwrites-yymsp[-1].minor.yy539*/}
-  yymsp[-2].minor.yy447 = yylhsminor.yy447;
+      case 273: /* trigger_cmd ::= scanpt select scanpt */
+{yylhsminor.yy95 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy303, yymsp[-2].minor.yy600, yymsp[0].minor.yy600); /*yylhsminor.yy95-overwrites-yymsp[-1].minor.yy303*/}
+  yymsp[-2].minor.yy95 = yylhsminor.yy95;
         break;
-      case 265: /* expr ::= RAISE LP IGNORE RP */
+      case 274: /* expr ::= RAISE LP IGNORE RP */
 {
-  yymsp[-3].minor.yy202 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
-  if( yymsp[-3].minor.yy202 ){
-    yymsp[-3].minor.yy202->affExpr = OE_Ignore;
+  yymsp[-3].minor.yy626 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
+  if( yymsp[-3].minor.yy626 ){
+    yymsp[-3].minor.yy626->affExpr = OE_Ignore;
   }
 }
         break;
-      case 266: /* expr ::= RAISE LP raisetype COMMA nm RP */
+      case 275: /* expr ::= RAISE LP raisetype COMMA nm RP */
 {
-  yymsp[-5].minor.yy202 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
-  if( yymsp[-5].minor.yy202 ) {
-    yymsp[-5].minor.yy202->affExpr = (char)yymsp[-3].minor.yy192;
+  yymsp[-5].minor.yy626 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
+  if( yymsp[-5].minor.yy626 ) {
+    yymsp[-5].minor.yy626->affExpr = (char)yymsp[-3].minor.yy64;
   }
 }
         break;
-      case 267: /* raisetype ::= ROLLBACK */
-{yymsp[0].minor.yy192 = OE_Rollback;}
+      case 276: /* raisetype ::= ROLLBACK */
+{yymsp[0].minor.yy64 = OE_Rollback;}
         break;
-      case 269: /* raisetype ::= FAIL */
-{yymsp[0].minor.yy192 = OE_Fail;}
+      case 278: /* raisetype ::= FAIL */
+{yymsp[0].minor.yy64 = OE_Fail;}
         break;
-      case 270: /* cmd ::= DROP TRIGGER ifexists fullname */
+      case 279: /* cmd ::= DROP TRIGGER ifexists fullname */
 {
-  sqlite3DropTrigger(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy192);
+  sqlite3DropTrigger(pParse,yymsp[0].minor.yy607,yymsp[-1].minor.yy64);
 }
         break;
-      case 271: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+      case 280: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
 {
-  sqlite3Attach(pParse, yymsp[-3].minor.yy202, yymsp[-1].minor.yy202, yymsp[0].minor.yy202);
+  sqlite3Attach(pParse, yymsp[-3].minor.yy626, yymsp[-1].minor.yy626, yymsp[0].minor.yy626);
 }
         break;
-      case 272: /* cmd ::= DETACH database_kw_opt expr */
+      case 281: /* cmd ::= DETACH database_kw_opt expr */
 {
-  sqlite3Detach(pParse, yymsp[0].minor.yy202);
+  sqlite3Detach(pParse, yymsp[0].minor.yy626);
 }
         break;
-      case 275: /* cmd ::= REINDEX */
+      case 284: /* cmd ::= REINDEX */
 {sqlite3Reindex(pParse, 0, 0);}
         break;
-      case 276: /* cmd ::= REINDEX nm dbnm */
+      case 285: /* cmd ::= REINDEX nm dbnm */
 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 277: /* cmd ::= ANALYZE */
+      case 286: /* cmd ::= ANALYZE */
 {sqlite3Analyze(pParse, 0, 0);}
         break;
-      case 278: /* cmd ::= ANALYZE nm dbnm */
+      case 287: /* cmd ::= ANALYZE nm dbnm */
 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 279: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
+      case 288: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
 {
-  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy47,&yymsp[0].minor.yy0);
+  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy607,&yymsp[0].minor.yy0);
 }
         break;
-      case 280: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
+      case 289: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
 {
   yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
   sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
 }
         break;
-      case 281: /* add_column_fullname ::= fullname */
+      case 290: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
+{
+  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy607, &yymsp[0].minor.yy0);
+}
+        break;
+      case 291: /* add_column_fullname ::= fullname */
 {
   disableLookaside(pParse);
-  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy47);
+  sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy607);
 }
         break;
-      case 282: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
+      case 292: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
 {
-  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy47, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy607, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
-      case 283: /* cmd ::= create_vtab */
+      case 293: /* cmd ::= create_vtab */
 {sqlite3VtabFinishParse(pParse,0);}
         break;
-      case 284: /* cmd ::= create_vtab LP vtabarglist RP */
+      case 294: /* cmd ::= create_vtab LP vtabarglist RP */
 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
         break;
-      case 285: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
+      case 295: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
 {
-    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy192);
+    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy64);
 }
         break;
-      case 286: /* vtabarg ::= */
+      case 296: /* vtabarg ::= */
 {sqlite3VtabArgInit(pParse);}
         break;
-      case 287: /* vtabargtoken ::= ANY */
-      case 288: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==288);
-      case 289: /* lp ::= LP */ yytestcase(yyruleno==289);
+      case 297: /* vtabargtoken ::= ANY */
+      case 298: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==298);
+      case 299: /* lp ::= LP */ yytestcase(yyruleno==299);
 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
         break;
-      case 290: /* with ::= WITH wqlist */
-      case 291: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==291);
-{ sqlite3WithPush(pParse, yymsp[0].minor.yy131, 1); }
+      case 300: /* with ::= WITH wqlist */
+      case 301: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==301);
+{ sqlite3WithPush(pParse, yymsp[0].minor.yy43, 1); }
+        break;
+      case 302: /* wqas ::= AS */
+{yymsp[0].minor.yy534 = M10d_Any;}
         break;
-      case 292: /* wqlist ::= nm eidlist_opt AS LP select RP */
+      case 303: /* wqas ::= AS MATERIALIZED */
+{yymsp[-1].minor.yy534 = M10d_Yes;}
+        break;
+      case 304: /* wqas ::= AS NOT MATERIALIZED */
+{yymsp[-2].minor.yy534 = M10d_No;}
+        break;
+      case 305: /* wqitem ::= nm eidlist_opt wqas LP select RP */
+{
+  yymsp[-5].minor.yy255 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy562, yymsp[-1].minor.yy303, yymsp[-3].minor.yy534); /*A-overwrites-X*/
+}
+        break;
+      case 306: /* wqlist ::= wqitem */
 {
-  yymsp[-5].minor.yy131 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539); /*A-overwrites-X*/
+  yymsp[0].minor.yy43 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy255); /*A-overwrites-X*/
 }
         break;
-      case 293: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
+      case 307: /* wqlist ::= wqlist COMMA wqitem */
 {
-  yymsp[-7].minor.yy131 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy131, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy242, yymsp[-1].minor.yy539);
+  yymsp[-2].minor.yy43 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy43, yymsp[0].minor.yy255);
 }
         break;
-      case 294: /* windowdefn_list ::= windowdefn */
-{ yylhsminor.yy303 = yymsp[0].minor.yy303; }
-  yymsp[0].minor.yy303 = yylhsminor.yy303;
+      case 308: /* windowdefn_list ::= windowdefn */
+{ yylhsminor.yy375 = yymsp[0].minor.yy375; }
+  yymsp[0].minor.yy375 = yylhsminor.yy375;
         break;
-      case 295: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
+      case 309: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
 {
-  assert( yymsp[0].minor.yy303!=0 );
-  sqlite3WindowChain(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy303);
-  yymsp[0].minor.yy303->pNextWin = yymsp[-2].minor.yy303;
-  yylhsminor.yy303 = yymsp[0].minor.yy303;
+  assert( yymsp[0].minor.yy375!=0 );
+  sqlite3WindowChain(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy375);
+  yymsp[0].minor.yy375->pNextWin = yymsp[-2].minor.yy375;
+  yylhsminor.yy375 = yymsp[0].minor.yy375;
 }
-  yymsp[-2].minor.yy303 = yylhsminor.yy303;
+  yymsp[-2].minor.yy375 = yylhsminor.yy375;
         break;
-      case 296: /* windowdefn ::= nm AS LP window RP */
+      case 310: /* windowdefn ::= nm AS LP window RP */
 {
-  if( ALWAYS(yymsp[-1].minor.yy303) ){
-    yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
+  if( ALWAYS(yymsp[-1].minor.yy375) ){
+    yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
   }
-  yylhsminor.yy303 = yymsp[-1].minor.yy303;
+  yylhsminor.yy375 = yymsp[-1].minor.yy375;
 }
-  yymsp[-4].minor.yy303 = yylhsminor.yy303;
+  yymsp[-4].minor.yy375 = yylhsminor.yy375;
         break;
-      case 297: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
+      case 311: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
 {
-  yymsp[-4].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, 0);
+  yymsp[-4].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, 0);
 }
         break;
-      case 298: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
+      case 312: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
 {
-  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, yymsp[-2].minor.yy242, yymsp[-1].minor.yy242, &yymsp[-5].minor.yy0);
+  yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy303 = yylhsminor.yy303;
+  yymsp[-5].minor.yy375 = yylhsminor.yy375;
         break;
-      case 299: /* window ::= ORDER BY sortlist frame_opt */
+      case 313: /* window ::= ORDER BY sortlist frame_opt */
 {
-  yymsp[-3].minor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, 0);
+  yymsp[-3].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, 0);
 }
         break;
-      case 300: /* window ::= nm ORDER BY sortlist frame_opt */
+      case 314: /* window ::= nm ORDER BY sortlist frame_opt */
 {
-  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, yymsp[-1].minor.yy242, &yymsp[-4].minor.yy0);
+  yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy303 = yylhsminor.yy303;
+  yymsp[-4].minor.yy375 = yylhsminor.yy375;
         break;
-      case 301: /* window ::= frame_opt */
-      case 320: /* filter_over ::= over_clause */ yytestcase(yyruleno==320);
+      case 315: /* window ::= frame_opt */
+      case 334: /* filter_over ::= over_clause */ yytestcase(yyruleno==334);
 {
-  yylhsminor.yy303 = yymsp[0].minor.yy303;
+  yylhsminor.yy375 = yymsp[0].minor.yy375;
 }
-  yymsp[0].minor.yy303 = yylhsminor.yy303;
+  yymsp[0].minor.yy375 = yylhsminor.yy375;
         break;
-      case 302: /* window ::= nm frame_opt */
+      case 316: /* window ::= nm frame_opt */
 {
-  yylhsminor.yy303 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy303, 0, 0, &yymsp[-1].minor.yy0);
+  yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, 0, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy303 = yylhsminor.yy303;
+  yymsp[-1].minor.yy375 = yylhsminor.yy375;
         break;
-      case 303: /* frame_opt ::= */
+      case 317: /* frame_opt ::= */
 {
-  yymsp[1].minor.yy303 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
+  yymsp[1].minor.yy375 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
 }
         break;
-      case 304: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
+      case 318: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
 {
-  yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy192, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy58);
+  yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy64, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy534);
 }
-  yymsp[-2].minor.yy303 = yylhsminor.yy303;
+  yymsp[-2].minor.yy375 = yylhsminor.yy375;
         break;
-      case 305: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
+      case 319: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
 {
-  yylhsminor.yy303 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy192, yymsp[-3].minor.yy77.eType, yymsp[-3].minor.yy77.pExpr, yymsp[-1].minor.yy77.eType, yymsp[-1].minor.yy77.pExpr, yymsp[0].minor.yy58);
+  yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy64, yymsp[-3].minor.yy81.eType, yymsp[-3].minor.yy81.pExpr, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, yymsp[0].minor.yy534);
 }
-  yymsp[-5].minor.yy303 = yylhsminor.yy303;
+  yymsp[-5].minor.yy375 = yylhsminor.yy375;
         break;
-      case 307: /* frame_bound_s ::= frame_bound */
-      case 309: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==309);
-{yylhsminor.yy77 = yymsp[0].minor.yy77;}
-  yymsp[0].minor.yy77 = yylhsminor.yy77;
+      case 321: /* frame_bound_s ::= frame_bound */
+      case 323: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==323);
+{yylhsminor.yy81 = yymsp[0].minor.yy81;}
+  yymsp[0].minor.yy81 = yylhsminor.yy81;
         break;
-      case 308: /* frame_bound_s ::= UNBOUNDED PRECEDING */
-      case 310: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==310);
-      case 312: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==312);
-{yylhsminor.yy77.eType = yymsp[-1].major; yylhsminor.yy77.pExpr = 0;}
-  yymsp[-1].minor.yy77 = yylhsminor.yy77;
+      case 322: /* frame_bound_s ::= UNBOUNDED PRECEDING */
+      case 324: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==324);
+      case 326: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==326);
+{yylhsminor.yy81.eType = yymsp[-1].major; yylhsminor.yy81.pExpr = 0;}
+  yymsp[-1].minor.yy81 = yylhsminor.yy81;
         break;
-      case 311: /* frame_bound ::= expr PRECEDING|FOLLOWING */
-{yylhsminor.yy77.eType = yymsp[0].major; yylhsminor.yy77.pExpr = yymsp[-1].minor.yy202;}
-  yymsp[-1].minor.yy77 = yylhsminor.yy77;
+      case 325: /* frame_bound ::= expr PRECEDING|FOLLOWING */
+{yylhsminor.yy81.eType = yymsp[0].major; yylhsminor.yy81.pExpr = yymsp[-1].minor.yy626;}
+  yymsp[-1].minor.yy81 = yylhsminor.yy81;
         break;
-      case 313: /* frame_exclude_opt ::= */
-{yymsp[1].minor.yy58 = 0;}
+      case 327: /* frame_exclude_opt ::= */
+{yymsp[1].minor.yy534 = 0;}
         break;
-      case 314: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
-{yymsp[-1].minor.yy58 = yymsp[0].minor.yy58;}
+      case 328: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
+{yymsp[-1].minor.yy534 = yymsp[0].minor.yy534;}
         break;
-      case 315: /* frame_exclude ::= NO OTHERS */
-      case 316: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==316);
-{yymsp[-1].minor.yy58 = yymsp[-1].major; /*A-overwrites-X*/}
+      case 329: /* frame_exclude ::= NO OTHERS */
+      case 330: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==330);
+{yymsp[-1].minor.yy534 = yymsp[-1].major; /*A-overwrites-X*/}
         break;
-      case 317: /* frame_exclude ::= GROUP|TIES */
-{yymsp[0].minor.yy58 = yymsp[0].major; /*A-overwrites-X*/}
+      case 331: /* frame_exclude ::= GROUP|TIES */
+{yymsp[0].minor.yy534 = yymsp[0].major; /*A-overwrites-X*/}
         break;
-      case 318: /* window_clause ::= WINDOW windowdefn_list */
-{ yymsp[-1].minor.yy303 = yymsp[0].minor.yy303; }
+      case 332: /* window_clause ::= WINDOW windowdefn_list */
+{ yymsp[-1].minor.yy375 = yymsp[0].minor.yy375; }
         break;
-      case 319: /* filter_over ::= filter_clause over_clause */
+      case 333: /* filter_over ::= filter_clause over_clause */
 {
-  yymsp[0].minor.yy303->pFilter = yymsp[-1].minor.yy202;
-  yylhsminor.yy303 = yymsp[0].minor.yy303;
+  if( yymsp[0].minor.yy375 ){
+    yymsp[0].minor.yy375->pFilter = yymsp[-1].minor.yy626;
+  }else{
+    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626);
+  }
+  yylhsminor.yy375 = yymsp[0].minor.yy375;
 }
-  yymsp[-1].minor.yy303 = yylhsminor.yy303;
+  yymsp[-1].minor.yy375 = yylhsminor.yy375;
         break;
-      case 321: /* filter_over ::= filter_clause */
+      case 335: /* filter_over ::= filter_clause */
 {
-  yylhsminor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yylhsminor.yy303 ){
-    yylhsminor.yy303->eFrmType = TK_FILTER;
-    yylhsminor.yy303->pFilter = yymsp[0].minor.yy202;
+  yylhsminor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
+  if( yylhsminor.yy375 ){
+    yylhsminor.yy375->eFrmType = TK_FILTER;
+    yylhsminor.yy375->pFilter = yymsp[0].minor.yy626;
   }else{
-    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy202);
+    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy626);
   }
 }
-  yymsp[0].minor.yy303 = yylhsminor.yy303;
+  yymsp[0].minor.yy375 = yylhsminor.yy375;
         break;
-      case 322: /* over_clause ::= OVER LP window RP */
+      case 336: /* over_clause ::= OVER LP window RP */
 {
-  yymsp[-3].minor.yy303 = yymsp[-1].minor.yy303;
-  assert( yymsp[-3].minor.yy303!=0 );
+  yymsp[-3].minor.yy375 = yymsp[-1].minor.yy375;
+  assert( yymsp[-3].minor.yy375!=0 );
 }
         break;
-      case 323: /* over_clause ::= OVER nm */
+      case 337: /* over_clause ::= OVER nm */
 {
-  yymsp[-1].minor.yy303 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( yymsp[-1].minor.yy303 ){
-    yymsp[-1].minor.yy303->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
+  yymsp[-1].minor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
+  if( yymsp[-1].minor.yy375 ){
+    yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
   }
 }
         break;
-      case 324: /* filter_clause ::= FILTER LP WHERE expr RP */
-{ yymsp[-4].minor.yy202 = yymsp[-1].minor.yy202; }
+      case 338: /* filter_clause ::= FILTER LP WHERE expr RP */
+{ yymsp[-4].minor.yy626 = yymsp[-1].minor.yy626; }
         break;
       default:
-      /* (325) input ::= cmdlist */ yytestcase(yyruleno==325);
-      /* (326) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==326);
-      /* (327) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=327);
-      /* (328) ecmd ::= SEMI */ yytestcase(yyruleno==328);
-      /* (329) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==329);
-      /* (330) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=330);
-      /* (331) trans_opt ::= */ yytestcase(yyruleno==331);
-      /* (332) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==332);
-      /* (333) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==333);
-      /* (334) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==334);
-      /* (335) savepoint_opt ::= */ yytestcase(yyruleno==335);
-      /* (336) cmd ::= create_table create_table_args */ yytestcase(yyruleno==336);
-      /* (337) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==337);
-      /* (338) columnlist ::= columnname carglist */ yytestcase(yyruleno==338);
-      /* (339) nm ::= ID|INDEXED */ yytestcase(yyruleno==339);
-      /* (340) nm ::= STRING */ yytestcase(yyruleno==340);
-      /* (341) nm ::= JOIN_KW */ yytestcase(yyruleno==341);
-      /* (342) typetoken ::= typename */ yytestcase(yyruleno==342);
-      /* (343) typename ::= ID|STRING */ yytestcase(yyruleno==343);
-      /* (344) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=344);
-      /* (345) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=345);
-      /* (346) carglist ::= carglist ccons */ yytestcase(yyruleno==346);
-      /* (347) carglist ::= */ yytestcase(yyruleno==347);
-      /* (348) ccons ::= NULL onconf */ yytestcase(yyruleno==348);
-      /* (349) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==349);
-      /* (350) ccons ::= AS generated */ yytestcase(yyruleno==350);
-      /* (351) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==351);
-      /* (352) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==352);
-      /* (353) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=353);
-      /* (354) tconscomma ::= */ yytestcase(yyruleno==354);
-      /* (355) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=355);
-      /* (356) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=356);
-      /* (357) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=357);
-      /* (358) oneselect ::= values */ yytestcase(yyruleno==358);
-      /* (359) sclp ::= selcollist COMMA */ yytestcase(yyruleno==359);
-      /* (360) as ::= ID|STRING */ yytestcase(yyruleno==360);
-      /* (361) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=361);
-      /* (362) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==362);
-      /* (363) exprlist ::= nexprlist */ yytestcase(yyruleno==363);
-      /* (364) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=364);
-      /* (365) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=365);
-      /* (366) nmnum ::= ON */ yytestcase(yyruleno==366);
-      /* (367) nmnum ::= DELETE */ yytestcase(yyruleno==367);
-      /* (368) nmnum ::= DEFAULT */ yytestcase(yyruleno==368);
-      /* (369) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==369);
-      /* (370) foreach_clause ::= */ yytestcase(yyruleno==370);
-      /* (371) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==371);
-      /* (372) trnm ::= nm */ yytestcase(yyruleno==372);
-      /* (373) tridxby ::= */ yytestcase(yyruleno==373);
-      /* (374) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==374);
-      /* (375) database_kw_opt ::= */ yytestcase(yyruleno==375);
-      /* (376) kwcolumn_opt ::= */ yytestcase(yyruleno==376);
-      /* (377) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==377);
-      /* (378) vtabarglist ::= vtabarg */ yytestcase(yyruleno==378);
-      /* (379) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==379);
-      /* (380) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==380);
-      /* (381) anylist ::= */ yytestcase(yyruleno==381);
-      /* (382) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==382);
-      /* (383) anylist ::= anylist ANY */ yytestcase(yyruleno==383);
-      /* (384) with ::= */ yytestcase(yyruleno==384);
+      /* (339) input ::= cmdlist */ yytestcase(yyruleno==339);
+      /* (340) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==340);
+      /* (341) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=341);
+      /* (342) ecmd ::= SEMI */ yytestcase(yyruleno==342);
+      /* (343) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==343);
+      /* (344) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=344);
+      /* (345) trans_opt ::= */ yytestcase(yyruleno==345);
+      /* (346) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==346);
+      /* (347) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==347);
+      /* (348) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==348);
+      /* (349) savepoint_opt ::= */ yytestcase(yyruleno==349);
+      /* (350) cmd ::= create_table create_table_args */ yytestcase(yyruleno==350);
+      /* (351) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=351);
+      /* (352) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==352);
+      /* (353) columnlist ::= columnname carglist */ yytestcase(yyruleno==353);
+      /* (354) nm ::= ID|INDEXED */ yytestcase(yyruleno==354);
+      /* (355) nm ::= STRING */ yytestcase(yyruleno==355);
+      /* (356) nm ::= JOIN_KW */ yytestcase(yyruleno==356);
+      /* (357) typetoken ::= typename */ yytestcase(yyruleno==357);
+      /* (358) typename ::= ID|STRING */ yytestcase(yyruleno==358);
+      /* (359) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=359);
+      /* (360) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=360);
+      /* (361) carglist ::= carglist ccons */ yytestcase(yyruleno==361);
+      /* (362) carglist ::= */ yytestcase(yyruleno==362);
+      /* (363) ccons ::= NULL onconf */ yytestcase(yyruleno==363);
+      /* (364) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==364);
+      /* (365) ccons ::= AS generated */ yytestcase(yyruleno==365);
+      /* (366) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==366);
+      /* (367) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==367);
+      /* (368) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=368);
+      /* (369) tconscomma ::= */ yytestcase(yyruleno==369);
+      /* (370) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=370);
+      /* (371) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=371);
+      /* (372) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=372);
+      /* (373) oneselect ::= values */ yytestcase(yyruleno==373);
+      /* (374) sclp ::= selcollist COMMA */ yytestcase(yyruleno==374);
+      /* (375) as ::= ID|STRING */ yytestcase(yyruleno==375);
+      /* (376) returning ::= */ yytestcase(yyruleno==376);
+      /* (377) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=377);
+      /* (378) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==378);
+      /* (379) exprlist ::= nexprlist */ yytestcase(yyruleno==379);
+      /* (380) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=380);
+      /* (381) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=381);
+      /* (382) nmnum ::= ON */ yytestcase(yyruleno==382);
+      /* (383) nmnum ::= DELETE */ yytestcase(yyruleno==383);
+      /* (384) nmnum ::= DEFAULT */ yytestcase(yyruleno==384);
+      /* (385) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==385);
+      /* (386) foreach_clause ::= */ yytestcase(yyruleno==386);
+      /* (387) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==387);
+      /* (388) trnm ::= nm */ yytestcase(yyruleno==388);
+      /* (389) tridxby ::= */ yytestcase(yyruleno==389);
+      /* (390) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==390);
+      /* (391) database_kw_opt ::= */ yytestcase(yyruleno==391);
+      /* (392) kwcolumn_opt ::= */ yytestcase(yyruleno==392);
+      /* (393) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==393);
+      /* (394) vtabarglist ::= vtabarg */ yytestcase(yyruleno==394);
+      /* (395) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==395);
+      /* (396) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==396);
+      /* (397) anylist ::= */ yytestcase(yyruleno==397);
+      /* (398) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==398);
+      /* (399) anylist ::= anylist ANY */ yytestcase(yyruleno==399);
+      /* (400) with ::= */ yytestcase(yyruleno==400);
         break;
 /********** End reduce actions ************************************************/
   };
@@ -159917,12 +164619,56 @@ SQLITE_PRIVATE void sqlite3Parser(
   }
 #endif
 
-  do{
+  while(1){ /* Exit by "break" */
+    assert( yypParser->yytos>=yypParser->yystack );
     assert( yyact==yypParser->yytos->stateno );
     yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
     if( yyact >= YY_MIN_REDUCE ){
-      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
-                        yyminor sqlite3ParserCTX_PARAM);
+      unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
+#ifndef NDEBUG
+      assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
+      if( yyTraceFILE ){
+        int yysize = yyRuleInfoNRhs[yyruleno];
+        if( yysize ){
+          fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
+            yyTracePrompt,
+            yyruleno, yyRuleName[yyruleno],
+            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
+            yypParser->yytos[yysize].stateno);
+        }else{
+          fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
+            yyTracePrompt, yyruleno, yyRuleName[yyruleno],
+            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
+        }
+      }
+#endif /* NDEBUG */
+
+      /* Check that the stack is large enough to grow by a single entry
+      ** if the RHS of the rule is empty.  This ensures that there is room
+      ** enough on the stack to push the LHS value */
+      if( yyRuleInfoNRhs[yyruleno]==0 ){
+#ifdef YYTRACKMAXSTACKDEPTH
+        if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+          yypParser->yyhwm++;
+          assert( yypParser->yyhwm ==
+                  (int)(yypParser->yytos - yypParser->yystack));
+        }
+#endif
+#if YYSTACKDEPTH>0
+        if( yypParser->yytos>=yypParser->yystackEnd ){
+          yyStackOverflow(yypParser);
+          break;
+        }
+#else
+        if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
+          if( yyGrowStack(yypParser) ){
+            yyStackOverflow(yypParser);
+            break;
+          }
+        }
+#endif
+      }
+      yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
       yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
 #ifndef YYNOERRORRECOVERY
@@ -159978,14 +164724,13 @@ SQLITE_PRIVATE void sqlite3Parser(
         yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
         yymajor = YYNOCODE;
       }else{
-        while( yypParser->yytos >= yypParser->yystack
-            && (yyact = yy_find_reduce_action(
-                        yypParser->yytos->stateno,
-                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
-        ){
+        while( yypParser->yytos > yypParser->yystack ){
+          yyact = yy_find_reduce_action(yypParser->yytos->stateno,
+                                        YYERRORSYMBOL);
+          if( yyact<=YY_MAX_SHIFTREDUCE ) break;
           yy_pop_parser_stack(yypParser);
         }
-        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
+        if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){
           yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
           yy_parse_failed(yypParser);
 #ifndef YYNOERRORRECOVERY
@@ -160035,7 +164780,7 @@ SQLITE_PRIVATE void sqlite3Parser(
       break;
 #endif
     }
-  }while( yypParser->yytos>yypParser->yystack );
+  }
 #ifndef NDEBUG
   if( yyTraceFILE ){
     yyStackEntry *i;
@@ -160096,8 +164841,8 @@ SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){
 ** all of them need to be used within the switch.
 */
 #define CC_X          0    /* The letter 'x', or start of BLOB literal */
-#define CC_KYWD       1    /* Alphabetics or '_'.  Usable in a keyword */
-#define CC_ID         2    /* unicode characters usable in IDs */
+#define CC_KYWD0      1    /* First letter of a keyword */
+#define CC_KYWD       2    /* Alphabetics or '_'.  Usable in a keyword */
 #define CC_DIGIT      3    /* Digits */
 #define CC_DOLLAR     4    /* '$' */
 #define CC_VARALPHA   5    /* '@', '#', ':'.  Alphabetic SQL variables */
@@ -160122,47 +164867,49 @@ SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){
 #define CC_AND       24    /* '&' */
 #define CC_TILDA     25    /* '~' */
 #define CC_DOT       26    /* '.' */
-#define CC_ILLEGAL   27    /* Illegal character */
-#define CC_NUL       28    /* 0x00 */
+#define CC_ID        27    /* unicode characters usable in IDs */
+#define CC_ILLEGAL   28    /* Illegal character */
+#define CC_NUL       29    /* 0x00 */
+#define CC_BOM       30    /* First byte of UTF8 BOM:  0xEF 0xBB 0xBF */
 
 static const unsigned char aiClass[] = {
 #ifdef SQLITE_ASCII
 /*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
-/* 0x */   28, 27, 27, 27, 27, 27, 27, 27, 27,  7,  7, 27,  7,  7, 27, 27,
-/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 0x */   29, 28, 28, 28, 28, 28, 28, 28, 28,  7,  7, 28,  7,  7, 28, 28,
+/* 1x */   28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 /* 2x */    7, 15,  8,  5,  4, 22, 24,  8, 17, 18, 21, 20, 23, 11, 26, 16,
 /* 3x */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  5, 19, 12, 14, 13,  6,
 /* 4x */    5,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-/* 5x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  9, 27, 27, 27,  1,
+/* 5x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  2,  2,  9, 28, 28, 28,  2,
 /* 6x */    8,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-/* 7x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1, 27, 10, 27, 25, 27,
-/* 8x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* 9x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Ax */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Bx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Cx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Dx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Ex */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-/* Fx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2
+/* 7x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  2,  2, 28, 10, 28, 25, 28,
+/* 8x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 9x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* Ax */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* Bx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* Cx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* Dx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* Ex */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 30,
+/* Fx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27
 #endif
 #ifdef SQLITE_EBCDIC
 /*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
-/* 0x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27,  7,  7, 27, 27,
-/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-/* 2x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-/* 3x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-/* 4x */    7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 12, 17, 20, 10,
-/* 5x */   24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15,  4, 21, 18, 19, 27,
-/* 6x */   11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22,  1, 13,  6,
-/* 7x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  8,  5,  5,  5,  8, 14,  8,
-/* 8x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
-/* 9x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
-/* Ax */   27, 25,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
-/* Bx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27,  9, 27, 27, 27, 27, 27,
-/* Cx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
-/* Dx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
-/* Ex */   27, 27,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
-/* Fx */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 27, 27, 27, 27, 27, 27,
+/* 0x */   29, 28, 28, 28, 28,  7, 28, 28, 28, 28, 28, 28,  7,  7, 28, 28,
+/* 1x */   28, 28, 28, 28, 28,  7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+/* 2x */   28, 28, 28, 28, 28,  7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+/* 3x */   28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+/* 4x */    7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 26, 12, 17, 20, 10,
+/* 5x */   24, 28, 28, 28, 28, 28, 28, 28, 28, 28, 15,  4, 21, 18, 19, 28,
+/* 6x */   11, 16, 28, 28, 28, 28, 28, 28, 28, 28, 28, 23, 22,  2, 13,  6,
+/* 7x */   28, 28, 28, 28, 28, 28, 28, 28, 28,  8,  5,  5,  5,  8, 14,  8,
+/* 8x */   28,  1,  1,  1,  1,  1,  1,  1,  1,  1, 28, 28, 28, 28, 28, 28,
+/* 9x */   28,  1,  1,  1,  1,  1,  1,  1,  1,  1, 28, 28, 28, 28, 28, 28,
+/* Ax */   28, 25,  1,  1,  1,  1,  1,  0,  2,  2, 28, 28, 28, 28, 28, 28,
+/* Bx */   28, 28, 28, 28, 28, 28, 28, 28, 28, 28,  9, 28, 28, 28, 28, 28,
+/* Cx */   28,  1,  1,  1,  1,  1,  1,  1,  1,  1, 28, 28, 28, 28, 28, 28,
+/* Dx */   28,  1,  1,  1,  1,  1,  1,  1,  1,  1, 28, 28, 28, 28, 28, 28,
+/* Ex */   28, 28,  1,  1,  1,  1,  1,  0,  2,  2, 28, 28, 28, 28, 28, 28,
+/* Fx */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 28, 28, 28, 28, 28, 28,
 #endif
 };
 
@@ -160227,20 +164974,21 @@ const unsigned char ebcdicToAscii[] = {
 ** is substantially reduced.  This is important for embedded applications
 ** on platforms with limited memory.
 */
-/* Hash score: 227 */
-/* zKWText[] encodes 984 bytes of keyword text in 648 bytes */
+/* Hash score: 231 */
+/* zKWText[] encodes 1007 bytes of keyword text in 667 bytes */
 /*   REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT       */
 /*   ABLEFTHENDEFERRABLELSEXCLUDELETEMPORARYISNULLSAVEPOINTERSECT       */
 /*   IESNOTNULLIKEXCEPTRANSACTIONATURALTERAISEXCLUSIVEXISTS             */
 /*   CONSTRAINTOFFSETRIGGERANGENERATEDETACHAVINGLOBEGINNEREFERENCES     */
 /*   UNIQUERYWITHOUTERELEASEATTACHBETWEENOTHINGROUPSCASCADEFAULT        */
 /*   CASECOLLATECREATECURRENT_DATEIMMEDIATEJOINSERTMATCHPLANALYZE       */
-/*   PRAGMABORTUPDATEVALUESVIRTUALWAYSWHENWHERECURSIVEAFTERENAMEAND     */
-/*   EFERREDISTINCTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS           */
-/*   CURRENT_TIMESTAMPARTITIONDROPRECEDINGFAILASTFILTEREPLACEFIRST      */
-/*   FOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVERIGHTROLLBACKROWS      */
-/*   UNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBYINITIALLYPRIMARY               */
-static const char zKWText[647] = {
+/*   PRAGMATERIALIZEDEFERREDISTINCTUPDATEVALUESVIRTUALWAYSWHENWHERE     */
+/*   CURSIVEABORTAFTERENAMEANDROPARTITIONAUTOINCREMENTCASTCOLUMN        */
+/*   COMMITCONFLICTCROSSCURRENT_TIMESTAMPRECEDINGFAILASTFILTER          */
+/*   EPLACEFIRSTFOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVER           */
+/*   ETURNINGRIGHTROLLBACKROWSUNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBY      */
+/*   INITIALLYPRIMARY                                                   */
+static const char zKWText[666] = {
   'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
   'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
   'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',
@@ -160261,86 +165009,87 @@ static const char zKWText[647] = {
   'C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A','T','E',
   'I','M','M','E','D','I','A','T','E','J','O','I','N','S','E','R','T','M',
   'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M',
-  'A','B','O','R','T','U','P','D','A','T','E','V','A','L','U','E','S','V',
-  'I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H','E','R',
-  'E','C','U','R','S','I','V','E','A','F','T','E','R','E','N','A','M','E',
-  'A','N','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','A',
-  'U','T','O','I','N','C','R','E','M','E','N','T','C','A','S','T','C','O',
-  'L','U','M','N','C','O','M','M','I','T','C','O','N','F','L','I','C','T',
-  'C','R','O','S','S','C','U','R','R','E','N','T','_','T','I','M','E','S',
-  'T','A','M','P','A','R','T','I','T','I','O','N','D','R','O','P','R','E',
-  'C','E','D','I','N','G','F','A','I','L','A','S','T','F','I','L','T','E',
-  'R','E','P','L','A','C','E','F','I','R','S','T','F','O','L','L','O','W',
-  'I','N','G','F','R','O','M','F','U','L','L','I','M','I','T','I','F','O',
-  'R','D','E','R','E','S','T','R','I','C','T','O','T','H','E','R','S','O',
-  'V','E','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O','W',
-  'S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S','I',
-  'N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W','B',
-  'Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y',
+  'A','T','E','R','I','A','L','I','Z','E','D','E','F','E','R','R','E','D',
+  'I','S','T','I','N','C','T','U','P','D','A','T','E','V','A','L','U','E',
+  'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H',
+  'E','R','E','C','U','R','S','I','V','E','A','B','O','R','T','A','F','T',
+  'E','R','E','N','A','M','E','A','N','D','R','O','P','A','R','T','I','T',
+  'I','O','N','A','U','T','O','I','N','C','R','E','M','E','N','T','C','A',
+  'S','T','C','O','L','U','M','N','C','O','M','M','I','T','C','O','N','F',
+  'L','I','C','T','C','R','O','S','S','C','U','R','R','E','N','T','_','T',
+  'I','M','E','S','T','A','M','P','R','E','C','E','D','I','N','G','F','A',
+  'I','L','A','S','T','F','I','L','T','E','R','E','P','L','A','C','E','F',
+  'I','R','S','T','F','O','L','L','O','W','I','N','G','F','R','O','M','F',
+  'U','L','L','I','M','I','T','I','F','O','R','D','E','R','E','S','T','R',
+  'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N',
+  'I','N','G','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O',
+  'W','S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S',
+  'I','N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W',
+  'B','Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y',
 };
 /* aKWHash[i] is the hash value for the i-th keyword */
 static const unsigned char aKWHash[127] = {
-    84, 102, 132,  82, 114,  29,   0,   0,  91,   0,  85,  72,   0,
-    53,  35,  86,  15,   0,  42,  94,  54, 126, 133,  19,   0,   0,
-   138,   0,  40, 128,   0,  22, 104,   0,   9,   0,   0, 122,  80,
-     0,  78,   6,   0,  65,  99, 145,   0, 134, 112,   0,   0,  48,
-     0, 100,  24,   0,  17,   0,  27,  70,  23,  26,   5,  60, 140,
-   107, 121,   0,  73, 101,  71, 143,  61, 119,  74,   0,  49,   0,
-    11,  41,   0, 110,   0,   0,   0, 106,  10, 108, 113, 124,  14,
-    50, 123,   0,  89,   0,  18, 120, 142,  56, 129, 137,  88,  83,
-    37,  30, 125,   0,   0, 105,  51, 130, 127,   0,  34,   0,   0,
-    44,   0,  95,  38,  39,   0,  20,  45, 116,  90,
+    84,  92, 134,  82, 105,  29,   0,   0,  94,   0,  85,  72,   0,
+    53,  35,  86,  15,   0,  42,  97,  54,  89, 135,  19,   0,   0,
+   140,   0,  40, 129,   0,  22, 107,   0,   9,   0,   0, 123,  80,
+     0,  78,   6,   0,  65, 103, 147,   0, 136, 115,   0,   0,  48,
+     0,  90,  24,   0,  17,   0,  27,  70,  23,  26,   5,  60, 142,
+   110, 122,   0,  73,  91,  71, 145,  61, 120,  74,   0,  49,   0,
+    11,  41,   0, 113,   0,   0,   0, 109,  10, 111, 116, 125,  14,
+    50, 124,   0, 100,   0,  18, 121, 144,  56, 130, 139,  88,  83,
+    37,  30, 126,   0,   0, 108,  51, 131, 128,   0,  34,   0,   0,
+   132,   0,  98,  38,  39,   0,  20,  45, 117,  93,
 };
 /* aKWNext[] forms the hash collision chain.  If aKWHash[i]==0
 ** then the i-th keyword has no more hash collisions.  Otherwise,
 ** the next keyword with the same hash is aKWHash[i]-1. */
-static const unsigned char aKWNext[145] = {
-     0,   0,   0,   0,   4,   0,  43,   0,   0, 103, 111,   0,   0,
-     0,   2,   0,   0, 141,   0,   0,   0,  13,   0,   0,   0,   0,
-   139,   0,   0, 118,  52,   0,   0, 135,  12,   0,   0,  62,   0,
-   136,   0, 131,   0,   0,  36,   0,   0,  28,  77,   0,   0,   0,
+static const unsigned char aKWNext[147] = {
+     0,   0,   0,   0,   4,   0,  43,   0,   0, 106, 114,   0,   0,
+     0,   2,   0,   0, 143,   0,   0,   0,  13,   0,   0,   0,   0,
+   141,   0,   0, 119,  52,   0,   0, 137,  12,   0,   0,  62,   0,
+   138,   0, 133,   0,   0,  36,   0,   0,  28,  77,   0,   0,   0,
      0,  59,   0,  47,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-     0,  69,   0,   0,   0,   0,   0, 144,   3,   0,  58,   0,   1,
-    75,   0,   0,   0,  31,   0,   0,   0,   0,   0,   0,  64,  66,
-    63,   0,   0,   0,   0,  46,   0,  16,   0, 115,   0,   0,   0,
-     0,   0,   0,   0,   0,   0,   0,  81,  97,   0,   8,   0, 109,
-    21,   7,  67,   0,  79,  93, 117,   0,   0,  68,   0,   0,  96,
-     0,  55,   0,  76,   0,  92,  32,  33,  57,  25,   0,  98,   0,
-     0,  87,
+     0,  69,   0,   0,   0,   0,   0, 146,   3,   0,  58,   0,   1,
+    75,   0,   0,   0,  31,   0,   0,   0,   0,   0, 127,   0, 104,
+     0,  64,  66,  63,   0,   0,   0,   0,   0,  46,   0,  16,   8,
+     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  81, 101,   0,
+   112,  21,   7,  67,   0,  79,  96, 118,   0,   0,  68,   0,   0,
+    99,  44,   0,  55,   0,  76,   0,  95,  32,  33,  57,  25,   0,
+   102,   0,   0,  87,
 };
 /* aKWLen[i] is the length (in bytes) of the i-th keyword */
-static const unsigned char aKWLen[145] = {
+static const unsigned char aKWLen[147] = {
      7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
      7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   7,
      6,   9,   4,   2,   6,   5,   9,   9,   4,   7,   3,   2,   4,
      4,   6,  11,   6,   2,   7,   5,   5,   9,   6,  10,   4,   6,
      2,   3,   7,   5,   9,   6,   6,   4,   5,   5,  10,   6,   5,
      7,   4,   5,   7,   6,   7,   7,   6,   5,   7,   3,   7,   4,
-     7,   6,  12,   9,   4,   6,   5,   4,   7,   6,   5,   6,   6,
-     7,   6,   4,   5,   9,   5,   6,   3,   8,   8,   2,  13,   2,
-     2,   4,   6,   6,   8,   5,  17,  12,   7,   9,   4,   9,   4,
-     4,   6,   7,   5,   9,   4,   4,   5,   2,   5,   8,   6,   4,
-     5,   8,   4,   3,   9,   5,   5,   6,   4,   6,   2,   2,   9,
-     3,   7,
+     7,   6,  12,   9,   4,   6,   5,   4,   7,   6,  12,   8,   8,
+     2,   6,   6,   7,   6,   4,   5,   9,   5,   5,   6,   3,   4,
+     9,  13,   2,   2,   4,   6,   6,   8,   5,  17,  12,   7,   9,
+     4,   4,   6,   7,   5,   9,   4,   4,   5,   2,   5,   8,   6,
+     4,   9,   5,   8,   4,   3,   9,   5,   5,   6,   4,   6,   2,
+     2,   9,   3,   7,
 };
 /* aKWOffset[i] is the index into zKWText[] of the start of
 ** the text for the i-th keyword. */
-static const unsigned short int aKWOffset[145] = {
+static const unsigned short int aKWOffset[147] = {
      0,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
     36,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
     86,  90,  90,  94,  99, 101, 105, 111, 119, 123, 123, 123, 126,
    129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184,
    184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239,
    244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295,
-   299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 360, 365, 371,
-   377, 382, 388, 392, 395, 404, 408, 414, 416, 423, 424, 431, 433,
-   435, 444, 448, 454, 460, 468, 473, 473, 473, 489, 498, 501, 510,
-   513, 517, 522, 529, 534, 543, 547, 550, 555, 557, 561, 569, 575,
-   578, 583, 591, 591, 595, 604, 609, 614, 620, 623, 626, 629, 631,
-   636, 640,
+   299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 359, 370, 377,
+   378, 385, 391, 397, 402, 408, 412, 415, 424, 429, 433, 439, 441,
+   444, 453, 455, 457, 466, 470, 476, 482, 490, 495, 495, 495, 511,
+   520, 523, 527, 532, 539, 544, 553, 557, 560, 565, 567, 571, 579,
+   585, 588, 597, 602, 610, 610, 614, 623, 628, 633, 639, 642, 645,
+   648, 650, 655, 659,
 };
 /* aKWCode[i] is the parser symbol code for the i-th keyword */
-static const unsigned char aKWCode[145] = {
+static const unsigned char aKWCode[147] = {
   TK_REINDEX,    TK_INDEXED,    TK_INDEX,      TK_DESC,       TK_ESCAPE,
   TK_EACH,       TK_CHECK,      TK_KEY,        TK_BEFORE,     TK_FOREIGN,
   TK_FOR,        TK_IGNORE,     TK_LIKE_KW,    TK_EXPLAIN,    TK_INSTEAD,
@@ -160358,18 +165107,19 @@ static const unsigned char aKWCode[145] = {
   TK_BETWEEN,    TK_NOTHING,    TK_GROUPS,     TK_GROUP,      TK_CASCADE,
   TK_ASC,        TK_DEFAULT,    TK_CASE,       TK_COLLATE,    TK_CREATE,
   TK_CTIME_KW,   TK_IMMEDIATE,  TK_JOIN,       TK_INSERT,     TK_MATCH,
-  TK_PLAN,       TK_ANALYZE,    TK_PRAGMA,     TK_ABORT,      TK_UPDATE,
-  TK_VALUES,     TK_VIRTUAL,    TK_ALWAYS,     TK_WHEN,       TK_WHERE,
-  TK_RECURSIVE,  TK_AFTER,      TK_RENAME,     TK_AND,        TK_DEFERRED,
-  TK_DISTINCT,   TK_IS,         TK_AUTOINCR,   TK_TO,         TK_IN,
-  TK_CAST,       TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,
-  TK_CTIME_KW,   TK_CTIME_KW,   TK_CURRENT,    TK_PARTITION,  TK_DROP,
-  TK_PRECEDING,  TK_FAIL,       TK_LAST,       TK_FILTER,     TK_REPLACE,
-  TK_FIRST,      TK_FOLLOWING,  TK_FROM,       TK_JOIN_KW,    TK_LIMIT,
-  TK_IF,         TK_ORDER,      TK_RESTRICT,   TK_OTHERS,     TK_OVER,
-  TK_JOIN_KW,    TK_ROLLBACK,   TK_ROWS,       TK_ROW,        TK_UNBOUNDED,
-  TK_UNION,      TK_USING,      TK_VACUUM,     TK_VIEW,       TK_WINDOW,
-  TK_DO,         TK_BY,         TK_INITIALLY,  TK_ALL,        TK_PRIMARY,
+  TK_PLAN,       TK_ANALYZE,    TK_PRAGMA,     TK_MATERIALIZED, TK_DEFERRED,
+  TK_DISTINCT,   TK_IS,         TK_UPDATE,     TK_VALUES,     TK_VIRTUAL,
+  TK_ALWAYS,     TK_WHEN,       TK_WHERE,      TK_RECURSIVE,  TK_ABORT,
+  TK_AFTER,      TK_RENAME,     TK_AND,        TK_DROP,       TK_PARTITION,
+  TK_AUTOINCR,   TK_TO,         TK_IN,         TK_CAST,       TK_COLUMNKW,
+  TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,    TK_CTIME_KW,   TK_CTIME_KW,
+  TK_CURRENT,    TK_PRECEDING,  TK_FAIL,       TK_LAST,       TK_FILTER,
+  TK_REPLACE,    TK_FIRST,      TK_FOLLOWING,  TK_FROM,       TK_JOIN_KW,
+  TK_LIMIT,      TK_IF,         TK_ORDER,      TK_RESTRICT,   TK_OTHERS,
+  TK_OVER,       TK_RETURNING,  TK_JOIN_KW,    TK_ROLLBACK,   TK_ROWS,
+  TK_ROW,        TK_UNBOUNDED,  TK_UNION,      TK_USING,      TK_VACUUM,
+  TK_VIEW,       TK_WINDOW,     TK_DO,         TK_BY,         TK_INITIALLY,
+  TK_ALL,        TK_PRIMARY,
 };
 /* Hash table decoded:
 **   0: INSERT
@@ -160393,7 +165143,7 @@ static const unsigned char aKWCode[145] = {
 **  18: TRANSACTION RIGHT
 **  19: WHEN
 **  20: SET HAVING
-**  21: IF
+**  21: MATERIALIZED IF
 **  22: ROWS
 **  23: SELECT
 **  24:
@@ -160489,7 +165239,7 @@ static const unsigned char aKWCode[145] = {
 ** 114: INTERSECT UNBOUNDED
 ** 115:
 ** 116:
-** 117: ON
+** 117: RETURNING ON
 ** 118:
 ** 119: WHERE
 ** 120: NO INNER
@@ -160507,7 +165257,7 @@ static int keywordCode(const char *z, int n, int *pType){
   int i, j;
   const char *zKW;
   if( n>=2 ){
-    i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127;
+    i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n*1) % 127;
     for(i=((int)aKWHash[i])-1; i>=0; i=((int)aKWNext[i])-1){
       if( aKWLen[i]!=n ) continue;
       zKW = &zKWText[aKWOffset[i]];
@@ -160612,63 +165362,65 @@ static int keywordCode(const char *z, int n, int *pType){
       testcase( i==85 ); /* PLAN */
       testcase( i==86 ); /* ANALYZE */
       testcase( i==87 ); /* PRAGMA */
-      testcase( i==88 ); /* ABORT */
-      testcase( i==89 ); /* UPDATE */
-      testcase( i==90 ); /* VALUES */
-      testcase( i==91 ); /* VIRTUAL */
-      testcase( i==92 ); /* ALWAYS */
-      testcase( i==93 ); /* WHEN */
-      testcase( i==94 ); /* WHERE */
-      testcase( i==95 ); /* RECURSIVE */
-      testcase( i==96 ); /* AFTER */
-      testcase( i==97 ); /* RENAME */
-      testcase( i==98 ); /* AND */
-      testcase( i==99 ); /* DEFERRED */
-      testcase( i==100 ); /* DISTINCT */
-      testcase( i==101 ); /* IS */
-      testcase( i==102 ); /* AUTOINCREMENT */
-      testcase( i==103 ); /* TO */
-      testcase( i==104 ); /* IN */
-      testcase( i==105 ); /* CAST */
-      testcase( i==106 ); /* COLUMN */
-      testcase( i==107 ); /* COMMIT */
-      testcase( i==108 ); /* CONFLICT */
-      testcase( i==109 ); /* CROSS */
-      testcase( i==110 ); /* CURRENT_TIMESTAMP */
-      testcase( i==111 ); /* CURRENT_TIME */
-      testcase( i==112 ); /* CURRENT */
-      testcase( i==113 ); /* PARTITION */
-      testcase( i==114 ); /* DROP */
-      testcase( i==115 ); /* PRECEDING */
-      testcase( i==116 ); /* FAIL */
-      testcase( i==117 ); /* LAST */
-      testcase( i==118 ); /* FILTER */
-      testcase( i==119 ); /* REPLACE */
-      testcase( i==120 ); /* FIRST */
-      testcase( i==121 ); /* FOLLOWING */
-      testcase( i==122 ); /* FROM */
-      testcase( i==123 ); /* FULL */
-      testcase( i==124 ); /* LIMIT */
-      testcase( i==125 ); /* IF */
-      testcase( i==126 ); /* ORDER */
-      testcase( i==127 ); /* RESTRICT */
-      testcase( i==128 ); /* OTHERS */
-      testcase( i==129 ); /* OVER */
-      testcase( i==130 ); /* RIGHT */
-      testcase( i==131 ); /* ROLLBACK */
-      testcase( i==132 ); /* ROWS */
-      testcase( i==133 ); /* ROW */
-      testcase( i==134 ); /* UNBOUNDED */
-      testcase( i==135 ); /* UNION */
-      testcase( i==136 ); /* USING */
-      testcase( i==137 ); /* VACUUM */
-      testcase( i==138 ); /* VIEW */
-      testcase( i==139 ); /* WINDOW */
-      testcase( i==140 ); /* DO */
-      testcase( i==141 ); /* BY */
-      testcase( i==142 ); /* INITIALLY */
-      testcase( i==143 ); /* ALL */
-      testcase( i==144 ); /* PRIMARY */
+      testcase( i==88 ); /* MATERIALIZED */
+      testcase( i==89 ); /* DEFERRED */
+      testcase( i==90 ); /* DISTINCT */
+      testcase( i==91 ); /* IS */
+      testcase( i==92 ); /* UPDATE */
+      testcase( i==93 ); /* VALUES */
+      testcase( i==94 ); /* VIRTUAL */
+      testcase( i==95 ); /* ALWAYS */
+      testcase( i==96 ); /* WHEN */
+      testcase( i==97 ); /* WHERE */
+      testcase( i==98 ); /* RECURSIVE */
+      testcase( i==99 ); /* ABORT */
+      testcase( i==100 ); /* AFTER */
+      testcase( i==101 ); /* RENAME */
+      testcase( i==102 ); /* AND */
+      testcase( i==103 ); /* DROP */
+      testcase( i==104 ); /* PARTITION */
+      testcase( i==105 ); /* AUTOINCREMENT */
+      testcase( i==106 ); /* TO */
+      testcase( i==107 ); /* IN */
+      testcase( i==108 ); /* CAST */
+      testcase( i==109 ); /* COLUMN */
+      testcase( i==110 ); /* COMMIT */
+      testcase( i==111 ); /* CONFLICT */
+      testcase( i==112 ); /* CROSS */
+      testcase( i==113 ); /* CURRENT_TIMESTAMP */
+      testcase( i==114 ); /* CURRENT_TIME */
+      testcase( i==115 ); /* CURRENT */
+      testcase( i==116 ); /* PRECEDING */
+      testcase( i==117 ); /* FAIL */
+      testcase( i==118 ); /* LAST */
+      testcase( i==119 ); /* FILTER */
+      testcase( i==120 ); /* REPLACE */
+      testcase( i==121 ); /* FIRST */
+      testcase( i==122 ); /* FOLLOWING */
+      testcase( i==123 ); /* FROM */
+      testcase( i==124 ); /* FULL */
+      testcase( i==125 ); /* LIMIT */
+      testcase( i==126 ); /* IF */
+      testcase( i==127 ); /* ORDER */
+      testcase( i==128 ); /* RESTRICT */
+      testcase( i==129 ); /* OTHERS */
+      testcase( i==130 ); /* OVER */
+      testcase( i==131 ); /* RETURNING */
+      testcase( i==132 ); /* RIGHT */
+      testcase( i==133 ); /* ROLLBACK */
+      testcase( i==134 ); /* ROWS */
+      testcase( i==135 ); /* ROW */
+      testcase( i==136 ); /* UNBOUNDED */
+      testcase( i==137 ); /* UNION */
+      testcase( i==138 ); /* USING */
+      testcase( i==139 ); /* VACUUM */
+      testcase( i==140 ); /* VIEW */
+      testcase( i==141 ); /* WINDOW */
+      testcase( i==142 ); /* DO */
+      testcase( i==143 ); /* BY */
+      testcase( i==144 ); /* INITIALLY */
+      testcase( i==145 ); /* ALL */
+      testcase( i==146 ); /* PRIMARY */
       *pType = aKWCode[i];
       break;
     }
@@ -160680,7 +165432,7 @@ SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
   keywordCode((char*)z, n, &id);
   return id;
 }
-#define SQLITE_N_KEYWORD 145
+#define SQLITE_N_KEYWORD 147
 SQLITE_API int sqlite3_keyword_name(int i,const char **pzName,int *pnName){
   if( i<0 || i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR;
   *pzName = zKWText + aKWOffset[i];
@@ -161049,7 +165801,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       if( n==0 ) *tokenType = TK_ILLEGAL;
       return i;
     }
-    case CC_KYWD: {
+    case CC_KYWD0: {
       for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
       if( IdChar(z[i]) ){
         /* This token started out using characters that can appear in keywords,
@@ -161079,10 +165831,19 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       ** SQL keywords start with the letter 'x'.  Fall through */
       /* no break */ deliberate_fall_through
     }
+    case CC_KYWD:
     case CC_ID: {
       i = 1;
       break;
     }
+    case CC_BOM: {
+      if( z[1]==0xbb && z[2]==0xbf ){
+        *tokenType = TK_SPACE;
+        return 3;
+      }
+      i = 1;
+      break;
+    }
     case CC_NUL: {
       *tokenType = TK_ILLEGAL;
       return 0;
@@ -161112,6 +165873,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   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 = 0;        /* Outer parse context, if any */
 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
   yyParser sEngine;    /* Space to hold the Lemon-generated Parser object */
 #endif
@@ -161147,7 +165909,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   assert( pParse->pNewTrigger==0 );
   assert( pParse->nVar==0 );
   assert( pParse->pVList==0 );
-  pParse->pParentParse = db->pParse;
+  pParentParse = db->pParse;
   db->pParse = pParse;
   while( 1 ){
     n = sqlite3GetToken((u8*)zSql, &tokenType);
@@ -161261,21 +166023,8 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   if( !IN_RENAME_OBJECT ){
     sqlite3DeleteTrigger(db, pParse->pNewTrigger);
   }
-
-  if( pParse->pWithToFree ) sqlite3WithDelete(db, pParse->pWithToFree);
   sqlite3DbFree(db, pParse->pVList);
-  while( pParse->pAinc ){
-    AutoincInfo *p = pParse->pAinc;
-    pParse->pAinc = p->pNext;
-    sqlite3DbFreeNN(db, p);
-  }
-  while( pParse->pZombieTab ){
-    Table *p = pParse->pZombieTab;
-    pParse->pZombieTab = p->pNextZombie;
-    sqlite3DeleteTable(db, p);
-  }
-  db->pParse = pParse->pParentParse;
-  pParse->pParentParse = 0;
+  db->pParse = pParentParse;
   assert( nErr==0 || pParse->rc!=SQLITE_OK );
   return nErr;
 }
@@ -162111,7 +166860,7 @@ SQLITE_API int sqlite3_initialize(void){
       sqlite3GlobalConfig.isPCacheInit = 1;
       rc = sqlite3OsInit();
     }
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
     if( rc==SQLITE_OK ){
       rc = sqlite3MemdbInit();
     }
@@ -162526,12 +167275,12 @@ SQLITE_API int sqlite3_config(int op, ...){
     }
 #endif /* SQLITE_ENABLE_SORTER_REFERENCES */
 
-#ifdef SQLITE_ENABLE_DESERIALIZE
+#ifndef SQLITE_OMIT_DESERIALIZE
     case SQLITE_CONFIG_MEMDB_MAXSIZE: {
       sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
       break;
     }
-#endif /* SQLITE_ENABLE_DESERIALIZE */
+#endif /* SQLITE_OMIT_DESERIALIZE */
 
     default: {
       rc = SQLITE_ERROR;
@@ -162892,7 +167641,7 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid)
 /*
 ** Return the number of changes in the most recent call to sqlite3_exec().
 */
-SQLITE_API int sqlite3_changes(sqlite3 *db){
+SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
@@ -162901,11 +167650,14 @@ SQLITE_API int sqlite3_changes(sqlite3 *db){
 #endif
   return db->nChange;
 }
+SQLITE_API int sqlite3_changes(sqlite3 *db){
+  return (int)sqlite3_changes64(db);
+}
 
 /*
 ** Return the number of changes since the database handle was opened.
 */
-SQLITE_API int sqlite3_total_changes(sqlite3 *db){
+SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;
@@ -162914,6 +167666,9 @@ SQLITE_API int sqlite3_total_changes(sqlite3 *db){
 #endif
   return db->nTotalChange;
 }
+SQLITE_API int sqlite3_total_changes(sqlite3 *db){
+  return (int)sqlite3_total_changes64(db);
+}
 
 /*
 ** Close all open savepoints. This function only manipulates fields of the
@@ -162938,7 +167693,9 @@ SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
 ** with SQLITE_ANY as the encoding.
 */
 static void functionDestroy(sqlite3 *db, FuncDef *p){
-  FuncDestructor *pDestructor = p->u.pDestructor;
+  FuncDestructor *pDestructor;
+  assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 );
+  pDestructor = p->u.pDestructor;
   if( pDestructor ){
     pDestructor->nRef--;
     if( pDestructor->nRef==0 ){
@@ -163042,7 +167799,7 @@ static int sqlite3Close(sqlite3 *db, int forceZombie){
 
   /* Convert the connection into a zombie and then close it.
   */
-  db->magic = SQLITE_MAGIC_ZOMBIE;
+  db->eOpenState = SQLITE_STATE_ZOMBIE;
   sqlite3LeaveMutexAndCloseZombie(db);
   return SQLITE_OK;
 }
@@ -163080,7 +167837,7 @@ SQLITE_API int sqlite3_txn_state(sqlite3 *db, const char *zSchema){
 /*
 ** Two variations on the public interface for closing a database
 ** connection. The sqlite3_close() version returns SQLITE_BUSY and
-** leaves the connection option if there are unfinalized prepared
+** leaves the connection open if there are unfinalized prepared
 ** statements or unfinished sqlite3_backups.  The sqlite3_close_v2()
 ** version forces the connection to become a zombie if there are
 ** unclosed resources, and arranges for deallocation when the last
@@ -163106,7 +167863,7 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
   ** or if the connection has not yet been closed by sqlite3_close_v2(),
   ** then just leave the mutex and return.
   */
-  if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){
+  if( db->eOpenState!=SQLITE_STATE_ZOMBIE || connectionIsBusy(db) ){
     sqlite3_mutex_leave(db->mutex);
     return;
   }
@@ -163192,7 +167949,7 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
   sqlite3_free(db->auth.zAuthPW);
 #endif
 
-  db->magic = SQLITE_MAGIC_ERROR;
+  db->eOpenState = SQLITE_STATE_ERROR;
 
   /* The temp-database schema is allocated differently from the other schema
   ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
@@ -163201,8 +167958,11 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
   ** structure?
   */
   sqlite3DbFree(db, db->aDb[1].pSchema);
+  if( db->xAutovacDestr ){
+    db->xAutovacDestr(db->pAutovacPagesArg);
+  }
   sqlite3_mutex_leave(db->mutex);
-  db->magic = SQLITE_MAGIC_CLOSED;
+  db->eOpenState = SQLITE_STATE_CLOSED;
   sqlite3_mutex_free(db->mutex);
   assert( sqlite3LookasideUsed(db,0)==0 );
   if( db->lookaside.bMalloced ){
@@ -163255,7 +168015,7 @@ SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){
   /* Any deferred constraint violations have now been resolved. */
   db->nDeferredCons = 0;
   db->nDeferredImmCons = 0;
-  db->flags &= ~(u64)SQLITE_DeferFKs;
+  db->flags &= ~(u64)(SQLITE_DeferFKs|SQLITE_CorruptRdOnly);
 
   /* If one has been configured, invoke the rollback-hook callback */
   if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
@@ -163590,7 +168350,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){
 */
 SQLITE_API void sqlite3_interrupt(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) && (db==0 || db->magic!=SQLITE_MAGIC_ZOMBIE) ){
+  if( !sqlite3SafetyCheckOk(db) && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) ){
     (void)SQLITE_MISUSE_BKPT;
     return;
   }
@@ -163619,7 +168379,6 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   FuncDestructor *pDestructor
 ){
   FuncDef *p;
-  int nName;
   int extraFlags;
 
   assert( sqlite3_mutex_held(db->mutex) );
@@ -163629,7 +168388,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
    || ((xFinal==0)!=(xStep==0))       /* Both or neither of xFinal and xStep */
    || ((xValue==0)!=(xInverse==0))    /* Both or neither of xValue, xInverse */
    || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG)
-   || (255<(nName = sqlite3Strlen30( zFunctionName)))
+   || (255<sqlite3Strlen30(zFunctionName))
   ){
     return SQLITE_MISUSE_BKPT;
   }
@@ -163654,22 +168413,33 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   ** If SQLITE_ANY is specified, add three versions of the function
   ** to the hash table.
   */
-  if( enc==SQLITE_UTF16 ){
-    enc = SQLITE_UTF16NATIVE;
-  }else if( enc==SQLITE_ANY ){
-    int rc;
-    rc = sqlite3CreateFunc(db, zFunctionName, nArg,
-         (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE,
-         pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
-    if( rc==SQLITE_OK ){
+  switch( enc ){
+    case SQLITE_UTF16:
+      enc = SQLITE_UTF16NATIVE;
+      break;
+    case SQLITE_ANY: {
+      int rc;
       rc = sqlite3CreateFunc(db, zFunctionName, nArg,
-           (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE,
+           (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE,
            pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
+      if( rc==SQLITE_OK ){
+        rc = sqlite3CreateFunc(db, zFunctionName, nArg,
+             (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE,
+             pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
+      }
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      enc = SQLITE_UTF16BE;
+      break;
     }
-    if( rc!=SQLITE_OK ){
-      return rc;
-    }
-    enc = SQLITE_UTF16BE;
+    case SQLITE_UTF8:
+    case SQLITE_UTF16LE:
+    case SQLITE_UTF16BE:
+      break;
+    default:
+      enc = SQLITE_UTF8;
+      break;
   }
 #else
   enc = SQLITE_UTF8;
@@ -163690,6 +168460,10 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
     }else{
       sqlite3ExpirePreparedStatements(db, 0);
     }
+  }else if( xSFunc==0 && xFinal==0 ){
+    /* Trying to delete a function that does not exist.  This is a no-op.
+    ** https://sqlite.org/forum/forumpost/726219164b */
+    return SQLITE_OK;
   }
 
   p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
@@ -163762,7 +168536,7 @@ static int createFunctionApi(
       xSFunc, xStep, xFinal, xValue, xInverse, pArg
   );
   if( pArg && pArg->nRef==0 ){
-    assert( rc!=SQLITE_OK );
+    assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) );
     xDestroy(p);
     sqlite3_free(pArg);
   }
@@ -164088,6 +168862,34 @@ SQLITE_API void *sqlite3_preupdate_hook(
 }
 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
 
+/*
+** Register a function to be invoked prior to each autovacuum that
+** determines the number of pages to vacuum.
+*/
+SQLITE_API int sqlite3_autovacuum_pages(
+  sqlite3 *db,                 /* Attach the hook to this database */
+  unsigned int (*xCallback)(void*,const char*,u32,u32,u32),
+  void *pArg,                  /* Argument to the function */
+  void (*xDestructor)(void*)   /* Destructor for pArg */
+){
+#ifdef SQLITE_ENABLE_API_ARMOR
+  if( !sqlite3SafetyCheckOk(db) ){
+    if( xDestructor ) xDestructor(pArg);
+    return SQLITE_MISUSE_BKPT;
+  }
+#endif
+  sqlite3_mutex_enter(db->mutex);
+  if( db->xAutovacDestr ){
+    db->xAutovacDestr(db->pAutovacPagesArg);
+  }
+  db->xAutovacPages = xCallback;
+  db->pAutovacPagesArg = pArg;
+  db->xAutovacDestr = xDestructor;
+  sqlite3_mutex_leave(db->mutex);
+  return SQLITE_OK;
+}
+
+
 #ifndef SQLITE_OMIT_WAL
 /*
 ** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
@@ -164180,7 +168982,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(
   return SQLITE_OK;
 #else
   int rc;                         /* Return code */
-  int iDb = SQLITE_MAX_ATTACHED;  /* sqlite3.aDb[] index of db to checkpoint */
+  int iDb;                        /* Schema to checkpoint */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
@@ -164203,6 +169005,8 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(
   sqlite3_mutex_enter(db->mutex);
   if( zDb && zDb[0] ){
     iDb = sqlite3FindDbName(db, zDb);
+  }else{
+    iDb = SQLITE_MAX_DB;   /* This means process all schemas */
   }
   if( iDb<0 ){
     rc = SQLITE_ERROR;
@@ -164251,7 +169055,7 @@ SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
 ** associated with the specific b-tree being checkpointed is taken by
 ** this function while the checkpoint is running.
 **
-** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
+** If iDb is passed SQLITE_MAX_DB then all attached databases are
 ** checkpointed. If an error is encountered it is returned immediately -
 ** no attempt is made to checkpoint any remaining databases.
 **
@@ -164266,9 +169070,11 @@ SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog
   assert( sqlite3_mutex_held(db->mutex) );
   assert( !pnLog || *pnLog==-1 );
   assert( !pnCkpt || *pnCkpt==-1 );
+  testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
+  testcase( iDb==SQLITE_MAX_DB );
 
   for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
-    if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
+    if( i==iDb || iDb==SQLITE_MAX_DB ){
       rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
       pnLog = 0;
       pnCkpt = 0;
@@ -164877,7 +169683,7 @@ SQLITE_PRIVATE int sqlite3ParseUri(
 */
 static const char *uriParameter(const char *zFilename, const char *zParam){
   zFilename += sqlite3Strlen30(zFilename) + 1;
-  while( zFilename[0] ){
+  while( ALWAYS(zFilename!=0) && zFilename[0] ){
     int x = strcmp(zFilename, zParam);
     zFilename += sqlite3Strlen30(zFilename) + 1;
     if( x==0 ) return zFilename;
@@ -164937,8 +169743,8 @@ static int openDatabase(
   ** dealt with in the previous code block.  Besides these, the only
   ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
   ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
-  ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits.  Silently mask
-  ** off all other flags.
+  ** SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_EXRESCODE, and some reserved
+  ** bits.  Silently mask off all other flags.
   */
   flags &=  ~( SQLITE_OPEN_DELETEONCLOSE |
                SQLITE_OPEN_EXCLUSIVE |
@@ -164973,9 +169779,9 @@ static int openDatabase(
     }
   }
   sqlite3_mutex_enter(db->mutex);
-  db->errMask = 0xff;
+  db->errMask = (flags & SQLITE_OPEN_EXRESCODE)!=0 ? 0xffffffff : 0xff;
   db->nDb = 2;
-  db->magic = SQLITE_MAGIC_BUSY;
+  db->eOpenState = SQLITE_STATE_BUSY;
   db->aDb = db->aDbStatic;
   db->lookaside.bDisable = 1;
   db->lookaside.sz = 0;
@@ -164987,7 +169793,15 @@ static int openDatabase(
   db->nextAutovac = -1;
   db->szMmap = sqlite3GlobalConfig.szMmap;
   db->nextPagesize = 0;
+  db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
+#ifdef SQLITE_ENABLE_SORTER_MMAP
+  /* Beginning with version 3.37.0, using the VFS xFetch() API to memory-map
+  ** the temporary files used to do external sorts (see code in vdbesort.c)
+  ** is disabled. It can still be used either by defining
+  ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the
+  ** SQLITE_TESTCTRL_SORTER_MMAP test-control at runtime. */
   db->nMaxSorterMmap = 0x7FFFFFFF;
+#endif
   db->flags |= SQLITE_ShortColNames
                  | SQLITE_EnableTrigger
                  | SQLITE_EnableView
@@ -165135,7 +169949,7 @@ static int openDatabase(
   db->aDb[1].zDbSName = "temp";
   db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF;
 
-  db->magic = SQLITE_MAGIC_OPEN;
+  db->eOpenState = SQLITE_STATE_OPEN;
   if( db->mallocFailed ){
     goto opendb_out;
   }
@@ -165197,12 +170011,12 @@ static int openDatabase(
     sqlite3_mutex_leave(db->mutex);
   }
   rc = sqlite3_errcode(db);
-  assert( db!=0 || rc==SQLITE_NOMEM );
-  if( rc==SQLITE_NOMEM ){
+  assert( db!=0 || (rc&0xff)==SQLITE_NOMEM );
+  if( (rc&0xff)==SQLITE_NOMEM ){
     sqlite3_close(db);
     db = 0;
   }else if( rc!=SQLITE_OK ){
-    db->magic = SQLITE_MAGIC_SICK;
+    db->eOpenState = SQLITE_STATE_SICK;
   }
   *ppDb = db;
 #ifdef SQLITE_ENABLE_SQLLOG
@@ -165213,7 +170027,7 @@ static int openDatabase(
   }
 #endif
   sqlite3_free_filename(zOpen);
-  return rc & 0xff;
+  return rc;
 }
 
 
@@ -165513,7 +170327,7 @@ SQLITE_API int sqlite3_table_column_metadata(
 
   /* Locate the table in question */
   pTab = sqlite3FindTable(db, zTableName, zDbName);
-  if( !pTab || pTab->pSelect ){
+  if( !pTab || IsView(pTab) ){
     pTab = 0;
     goto error_out;
   }
@@ -165524,7 +170338,7 @@ SQLITE_API int sqlite3_table_column_metadata(
   }else{
     for(iCol=0; iCol<pTab->nCol; iCol++){
       pCol = &pTab->aCol[iCol];
-      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
+      if( 0==sqlite3StrICmp(pCol->zCnName, zColumnName) ){
         break;
       }
     }
@@ -165551,7 +170365,7 @@ SQLITE_API int sqlite3_table_column_metadata(
   */
   if( pCol ){
     zDataType = sqlite3ColumnType(pCol,0);
-    zCollSeq = pCol->zColl;
+    zCollSeq = sqlite3ColumnColl(pCol);
     notnull = pCol->notNull!=0;
     primarykey  = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
     autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
@@ -165886,7 +170700,7 @@ SQLITE_API int sqlite3_test_control(int op, ...){
     */
     case SQLITE_TESTCTRL_OPTIMIZATIONS: {
       sqlite3 *db = va_arg(ap, sqlite3*);
-      db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
+      db->dbOptFlags = va_arg(ap, u32);
       break;
     }
 
@@ -166061,7 +170875,56 @@ SQLITE_API int sqlite3_test_control(int op, ...){
       break;
     }
 
+    /*  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, op, ptr)
+    **
+    **  "ptr" is a pointer to a u32.
+    **
+    **   op==0       Store the current sqlite3SelectTrace in *ptr
+    **   op==1       Set sqlite3SelectTrace to the value *ptr
+    **   op==3       Store the current sqlite3WhereTrace in *ptr
+    **   op==3       Set sqlite3WhereTrace to the value *ptr
+    */
+    case SQLITE_TESTCTRL_TRACEFLAGS: {
+       int opTrace = va_arg(ap, int);
+       u32 *ptr = va_arg(ap, u32*);
+       switch( opTrace ){
+         case 0:   *ptr = sqlite3SelectTrace;      break;
+         case 1:   sqlite3SelectTrace = *ptr;      break;
+         case 2:   *ptr = sqlite3WhereTrace;       break;
+         case 3:   sqlite3WhereTrace = *ptr;       break;
+       }
+       break;
+    }
 
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
+    /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
+    **
+    ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
+    ** of the id-th tuning parameter to *piValue.  If "id" is between -1
+    ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
+    ** tuning parameter into *piValue.
+    **
+    ** Tuning parameters are for use during transient development builds,
+    ** to help find the best values for constants in the query planner.
+    ** Access tuning parameters using the Tuning(ID) macro.  Set the
+    ** parameters in the CLI using ".testctrl tune ID VALUE".
+    **
+    ** Transient use only.  Tuning parameters should not be used in
+    ** checked-in code.
+    */
+    case SQLITE_TESTCTRL_TUNE: {
+      int id = va_arg(ap, int);
+      int *piValue = va_arg(ap, int*);
+      if( id>0 && id<=SQLITE_NTUNE ){
+        Tuning(id) = *piValue;
+      }else if( id<0 && id>=-SQLITE_NTUNE ){
+        *piValue = Tuning(-id);
+      }else{
+        rc = SQLITE_NOTFOUND;
+      }
+      break;
+    }
+#endif
   }
   va_end(ap);
 #endif /* SQLITE_UNTESTABLE */
@@ -166169,7 +171032,7 @@ SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N){
   if( zFilename==0 || N<0 ) return 0;
   zFilename = databaseName(zFilename);
   zFilename += sqlite3Strlen30(zFilename) + 1;
-  while( zFilename[0] && (N--)>0 ){
+  while( ALWAYS(zFilename) && zFilename[0] && (N--)>0 ){
     zFilename += sqlite3Strlen30(zFilename) + 1;
     zFilename += sqlite3Strlen30(zFilename) + 1;
   }
@@ -166212,12 +171075,14 @@ SQLITE_API sqlite3_int64 sqlite3_uri_int64(
 ** corruption.
 */
 SQLITE_API const char *sqlite3_filename_database(const char *zFilename){
+  if( zFilename==0 ) return 0;
   return databaseName(zFilename);
 }
 SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){
+  if( zFilename==0 ) return 0;
   zFilename = databaseName(zFilename);
   zFilename += sqlite3Strlen30(zFilename) + 1;
-  while( zFilename[0] ){
+  while( ALWAYS(zFilename) && zFilename[0] ){
     zFilename += sqlite3Strlen30(zFilename) + 1;
     zFilename += sqlite3Strlen30(zFilename) + 1;
   }
@@ -166228,7 +171093,7 @@ SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){
   return 0;
 #else
   zFilename = sqlite3_filename_journal(zFilename);
-  zFilename += sqlite3Strlen30(zFilename) + 1;
+  if( zFilename ) zFilename += sqlite3Strlen30(zFilename) + 1;
   return zFilename;
 #endif
 }
@@ -167504,7 +172369,7 @@ SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const voi
 ** is used for assert() conditions that are true only if it can be
 ** guranteed that the database is not corrupt.
 */
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
+#ifdef SQLITE_DEBUG
 SQLITE_API extern int sqlite3_fts3_may_be_corrupt;
 # define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x))
 #else
@@ -167521,17 +172386,18 @@ SQLITE_API extern int sqlite3_fts3_may_be_corrupt;
 ** Macros indicating that conditional expressions are always true or
 ** false.
 */
-#ifdef SQLITE_COVERAGE_TEST
-# define ALWAYS(x) (1)
-# define NEVER(X)  (0)
-#elif defined(SQLITE_DEBUG)
-# define ALWAYS(x) sqlite3Fts3Always((x)!=0)
-# define NEVER(x) sqlite3Fts3Never((x)!=0)
-SQLITE_PRIVATE int sqlite3Fts3Always(int b);
-SQLITE_PRIVATE int sqlite3Fts3Never(int b);
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
+#endif
+#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
+# define ALWAYS(X)      (1)
+# define NEVER(X)       (0)
+#elif !defined(NDEBUG)
+# define ALWAYS(X)      ((X)?1:(assert(0),0))
+# define NEVER(X)       ((X)?(assert(0),1):0)
 #else
-# define ALWAYS(x) (x)
-# define NEVER(x)  (x)
+# define ALWAYS(X)      (X)
+# define NEVER(X)       (X)
 #endif
 
 /*
@@ -167990,6 +172856,7 @@ SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *);
 SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*);
 SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db);
 #endif
+SQLITE_PRIVATE void *sqlite3Fts3MallocZero(i64 nByte);
 
 SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int,
   sqlite3_tokenizer_cursor **
@@ -168047,20 +172914,15 @@ static int fts3EvalStart(Fts3Cursor *pCsr);
 static int fts3TermSegReaderCursor(
     Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **);
 
-#ifndef SQLITE_AMALGAMATION
-# if defined(SQLITE_DEBUG)
-SQLITE_PRIVATE int sqlite3Fts3Always(int b) { assert( b ); return b; }
-SQLITE_PRIVATE int sqlite3Fts3Never(int b)  { assert( !b ); return b; }
-# endif
-#endif
-
 /*
 ** This variable is set to false when running tests for which the on disk
 ** structures should not be corrupt. Otherwise, true. If it is false, extra
 ** assert() conditions in the fts3 code are activated - conditions that are
 ** only true if it is guaranteed that the fts3 database is not corrupt.
 */
+#ifdef SQLITE_DEBUG
 SQLITE_API int sqlite3_fts3_may_be_corrupt = 1;
+#endif
 
 /*
 ** Write a 64-bit variable-length integer to memory starting at p[0].
@@ -169631,7 +174493,7 @@ static int fts3ScanInteriorNode(
   char *zBuffer = 0;              /* Buffer to load terms into */
   i64 nAlloc = 0;                 /* Size of allocated buffer */
   int isFirstTerm = 1;            /* True when processing first term on page */
-  sqlite3_int64 iChild;           /* Block id of child node to descend to */
+  u64 iChild;                     /* Block id of child node to descend to */
   int nBuffer = 0;                /* Total term size */
 
   /* Skip over the 'height' varint that occurs at the start of every
@@ -169647,8 +174509,8 @@ static int fts3ScanInteriorNode(
   ** table, then there are always 20 bytes of zeroed padding following the
   ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details).
   */
-  zCsr += sqlite3Fts3GetVarint(zCsr, &iChild);
-  zCsr += sqlite3Fts3GetVarint(zCsr, &iChild);
+  zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild);
+  zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild);
   if( zCsr>zEnd ){
     return FTS_CORRUPT_VTAB;
   }
@@ -169701,20 +174563,20 @@ static int fts3ScanInteriorNode(
     */
     cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer));
     if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){
-      *piFirst = iChild;
+      *piFirst = (i64)iChild;
       piFirst = 0;
     }
 
     if( piLast && cmp<0 ){
-      *piLast = iChild;
+      *piLast = (i64)iChild;
       piLast = 0;
     }
 
     iChild++;
   };
 
-  if( piFirst ) *piFirst = iChild;
-  if( piLast ) *piLast = iChild;
+  if( piFirst ) *piFirst = (i64)iChild;
+  if( piLast ) *piLast = (i64)iChild;
 
  finish_scan:
   sqlite3_free(zBuffer);
@@ -171320,14 +176182,20 @@ static int fts3SetHasStat(Fts3Table *p){
 */
 static int fts3BeginMethod(sqlite3_vtab *pVtab){
   Fts3Table *p = (Fts3Table*)pVtab;
+  int rc;
   UNUSED_PARAMETER(pVtab);
   assert( p->pSegments==0 );
   assert( p->nPendingData==0 );
   assert( p->inTransaction!=1 );
-  TESTONLY( p->inTransaction = 1 );
-  TESTONLY( p->mxSavepoint = -1; );
   p->nLeafAdd = 0;
-  return fts3SetHasStat(p);
+  rc = fts3SetHasStat(p);
+#ifdef SQLITE_DEBUG
+  if( rc==SQLITE_OK ){
+    p->inTransaction = 1;
+    p->mxSavepoint = -1;
+  }
+#endif
+  return rc;
 }
 
 /*
@@ -172856,16 +177724,15 @@ static int fts3EvalStart(Fts3Cursor *pCsr){
 #ifndef SQLITE_DISABLE_FTS4_DEFERRED
   if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
     Fts3TokenAndCost *aTC;
-    Fts3Expr **apOr;
     aTC = (Fts3TokenAndCost *)sqlite3_malloc64(
         sizeof(Fts3TokenAndCost) * nToken
       + sizeof(Fts3Expr *) * nOr * 2
     );
-    apOr = (Fts3Expr **)&aTC[nToken];
 
     if( !aTC ){
       rc = SQLITE_NOMEM;
     }else{
+      Fts3Expr **apOr = (Fts3Expr **)&aTC[nToken];
       int ii;
       Fts3TokenAndCost *pTC = aTC;
       Fts3Expr **ppOr = apOr;
@@ -172946,9 +177813,9 @@ static int fts3EvalNearTrim(
   );
   if( res ){
     nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
-    if( nNew>=0 ){
+    assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 );
+    if( nNew>=0 && nNew<=pPhrase->doclist.nList ){
       assert( pPhrase->doclist.pList[nNew]=='\0' );
-      assert( nNew<=pPhrase->doclist.nList && nNew>0 );
       memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
       pPhrase->doclist.nList = nNew;
     }
@@ -173071,8 +177938,8 @@ static void fts3EvalNextRow(
         Fts3Expr *pRight = pExpr->pRight;
         sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
 
-        assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
-        assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
+        assert_fts3_nc( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
+        assert_fts3_nc( pRight->bStart || pLeft->iDocid==pRight->iDocid );
 
         if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){
           fts3EvalNextRow(pCsr, pLeft, pRc);
@@ -173710,6 +178577,9 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(
         if( bEofSave==0 && pNear->iDocid==iDocid ) break;
       }
       assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
+      if( rc==SQLITE_OK && pNear->bEof!=bEofSave ){
+        rc = FTS_CORRUPT_VTAB;
+      }
     }
     if( bTreeEof ){
       while( rc==SQLITE_OK && !pNear->bEof ){
@@ -174132,6 +179002,7 @@ static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){
     if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
     memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
     iCol = 0;
+    rc = SQLITE_OK;
 
     while( i<nDoclist ){
       sqlite3_int64 v = 0;
@@ -174175,6 +179046,10 @@ static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){
         /* State 3. The integer just read is a column number. */
         default: assert( eState==3 );
           iCol = (int)v;
+          if( iCol<1 ){
+            rc = SQLITE_CORRUPT_VTAB;
+            break;
+          }
           if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
           pCsr->aStat[iCol+1].nDoc++;
           eState = 2;
@@ -174183,7 +179058,6 @@ static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){
     }
 
     pCsr->iCol = 0;
-    rc = SQLITE_OK;
   }else{
     pCsr->isEof = 1;
   }
@@ -174241,6 +179115,7 @@ static int fts3auxFilterMethod(
   sqlite3Fts3SegReaderFinish(&pCsr->csr);
   sqlite3_free((void *)pCsr->filter.zTerm);
   sqlite3_free(pCsr->aStat);
+  sqlite3_free(pCsr->zStop);
   memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
 
   pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
@@ -174511,7 +179386,7 @@ static int fts3isspace(char c){
 ** zero the memory before returning a pointer to it. If unsuccessful,
 ** return NULL.
 */
-static void *fts3MallocZero(sqlite3_int64 nByte){
+SQLITE_PRIVATE void *sqlite3Fts3MallocZero(sqlite3_int64 nByte){
   void *pRet = sqlite3_malloc64(nByte);
   if( pRet ) memset(pRet, 0, nByte);
   return pRet;
@@ -174592,7 +179467,7 @@ static int getNextToken(
     rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
     if( rc==SQLITE_OK ){
       nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
-      pRet = (Fts3Expr *)fts3MallocZero(nByte);
+      pRet = (Fts3Expr *)sqlite3Fts3MallocZero(nByte);
       if( !pRet ){
         rc = SQLITE_NOMEM;
       }else{
@@ -174847,7 +179722,7 @@ static int getNextNode(
       if( fts3isspace(cNext)
        || cNext=='"' || cNext=='(' || cNext==')' || cNext==0
       ){
-        pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr));
+        pRet = (Fts3Expr *)sqlite3Fts3MallocZero(sizeof(Fts3Expr));
         if( !pRet ){
           return SQLITE_NOMEM;
         }
@@ -174882,6 +179757,11 @@ static int getNextNode(
     if( *zInput=='(' ){
       int nConsumed = 0;
       pParse->nNest++;
+#if !defined(SQLITE_MAX_EXPR_DEPTH)
+      if( pParse->nNest>1000 ) return SQLITE_ERROR;
+#elif SQLITE_MAX_EXPR_DEPTH>0
+      if( pParse->nNest>SQLITE_MAX_EXPR_DEPTH ) return SQLITE_ERROR;
+#endif
       rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed);
       *pnConsumed = (int)(zInput - z) + 1 + nConsumed;
       return rc;
@@ -175021,7 +179901,7 @@ static int fts3ExprParse(
             && p->eType==FTSQUERY_PHRASE && pParse->isNot
         ){
           /* Create an implicit NOT operator. */
-          Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr));
+          Fts3Expr *pNot = sqlite3Fts3MallocZero(sizeof(Fts3Expr));
           if( !pNot ){
             sqlite3Fts3ExprFree(p);
             rc = SQLITE_NOMEM;
@@ -175055,7 +179935,7 @@ static int fts3ExprParse(
             /* Insert an implicit AND operator. */
             Fts3Expr *pAnd;
             assert( pRet && pPrev );
-            pAnd = fts3MallocZero(sizeof(Fts3Expr));
+            pAnd = sqlite3Fts3MallocZero(sizeof(Fts3Expr));
             if( !pAnd ){
               sqlite3Fts3ExprFree(p);
               rc = SQLITE_NOMEM;
@@ -179285,8 +184165,18 @@ static int fts3SegReaderNext(
         char *aCopy;
         PendingList *pList = (PendingList *)fts3HashData(pElem);
         int nCopy = pList->nData+1;
-        pReader->zTerm = (char *)fts3HashKey(pElem);
-        pReader->nTerm = fts3HashKeysize(pElem);
+
+        int nTerm = fts3HashKeysize(pElem);
+        if( (nTerm+1)>pReader->nTermAlloc ){
+          sqlite3_free(pReader->zTerm);
+          pReader->zTerm = (char*)sqlite3_malloc((nTerm+1)*2);
+          if( !pReader->zTerm ) return SQLITE_NOMEM;
+          pReader->nTermAlloc = (nTerm+1)*2;
+        }
+        memcpy(pReader->zTerm, fts3HashKey(pElem), nTerm);
+        pReader->zTerm[nTerm] = '\0';
+        pReader->nTerm = nTerm;
+
         aCopy = (char*)sqlite3_malloc(nCopy);
         if( !aCopy ) return SQLITE_NOMEM;
         memcpy(aCopy, pList->aData, nCopy);
@@ -179539,9 +184429,7 @@ SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(
 */
 SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){
   if( pReader ){
-    if( !fts3SegReaderIsPending(pReader) ){
-      sqlite3_free(pReader->zTerm);
-    }
+    sqlite3_free(pReader->zTerm);
     if( !fts3SegReaderIsRootOnly(pReader) ){
       sqlite3_free(pReader->aNode);
     }
@@ -179757,7 +184645,7 @@ static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
   if( rc==0 ){
     rc = pRhs->iIdx - pLhs->iIdx;
   }
-  assert( rc!=0 );
+  assert_fts3_nc( rc!=0 );
   return rc;
 }
 
@@ -179953,8 +184841,8 @@ static int fts3PrefixCompress(
   int nNext                       /* Size of buffer zNext in bytes */
 ){
   int n;
-  UNUSED_PARAMETER(nNext);
-  for(n=0; n<nPrev && zPrev[n]==zNext[n]; n++);
+  for(n=0; n<nPrev && n<nNext && zPrev[n]==zNext[n]; n++);
+  assert_fts3_nc( n<nNext );
   return n;
 }
 
@@ -180953,7 +185841,7 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(
 
           nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
 
-          rc = fts3GrowSegReaderBuffer(pCsr, nByte+nDoclist);
+          rc = fts3GrowSegReaderBuffer(pCsr, nByte+nDoclist+FTS3_NODE_PADDING);
           if( rc ) return rc;
 
           if( isFirst ){
@@ -181733,7 +186621,7 @@ static int nodeReaderNext(NodeReader *p){
       return FTS_CORRUPT_VTAB;
     }
     blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc);
-    if( rc==SQLITE_OK ){
+    if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){
       memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix);
       p->term.n = nPrefix+nSuffix;
       p->iOff += nSuffix;
@@ -182127,7 +187015,11 @@ static int fts3TermCmp(
   int nCmp = MIN(nLhs, nRhs);
   int res;
 
-  res = (nCmp ? memcmp(zLhs, zRhs, nCmp) : 0);
+  if( nCmp && ALWAYS(zLhs) && ALWAYS(zRhs) ){
+    res = memcmp(zLhs, zRhs, nCmp);
+  }else{
+    res = 0;
+  }
   if( res==0 ) res = nLhs - nRhs;
 
   return res;
@@ -182285,17 +187177,20 @@ static int fts3IncrmergeLoad(
           while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
           blobGrowBuffer(&pNode->key, reader.term.n, &rc);
           if( rc==SQLITE_OK ){
-            memcpy(pNode->key.a, reader.term.a, reader.term.n);
+            assert_fts3_nc( reader.term.n>0 || reader.aNode==0 );
+            if( reader.term.n>0 ){
+              memcpy(pNode->key.a, reader.term.a, reader.term.n);
+            }
             pNode->key.n = reader.term.n;
             if( i>0 ){
               char *aBlock = 0;
               int nBlock = 0;
               pNode = &pWriter->aNodeWriter[i-1];
               pNode->iBlock = reader.iChild;
-              rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock, 0);
+              rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock,0);
               blobGrowBuffer(&pNode->block,
                   MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc
-              );
+                  );
               if( rc==SQLITE_OK ){
                 memcpy(pNode->block.a, aBlock, nBlock);
                 pNode->block.n = nBlock;
@@ -182768,7 +187663,7 @@ static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){
       if( aHint ){
         blobGrowBuffer(pHint, nHint, &rc);
         if( rc==SQLITE_OK ){
-          memcpy(pHint->a, aHint, nHint);
+          if( ALWAYS(pHint->a!=0) ) memcpy(pHint->a, aHint, nHint);
           pHint->n = nHint;
         }
       }
@@ -183764,6 +188659,10 @@ SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){
 /* #include <string.h> */
 /* #include <assert.h> */
 
+#ifndef SQLITE_AMALGAMATION
+typedef sqlite3_int64 i64;
+#endif
+
 /*
 ** Characters that may appear in the second argument to matchinfo().
 */
@@ -183814,9 +188713,9 @@ struct SnippetIter {
 struct SnippetPhrase {
   int nToken;                     /* Number of tokens in phrase */
   char *pList;                    /* Pointer to start of phrase position list */
-  int iHead;                      /* Next value in position list */
+  i64 iHead;                      /* Next value in position list */
   char *pHead;                    /* Position list data following iHead */
-  int iTail;                      /* Next value in trailing position list */
+  i64 iTail;                      /* Next value in trailing position list */
   char *pTail;                    /* Position list data following iTail */
 };
 
@@ -183881,9 +188780,8 @@ static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){
                            + sizeof(MatchinfoBuffer);
   sqlite3_int64 nStr = strlen(zMatchinfo);
 
-  pRet = sqlite3_malloc64(nByte + nStr+1);
+  pRet = sqlite3Fts3MallocZero(nByte + nStr+1);
   if( pRet ){
-    memset(pRet, 0, nByte);
     pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet;
     pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0]
                                       + sizeof(u32)*((int)nElem+1);
@@ -183981,7 +188879,7 @@ SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p){
 ** After it returns, *piPos contains the value of the next element of the
 ** list and *pp is advanced to the following varint.
 */
-static void fts3GetDeltaPosition(char **pp, int *piPos){
+static void fts3GetDeltaPosition(char **pp, i64 *piPos){
   int iVal;
   *pp += fts3GetVarint32(*pp, &iVal);
   *piPos += (iVal-2);
@@ -184090,10 +188988,10 @@ static int fts3ExprPhraseCount(Fts3Expr *pExpr){
 ** arguments so that it points to the first element with a value greater
 ** than or equal to parameter iNext.
 */
-static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){
+static void fts3SnippetAdvance(char **ppIter, i64 *piIter, int iNext){
   char *pIter = *ppIter;
   if( pIter ){
-    int iIter = *piIter;
+    i64 iIter = *piIter;
 
     while( iIter<iNext ){
       if( 0==(*pIter & 0xFE) ){
@@ -184176,7 +189074,7 @@ static void fts3SnippetDetails(
     SnippetPhrase *pPhrase = &pIter->aPhrase[i];
     if( pPhrase->pTail ){
       char *pCsr = pPhrase->pTail;
-      int iCsr = pPhrase->iTail;
+      i64 iCsr = pPhrase->iTail;
 
       while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
         int j;
@@ -184222,7 +189120,7 @@ static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
   rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
   assert( rc==SQLITE_OK || pCsr==0 );
   if( pCsr ){
-    int iFirst = 0;
+    i64 iFirst = 0;
     pPhrase->pList = pCsr;
     fts3GetDeltaPosition(&pCsr, &iFirst);
     if( iFirst<0 ){
@@ -184287,11 +189185,10 @@ static int fts3BestSnippet(
   ** the required space using malloc().
   */
   nByte = sizeof(SnippetPhrase) * nList;
-  sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc64(nByte);
+  sIter.aPhrase = (SnippetPhrase *)sqlite3Fts3MallocZero(nByte);
   if( !sIter.aPhrase ){
     return SQLITE_NOMEM;
   }
-  memset(sIter.aPhrase, 0, nByte);
 
   /* Initialize the contents of the SnippetIter object. Then iterate through
   ** the set of phrases in the expression to populate the aPhrase[] array.
@@ -184855,10 +189752,12 @@ static int fts3MatchinfoLcsCb(
 ** position list for the next column.
 */
 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
-  char *pRead = pIter->pRead;
+  char *pRead;
   sqlite3_int64 iRead;
   int rc = 0;
 
+  if( NEVER(pIter==0) ) return 1;
+  pRead = pIter->pRead;
   pRead += sqlite3Fts3GetVarint(pRead, &iRead);
   if( iRead==0 || iRead==1 ){
     pRead = 0;
@@ -184892,9 +189791,8 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
   /* Allocate and populate the array of LcsIterator objects. The array
   ** contains one element for each matchable phrase in the query.
   **/
-  aIter = sqlite3_malloc64(sizeof(LcsIterator) * pCsr->nPhrase);
+  aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase);
   if( !aIter ) return SQLITE_NOMEM;
-  memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase);
   (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
 
   for(i=0; i<pInfo->nPhrase; i++){
@@ -185286,8 +190184,8 @@ typedef struct TermOffsetCtx TermOffsetCtx;
 
 struct TermOffset {
   char *pList;                    /* Position-list */
-  int iPos;                       /* Position just read from pList */
-  int iOff;                       /* Offset of this term from read positions */
+  i64 iPos;                       /* Position just read from pList */
+  i64 iOff;                       /* Offset of this term from read positions */
 };
 
 struct TermOffsetCtx {
@@ -185306,7 +190204,7 @@ static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
   int nTerm;                      /* Number of tokens in phrase */
   int iTerm;                      /* For looping through nTerm phrase terms */
   char *pList;                    /* Pointer to position list for phrase */
-  int iPos = 0;                   /* First position in position-list */
+  i64 iPos = 0;                   /* First position in position-list */
   int rc;
 
   UNUSED_PARAMETER(iPhrase);
@@ -185355,7 +190253,7 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets(
   if( rc!=SQLITE_OK ) goto offsets_out;
 
   /* Allocate the array of TermOffset iterators. */
-  sCtx.aTerm = (TermOffset *)sqlite3_malloc64(sizeof(TermOffset)*nToken);
+  sCtx.aTerm = (TermOffset *)sqlite3Fts3MallocZero(sizeof(TermOffset)*nToken);
   if( 0==sCtx.aTerm ){
     rc = SQLITE_NOMEM;
     goto offsets_out;
@@ -185376,13 +190274,13 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets(
     const char *zDoc;
     int nDoc;
 
-    /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
-    ** no way that this operation can fail, so the return code from
-    ** fts3ExprIterate() can be discarded.
+    /* Initialize the contents of sCtx.aTerm[] for column iCol. This
+    ** operation may fail if the database contains corrupt records.
     */
     sCtx.iCol = iCol;
     sCtx.iTerm = 0;
-    (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
+    rc = fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);
+    if( rc!=SQLITE_OK ) goto offsets_out;
 
     /* Retreive the text stored in column iCol. If an SQL NULL is stored
     ** in column iCol, jump immediately to the next iteration of the loop.
@@ -185783,6 +190681,7 @@ static int unicodeOpen(
   pCsr->aInput = (const unsigned char *)aInput;
   if( aInput==0 ){
     pCsr->nInput = 0;
+    pCsr->aInput = (const unsigned char*)"";
   }else if( nInput<0 ){
     pCsr->nInput = (int)strlen(aInput);
   }else{
@@ -186379,7 +191278,34 @@ static const char jsonIsSpace[] = {
   typedef unsigned int u32;
   typedef unsigned short int u16;
   typedef unsigned char u8;
+# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+#   define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
+# endif
+# if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
+#   define ALWAYS(X)      (1)
+#   define NEVER(X)       (0)
+# elif !defined(NDEBUG)
+#   define ALWAYS(X)      ((X)?1:(assert(0),0))
+#   define NEVER(X)       ((X)?(assert(0),1):0)
+# else
+#   define ALWAYS(X)      (X)
+#   define NEVER(X)       (X)
+# endif
+# define testcase(X)
 #endif
+#if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST)
+#  define VVA(X)
+#else
+#  define VVA(X) X
+#endif
+
+/*
+** Some of the testcase() macros in this file are problematic for gcov
+** in that they generate false-miss errors randomly.  This is a gcov problem,
+** not a problem in this case.  But to work around it, we disable the
+** problematic test cases for production builds.
+*/
+#define json_testcase(X)
 
 /* Objects */
 typedef struct JsonString JsonString;
@@ -186437,13 +191363,14 @@ static const char * const jsonType[] = {
 struct JsonNode {
   u8 eType;              /* One of the JSON_ type values */
   u8 jnFlags;            /* JNODE flags */
+  u8 eU;                 /* Which union element to use */
   u32 n;                 /* Bytes of content, or number of sub-nodes */
   union {
-    const char *zJContent; /* Content for INT, REAL, and STRING */
-    u32 iAppend;           /* More terms for ARRAY and OBJECT */
-    u32 iKey;              /* Key for ARRAY objects in json_tree() */
-    u32 iReplace;          /* Replacement content for JNODE_REPLACE */
-    JsonNode *pPatch;      /* Node chain of patch for JNODE_PATCH */
+    const char *zJContent; /* 1: Content for INT, REAL, and STRING */
+    u32 iAppend;           /* 2: More terms for ARRAY and OBJECT */
+    u32 iKey;              /* 3: Key for ARRAY objects in json_tree() */
+    u32 iReplace;          /* 4: Replacement content for JNODE_REPLACE */
+    JsonNode *pPatch;      /* 5: Node chain of patch for JNODE_PATCH */
   } u;
 };
 
@@ -186582,7 +191509,7 @@ static void jsonAppendSeparator(JsonString *p){
 */
 static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
   u32 i;
-  if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return;
+  if( zIn==0 || ((N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0) ) return;
   p->zBuf[p->nUsed++] = '"';
   for(i=0; i<N; i++){
     unsigned char c = ((unsigned const char*)zIn)[i];
@@ -186721,11 +191648,14 @@ static void jsonRenderNode(
   JsonString *pOut,              /* Write JSON here */
   sqlite3_value **aReplace       /* Replacement values */
 ){
+  assert( pNode!=0 );
   if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){
-    if( pNode->jnFlags & JNODE_REPLACE ){
+    if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){
+      assert( pNode->eU==4 );
       jsonAppendValue(pOut, aReplace[pNode->u.iReplace]);
       return;
     }
+    assert( pNode->eU==5 );
     pNode = pNode->u.pPatch;
   }
   switch( pNode->eType ){
@@ -186744,6 +191674,7 @@ static void jsonRenderNode(
     }
     case JSON_STRING: {
       if( pNode->jnFlags & JNODE_RAW ){
+        assert( pNode->eU==1 );
         jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
         break;
       }
@@ -186751,6 +191682,7 @@ static void jsonRenderNode(
     }
     case JSON_REAL:
     case JSON_INT: {
+      assert( pNode->eU==1 );
       jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
       break;
     }
@@ -186766,6 +191698,7 @@ static void jsonRenderNode(
           j += jsonNodeSize(&pNode[j]);
         }
         if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
+        assert( pNode->eU==2 );
         pNode = &pNode[pNode->u.iAppend];
         j = 1;
       }
@@ -186786,6 +191719,7 @@ static void jsonRenderNode(
           j += 1 + jsonNodeSize(&pNode[j+1]);
         }
         if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
+        assert( pNode->eU==2 );
         pNode = &pNode[pNode->u.iAppend];
         j = 1;
       }
@@ -186865,7 +191799,9 @@ static void jsonReturn(
     }
     case JSON_INT: {
       sqlite3_int64 i = 0;
-      const char *z = pNode->u.zJContent;
+      const char *z;
+      assert( pNode->eU==1 );
+      z = pNode->u.zJContent;
       if( z[0]=='-' ){ z++; }
       while( z[0]>='0' && z[0]<='9' ){
         unsigned v = *(z++) - '0';
@@ -186888,14 +191824,17 @@ static void jsonReturn(
       sqlite3_result_int64(pCtx, i);
       int_done:
       break;
-      int_as_real: i=0; /* no break */ deliberate_fall_through
+      int_as_real: ; /* no break */ deliberate_fall_through
     }
     case JSON_REAL: {
       double r;
 #ifdef SQLITE_AMALGAMATION
-      const char *z = pNode->u.zJContent;
+      const char *z;
+      assert( pNode->eU==1 );
+      z = pNode->u.zJContent;
       sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8);
 #else
+      assert( pNode->eU==1 );
       r = strtod(pNode->u.zJContent, 0);
 #endif
       sqlite3_result_double(pCtx, r);
@@ -186906,6 +191845,7 @@ static void jsonReturn(
       ** json_insert() and json_replace() and those routines do not
       ** call jsonReturn() */
       if( pNode->jnFlags & JNODE_RAW ){
+        assert( pNode->eU==1 );
         sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
                             SQLITE_TRANSIENT);
       }else
@@ -186913,15 +191853,18 @@ static void jsonReturn(
       assert( (pNode->jnFlags & JNODE_RAW)==0 );
       if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){
         /* JSON formatted without any backslash-escapes */
+        assert( pNode->eU==1 );
         sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
                             SQLITE_TRANSIENT);
       }else{
         /* Translate JSON formatted string into raw text */
         u32 i;
         u32 n = pNode->n;
-        const char *z = pNode->u.zJContent;
+        const char *z;
         char *zOut;
         u32 j;
+        assert( pNode->eU==1 );
+        z = pNode->u.zJContent;
         zOut = sqlite3_malloc( n+1 );
         if( zOut==0 ){
           sqlite3_result_error_nomem(pCtx);
@@ -187042,12 +191985,13 @@ static int jsonParseAddNode(
   const char *zContent      /* Content */
 ){
   JsonNode *p;
-  if( pParse->nNode>=pParse->nAlloc ){
+  if( pParse->aNode==0 || pParse->nNode>=pParse->nAlloc ){
     return jsonParseAddNodeExpand(pParse, eType, n, zContent);
   }
   p = &pParse->aNode[pParse->nNode];
   p->eType = (u8)eType;
   p->jnFlags = 0;
+  VVA( p->eU = zContent ? 1 : 0 );
   p->n = n;
   p->u.zJContent = zContent;
   return pParse->nNode++;
@@ -187115,6 +192059,7 @@ static int jsonParseValue(JsonParse *pParse, u32 i){
     /* Parse array */
     iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
     if( iThis<0 ) return -1;
+    memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u));
     for(j=i+1;;j++){
       while( safe_isspace(z[j]) ){ j++; }
       if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1;
@@ -187379,6 +192324,7 @@ static JsonParse *jsonParseCached(
 ** a match.
 */
 static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){
+  assert( pNode->eU==1 );
   if( pNode->jnFlags & JNODE_RAW ){
     if( pNode->n!=nKey ) return 0;
     return strncmp(pNode->u.zJContent, zKey, nKey)==0;
@@ -187444,6 +192390,7 @@ static JsonNode *jsonLookupStep(
         j += jsonNodeSize(&pRoot[j]);
       }
       if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
+      assert( pRoot->eU==2 );
       iRoot += pRoot->u.iAppend;
       pRoot = &pParse->aNode[iRoot];
       j = 1;
@@ -187458,8 +192405,10 @@ static JsonNode *jsonLookupStep(
       if( pParse->oom ) return 0;
       if( pNode ){
         pRoot = &pParse->aNode[iRoot];
+        assert( pRoot->eU==0 );
         pRoot->u.iAppend = iStart - iRoot;
         pRoot->jnFlags |= JNODE_APPEND;
+        VVA( pRoot->eU = 2 );
         pParse->aNode[iLabel].jnFlags |= JNODE_RAW;
       }
       return pNode;
@@ -187482,6 +192431,7 @@ static JsonNode *jsonLookupStep(
             j += jsonNodeSize(&pBase[j]);
           }
           if( (pBase->jnFlags & JNODE_APPEND)==0 ) break;
+          assert( pBase->eU==2 );
           iBase += pBase->u.iAppend;
           pBase = &pParse->aNode[iBase];
           j = 1;
@@ -187515,6 +192465,7 @@ static JsonNode *jsonLookupStep(
         j += jsonNodeSize(&pRoot[j]);
       }
       if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
+      assert( pRoot->eU==2 );
       iRoot += pRoot->u.iAppend;
       pRoot = &pParse->aNode[iRoot];
       j = 1;
@@ -187530,8 +192481,10 @@ static JsonNode *jsonLookupStep(
       if( pParse->oom ) return 0;
       if( pNode ){
         pRoot = &pParse->aNode[iRoot];
+        assert( pRoot->eU==0 );
         pRoot->u.iAppend = iStart - iRoot;
         pRoot->jnFlags |= JNODE_APPEND;
+        VVA( pRoot->eU = 2 );
       }
       return pNode;
     }
@@ -187685,9 +192638,13 @@ static void jsonParseFunc(
     }
     jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d",
                i, zType, x.aNode[i].n, x.aUp[i]);
+    assert( x.aNode[i].eU==0 || x.aNode[i].eU==1 );
     if( x.aNode[i].u.zJContent!=0 ){
+      assert( x.aNode[i].eU==1 );
       jsonAppendRaw(&s, " ", 1);
       jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n);
+    }else{
+      assert( x.aNode[i].eU==0 );
     }
     jsonAppendRaw(&s, "\n", 1);
   }
@@ -187870,6 +192827,7 @@ static JsonNode *jsonMergePatch(
     const char *zKey;
     assert( pPatch[i].eType==JSON_STRING );
     assert( pPatch[i].jnFlags & JNODE_LABEL );
+    assert( pPatch[i].eU==1 );
     nKey = pPatch[i].n;
     zKey = pPatch[i].u.zJContent;
     assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
@@ -187886,6 +192844,12 @@ static JsonNode *jsonMergePatch(
           if( pNew==0 ) return 0;
           pTarget = &pParse->aNode[iTarget];
           if( pNew!=&pTarget[j+1] ){
+            assert( pTarget[j+1].eU==0
+                 || pTarget[j+1].eU==1
+                 || pTarget[j+1].eU==2 );
+            testcase( pTarget[j+1].eU==1 );
+            testcase( pTarget[j+1].eU==2 );
+            VVA( pTarget[j+1].eU = 5 );
             pTarget[j+1].u.pPatch = pNew;
             pTarget[j+1].jnFlags |= JNODE_PATCH;
           }
@@ -187901,9 +192865,14 @@ static JsonNode *jsonMergePatch(
       if( pParse->oom ) return 0;
       jsonRemoveAllNulls(pPatch);
       pTarget = &pParse->aNode[iTarget];
+      assert( pParse->aNode[iRoot].eU==0 || pParse->aNode[iRoot].eU==2 );
+      testcase( pParse->aNode[iRoot].eU==2 );
       pParse->aNode[iRoot].jnFlags |= JNODE_APPEND;
+      VVA( pParse->aNode[iRoot].eU = 2 );
       pParse->aNode[iRoot].u.iAppend = iStart - iRoot;
       iRoot = iStart;
+      assert( pParse->aNode[iPatch].eU==0 );
+      VVA( pParse->aNode[iPatch].eU = 5 );
       pParse->aNode[iPatch].jnFlags |= JNODE_PATCH;
       pParse->aNode[iPatch].u.pPatch = &pPatch[i+1];
     }
@@ -188045,11 +193014,15 @@ static void jsonReplaceFunc(
     pNode = jsonLookup(&x, zPath, 0, ctx);
     if( x.nErr ) goto replace_err;
     if( pNode ){
+      assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 );
+      json_testcase( pNode->eU!=0 && pNode->eU!=1 );
       pNode->jnFlags |= (u8)JNODE_REPLACE;
+      VVA( pNode->eU =  4 );
       pNode->u.iReplace = i + 1;
     }
   }
   if( x.aNode[0].jnFlags & JNODE_REPLACE ){
+    assert( x.aNode[0].eU==4 );
     sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
   }else{
     jsonReturnJson(x.aNode, ctx, argv);
@@ -188099,11 +193072,15 @@ static void jsonSetFunc(
     }else if( x.nErr ){
       goto jsonSetDone;
     }else if( pNode && (bApnd || bIsSet) ){
+      json_testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 );
+      assert( pNode->eU!=3 || pNode->eU!=5 );
+      VVA( pNode->eU = 4 );
       pNode->jnFlags |= (u8)JNODE_REPLACE;
       pNode->u.iReplace = i + 1;
     }
   }
   if( x.aNode[0].jnFlags & JNODE_REPLACE ){
+    assert( x.aNode[0].eU==4 );
     sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
   }else{
     jsonReturnJson(x.aNode, ctx, argv);
@@ -188181,8 +193158,8 @@ static void jsonArrayStep(
       jsonAppendChar(pStr, '[');
     }else if( pStr->nUsed>1 ){
       jsonAppendChar(pStr, ',');
-      pStr->pCtx = ctx;
     }
+    pStr->pCtx = ctx;
     jsonAppendValue(pStr, argv[0]);
   }
 }
@@ -188242,11 +193219,7 @@ static void jsonGroupInverse(
   if( NEVER(!pStr) ) return;
 #endif
   z = pStr->zBuf;
-  for(i=1; (c = z[i])!=',' || inStr || nNest; i++){
-    if( i>=pStr->nUsed ){
-      pStr->nUsed = 1;
-      return;
-    }
+  for(i=1; i<pStr->nUsed && ((c = z[i])!=',' || inStr || nNest); i++){
     if( c=='"' ){
       inStr = !inStr;
     }else if( c=='\\' ){
@@ -188256,8 +193229,13 @@ static void jsonGroupInverse(
       if( c=='}' || c==']' ) nNest--;
     }
   }
-  pStr->nUsed -= i;
-  memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1);
+  if( i<pStr->nUsed ){
+    pStr->nUsed -= i;
+    memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1);
+    z[pStr->nUsed] = 0;
+  }else{
+    pStr->nUsed = 1;
+  }
 }
 #else
 # define jsonGroupInverse 0
@@ -188285,8 +193263,8 @@ static void jsonObjectStep(
       jsonAppendChar(pStr, '{');
     }else if( pStr->nUsed>1 ){
       jsonAppendChar(pStr, ',');
-      pStr->pCtx = ctx;
     }
+    pStr->pCtx = ctx;
     z = (const char*)sqlite3_value_text(argv[0]);
     n = (u32)sqlite3_value_bytes(argv[0]);
     jsonAppendString(pStr, z, n);
@@ -188453,6 +193431,9 @@ static int jsonEachNext(sqlite3_vtab_cursor *cur){
       JsonNode *pUp = &p->sParse.aNode[iUp];
       p->eType = pUp->eType;
       if( pUp->eType==JSON_ARRAY ){
+        assert( pUp->eU==0 || pUp->eU==3 );
+        json_testcase( pUp->eU==3 );
+        VVA( pUp->eU = 3 );
         if( iUp==p->i-1 ){
           pUp->u.iKey = 0;
         }else{
@@ -188499,12 +193480,15 @@ static void jsonEachComputePath(
   pNode = &p->sParse.aNode[i];
   pUp = &p->sParse.aNode[iUp];
   if( pUp->eType==JSON_ARRAY ){
+    assert( pUp->eU==3 || (pUp->eU==0 && pUp->u.iKey==0) );
+    testcase( pUp->eU==0 );
     jsonPrintf(30, pStr, "[%d]", pUp->u.iKey);
   }else{
     assert( pUp->eType==JSON_OBJECT );
     if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--;
     assert( pNode->eType==JSON_STRING );
     assert( pNode->jnFlags & JNODE_LABEL );
+    assert( pNode->eU==1 );
     jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1);
   }
 }
@@ -188526,6 +193510,7 @@ static int jsonEachColumn(
         u32 iKey;
         if( p->bRecursive ){
           if( p->iRowid==0 ) break;
+          assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 );
           iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey;
         }else{
           iKey = p->iRowid;
@@ -188575,6 +193560,7 @@ static int jsonEachColumn(
         if( p->eType==JSON_ARRAY ){
           jsonPrintf(30, &x, "[%d]", p->iRowid);
         }else if( p->eType==JSON_OBJECT ){
+          assert( pThis->eU==1 );
           jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1);
         }
       }
@@ -188642,6 +193628,7 @@ static int jsonEachBestIndex(
     if( pConstraint->iColumn < JEACH_JSON ) continue;
     iCol = pConstraint->iColumn - JEACH_JSON;
     assert( iCol==0 || iCol==1 );
+    testcase( iCol==0 );
     iMask = 1 << iCol;
     if( pConstraint->usable==0 ){
       unusableMask |= iMask;
@@ -188739,6 +193726,8 @@ static int jsonEachFilter(
     p->iBegin = p->i = (int)(pNode - p->sParse.aNode);
     p->eType = pNode->eType;
     if( p->eType>=JSON_ARRAY ){
+      assert( pNode->eU==0 );
+      VVA( pNode->eU = 3 );
       pNode->u.iKey = 0;
       p->iEnd = p->i + pNode->n + 1;
       if( p->bRecursive ){
@@ -188981,7 +193970,11 @@ SQLITE_API int sqlite3_json_init(
 #endif
 SQLITE_PRIVATE int sqlite3GetToken(const unsigned char*,int*); /* In the SQLite core */
 
-#ifndef SQLITE_AMALGAMATION
+/*
+** If building separately, we will need some setup that is normally
+** found in sqliteInt.h
+*/
+#if !defined(SQLITE_AMALGAMATION)
 #include "sqlite3rtree.h"
 typedef sqlite3_int64 i64;
 typedef sqlite3_uint64 u64;
@@ -188994,7 +193987,20 @@ typedef unsigned int u32;
 #if defined(NDEBUG) && defined(SQLITE_DEBUG)
 # undef NDEBUG
 #endif
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
 #endif
+#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
+# define ALWAYS(X)      (1)
+# define NEVER(X)       (0)
+#elif !defined(NDEBUG)
+# define ALWAYS(X)      ((X)?1:(assert(0),0))
+# define NEVER(X)       ((X)?(assert(0),1):0)
+#else
+# define ALWAYS(X)      (X)
+# define NEVER(X)       (X)
+#endif
+#endif /* !defined(SQLITE_AMALGAMATION) */
 
 /* #include <string.h> */
 /* #include <stdio.h> */
@@ -189052,7 +194058,9 @@ struct Rtree {
   u8 nBytesPerCell;           /* Bytes consumed per cell */
   u8 inWrTrans;               /* True if inside write transaction */
   u8 nAux;                    /* # of auxiliary columns in %_rowid */
+#ifdef SQLITE_ENABLE_GEOPOLY
   u8 nAuxNotNull;             /* Number of initial not-null aux columns */
+#endif
 #ifdef SQLITE_DEBUG
   u8 bCorrupt;                /* Shadow table corruption detected */
 #endif
@@ -189334,7 +194342,12 @@ struct RtreeMatchArg {
 ** it is not, make it a no-op.
 */
 #ifndef SQLITE_AMALGAMATION
-# define testcase(X)
+# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG)
+    unsigned int sqlite3RtreeTestcase = 0;
+#   define testcase(X)  if( X ){ sqlite3RtreeTestcase += __LINE__; }
+# else
+#   define testcase(X)
+# endif
 #endif
 
 /*
@@ -189583,18 +194596,6 @@ static void nodeBlobReset(Rtree *pRtree){
   }
 }
 
-/*
-** Check to see if pNode is the same as pParent or any of the parents
-** of pParent.
-*/
-static int nodeInParentChain(const RtreeNode *pNode, const RtreeNode *pParent){
-  do{
-    if( pNode==pParent ) return 1;
-    pParent = pParent->pParent;
-  }while( pParent );
-  return 0;
-}
-
 /*
 ** Obtain a reference to an r-tree node.
 */
@@ -189611,14 +194612,7 @@ static int nodeAcquire(
   ** increase its reference count and return it.
   */
   if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){
-    if( pParent && !pNode->pParent ){
-      if( nodeInParentChain(pNode, pParent) ){
-        RTREE_IS_CORRUPT(pRtree);
-        return SQLITE_CORRUPT_VTAB;
-      }
-      pParent->nRef++;
-      pNode->pParent = pParent;
-    }else if( pParent && pNode->pParent && pParent!=pNode->pParent ){
+    if( pParent && pParent!=pNode->pParent ){
       RTREE_IS_CORRUPT(pRtree);
       return SQLITE_CORRUPT_VTAB;
     }
@@ -189676,7 +194670,7 @@ static int nodeAcquire(
   ** are the leaves, and so on. If the depth as specified on the root node
   ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
   */
-  if( pNode && rc==SQLITE_OK && iNode==1 ){
+  if( rc==SQLITE_OK && pNode && iNode==1 ){
     pRtree->iDepth = readInt16(pNode->zData);
     if( pRtree->iDepth>RTREE_MAX_DEPTH ){
       rc = SQLITE_CORRUPT_VTAB;
@@ -190199,20 +195193,29 @@ static void rtreeNonleafConstraint(
   switch( p->op ){
     case RTREE_TRUE:  return;   /* Always satisfied */
     case RTREE_FALSE: break;    /* Never satisfied */
+    case RTREE_EQ:
+      RTREE_DECODE_COORD(eInt, pCellData, val);
+      /* val now holds the lower bound of the coordinate pair */
+      if( p->u.rValue>=val ){
+        pCellData += 4;
+        RTREE_DECODE_COORD(eInt, pCellData, val);
+        /* val now holds the upper bound of the coordinate pair */
+        if( p->u.rValue<=val ) return;
+      }
+      break;
     case RTREE_LE:
     case RTREE_LT:
-    case RTREE_EQ:
       RTREE_DECODE_COORD(eInt, pCellData, val);
       /* val now holds the lower bound of the coordinate pair */
       if( p->u.rValue>=val ) return;
-      if( p->op!=RTREE_EQ ) break;  /* RTREE_LE and RTREE_LT end here */
-      /* Fall through for the RTREE_EQ case */
+      break;
 
-    default: /* RTREE_GT or RTREE_GE,  or fallthrough of RTREE_EQ */
+    default:
       pCellData += 4;
       RTREE_DECODE_COORD(eInt, pCellData, val);
       /* val now holds the upper bound of the coordinate pair */
       if( p->u.rValue<=val ) return;
+      break;
   }
   *peWithin = NOT_WITHIN;
 }
@@ -190282,11 +195285,12 @@ static int nodeRowidIndex(
 */
 static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
   RtreeNode *pParent = pNode->pParent;
-  if( pParent ){
+  if( ALWAYS(pParent) ){
     return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex);
+  }else{
+    *piIndex = -1;
+    return SQLITE_OK;
   }
-  *piIndex = -1;
-  return SQLITE_OK;
 }
 
 /*
@@ -190409,7 +195413,8 @@ static RtreeSearchPoint *rtreeSearchPointNew(
       pNew = rtreeEnqueue(pCur, rScore, iLevel);
       if( pNew==0 ) return 0;
       ii = (int)(pNew - pCur->aPoint) + 1;
-      if( ii<RTREE_CACHE_SZ ){
+      assert( ii==1 );
+      if( ALWAYS(ii<RTREE_CACHE_SZ) ){
         assert( pCur->aNode[ii]==0 );
         pCur->aNode[ii] = pCur->aNode[0];
       }else{
@@ -190470,7 +195475,7 @@ static void rtreeSearchPointPop(RtreeCursor *p){
   if( p->bPoint ){
     p->anQueue[p->sPoint.iLevel]--;
     p->bPoint = 0;
-  }else if( p->nPoint ){
+  }else if( ALWAYS(p->nPoint) ){
     p->anQueue[p->aPoint[0].iLevel]--;
     n = --p->nPoint;
     p->aPoint[0] = p->aPoint[n];
@@ -190611,7 +195616,7 @@ static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){
   RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
   int rc = SQLITE_OK;
   RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
-  if( rc==SQLITE_OK && p ){
+  if( rc==SQLITE_OK && ALWAYS(p) ){
     *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
   }
   return rc;
@@ -190629,7 +195634,7 @@ static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
   RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
 
   if( rc ) return rc;
-  if( p==0 ) return SQLITE_OK;
+  if( NEVER(p==0) ) return SQLITE_OK;
   if( i==0 ){
     sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
   }else if( i<=pRtree->nDim2 ){
@@ -190828,8 +195833,11 @@ static int rtreeFilter(
     }
     if( rc==SQLITE_OK ){
       RtreeSearchPoint *pNew;
+      assert( pCsr->bPoint==0 );  /* Due to the resetCursor() call above */
       pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
-      if( pNew==0 ) return SQLITE_NOMEM;
+      if( NEVER(pNew==0) ){       /* Because pCsr->bPoint was FALSE */
+        return SQLITE_NOMEM;
+      }
       pNew->id = 1;
       pNew->iCell = 0;
       pNew->eWithin = PARTLY_WITHIN;
@@ -190906,7 +195914,7 @@ static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
     struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii];
 
     if( bMatch==0 && p->usable
-     && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ
+     && p->iColumn<=0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ
     ){
       /* We have an equality constraint on the rowid. Use strategy 1. */
       int jj;
@@ -191112,7 +196120,7 @@ static int ChooseLeaf(
 
     int nCell = NCELL(pNode);
     RtreeCell cell;
-    RtreeNode *pChild;
+    RtreeNode *pChild = 0;
 
     RtreeCell *aCell = 0;
 
@@ -191159,12 +196167,19 @@ static int AdjustTree(
 ){
   RtreeNode *p = pNode;
   int cnt = 0;
+  int rc;
   while( p->pParent ){
     RtreeNode *pParent = p->pParent;
     RtreeCell cell;
     int iCell;
 
-    if( (++cnt)>1000 || nodeParentIndex(pRtree, p, &iCell)  ){
+    cnt++;
+    if( NEVER(cnt>100) ){
+      RTREE_IS_CORRUPT(pRtree);
+      return SQLITE_CORRUPT_VTAB;
+    }
+    rc = nodeParentIndex(pRtree, p, &iCell);
+    if( NEVER(rc!=SQLITE_OK) ){
       RTREE_IS_CORRUPT(pRtree);
       return SQLITE_CORRUPT_VTAB;
     }
@@ -191453,12 +196468,17 @@ static int updateMapping(
   xSetMapping = ((iHeight==0)?rowidWrite:parentWrite);
   if( iHeight>0 ){
     RtreeNode *pChild = nodeHashLookup(pRtree, iRowid);
+    RtreeNode *p;
+    for(p=pNode; p; p=p->pParent){
+      if( p==pChild ) return SQLITE_CORRUPT_VTAB;
+    }
     if( pChild ){
       nodeRelease(pRtree, pChild->pParent);
       nodeReference(pNode);
       pChild->pParent = pNode;
     }
   }
+  if( NEVER(pNode==0) ) return SQLITE_ERROR;
   return xSetMapping(pRtree, iRowid, pNode->iNode);
 }
 
@@ -191548,11 +196568,12 @@ static int SplitNode(
     RtreeNode *pParent = pLeft->pParent;
     int iCell;
     rc = nodeParentIndex(pRtree, pLeft, &iCell);
-    if( rc==SQLITE_OK ){
+    if( ALWAYS(rc==SQLITE_OK) ){
       nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell);
       rc = AdjustTree(pRtree, pParent, &leftbbox);
+      assert( rc==SQLITE_OK );
     }
-    if( rc!=SQLITE_OK ){
+    if( NEVER(rc!=SQLITE_OK) ){
       goto splitnode_out;
     }
   }
@@ -191627,7 +196648,7 @@ static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){
       */
       iNode = sqlite3_column_int64(pRtree->pReadParent, 0);
       for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent);
-      if( !pTest ){
+      if( pTest==0 ){
         rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent);
       }
     }
@@ -191658,6 +196679,7 @@ static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){
     pParent = pNode->pParent;
     pNode->pParent = 0;
     rc = deleteCell(pRtree, pParent, iCell, iHeight+1);
+    testcase( rc!=SQLITE_OK );
   }
   rc2 = nodeRelease(pRtree, pParent);
   if( rc==SQLITE_OK ){
@@ -191880,7 +196902,7 @@ static int rtreeInsertCell(
     }
   }else{
     rc = AdjustTree(pRtree, pNode, pCell);
-    if( rc==SQLITE_OK ){
+    if( ALWAYS(rc==SQLITE_OK) ){
       if( iHeight==0 ){
         rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
       }else{
@@ -191986,7 +197008,7 @@ static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){
     int rc2;
     RtreeNode *pChild = 0;
     i64 iChild = nodeGetRowid(pRtree, pRoot, 0);
-    rc = nodeAcquire(pRtree, iChild, pRoot, &pChild);
+    rc = nodeAcquire(pRtree, iChild, pRoot, &pChild);  /* tag-20210916a */
     if( rc==SQLITE_OK ){
       rc = removeNode(pRtree, pChild, pRtree->iDepth-1);
     }
@@ -192321,7 +197343,7 @@ static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){
   char *zSql;
   sqlite3_stmt *p;
   int rc;
-  i64 nRow = 0;
+  i64 nRow = RTREE_MIN_ROWEST;
 
   rc = sqlite3_table_column_metadata(
       db, pRtree->zDb, "sqlite_stat1",0,0,0,0,0,0
@@ -192338,20 +197360,10 @@ static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){
     if( rc==SQLITE_OK ){
       if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0);
       rc = sqlite3_finalize(p);
-    }else if( rc!=SQLITE_NOMEM ){
-      rc = SQLITE_OK;
-    }
-
-    if( rc==SQLITE_OK ){
-      if( nRow==0 ){
-        pRtree->nRowEst = RTREE_DEFAULT_ROWEST;
-      }else{
-        pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST);
-      }
     }
     sqlite3_free(zSql);
   }
-
+  pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST);
   return rc;
 }
 
@@ -192501,9 +197513,12 @@ static int rtreeSqlInit(
       sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix);
       for(ii=0; ii<pRtree->nAux; ii++){
         if( ii ) sqlite3_str_append(p, ",", 1);
+#ifdef SQLITE_ENABLE_GEOPOLY
         if( ii<pRtree->nAuxNotNull ){
           sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii);
-        }else{
+        }else
+#endif
+        {
           sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2);
         }
       }
@@ -192768,6 +197783,7 @@ static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
   tree.nDim2 = tree.nDim*2;
   tree.nBytesPerCell = 8 + 8 * tree.nDim;
   node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
+  if( node.zData==0 ) return;
   nData = sqlite3_value_bytes(apArg[1]);
   if( nData<4 ) return;
   if( nData<NCELL(&node)*tree.nBytesPerCell ) return;
@@ -192807,11 +197823,16 @@ static void rtreedepth(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
   UNUSED_PARAMETER(nArg);
   if( sqlite3_value_type(apArg[0])!=SQLITE_BLOB
    || sqlite3_value_bytes(apArg[0])<2
+
   ){
     sqlite3_result_error(ctx, "Invalid argument to rtreedepth()", -1);
   }else{
     u8 *zBlob = (u8 *)sqlite3_value_blob(apArg[0]);
-    sqlite3_result_int(ctx, readInt16(zBlob));
+    if( zBlob ){
+      sqlite3_result_int(ctx, readInt16(zBlob));
+    }else{
+      sqlite3_result_error_nomem(ctx);
+    }
   }
 }
 
@@ -193177,8 +198198,10 @@ static int rtreeCheckTable(
     if( pStmt ){
       nAux = sqlite3_column_count(pStmt) - 2;
       sqlite3_finalize(pStmt);
+    }else
+    if( check.rc!=SQLITE_NOMEM ){
+      check.rc = SQLITE_OK;
     }
-    check.rc = SQLITE_OK;
   }
 
   /* Find number of dimensions in the rtree table. */
@@ -193592,11 +198615,16 @@ static GeoPoly *geopolyFuncParam(
 ){
   GeoPoly *p = 0;
   int nByte;
+  testcase( pCtx==0 );
   if( sqlite3_value_type(pVal)==SQLITE_BLOB
    && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord))
   ){
     const unsigned char *a = sqlite3_value_blob(pVal);
     int nVertex;
+    if( a==0 ){
+      if( pCtx ) sqlite3_result_error_nomem(pCtx);
+      return 0;
+    }
     nVertex = (a[1]<<16) + (a[2]<<8) + a[3];
     if( (a[0]==0 || a[0]==1)
      && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte
@@ -193970,7 +198998,7 @@ static GeoPoly *geopolyBBox(
       aCoord[2].f = mnY;
       aCoord[3].f = mxY;
     }
-  }else{
+  }else if( aCoord ){
     memset(aCoord, 0, sizeof(RtreeCoord)*4);
   }
   return pOut;
@@ -194421,11 +199449,11 @@ static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){
     }else{
       /* Remove a segment */
       if( pActive==pThisEvent->pSeg ){
-        pActive = pActive->pNext;
+        pActive = ALWAYS(pActive) ? pActive->pNext : 0;
       }else{
         for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
           if( pSeg->pNext==pThisEvent->pSeg ){
-            pSeg->pNext = pSeg->pNext->pNext;
+            pSeg->pNext = ALWAYS(pSeg->pNext) ? pSeg->pNext->pNext : 0;
             break;
           }
         }
@@ -194669,6 +199697,7 @@ static int geopolyFilter(
       RtreeCoord bbox[4];
       RtreeConstraint *p;
       assert( argc==1 );
+      assert( argv[0]!=0 );
       geopolyBBox(0, argv[0], bbox, &rc);
       if( rc ){
         goto geopoly_filter_end;
@@ -194896,6 +199925,7 @@ static int geopolyUpdate(
         || !sqlite3_value_nochange(aData[2])  /* UPDATE _shape */
         || oldRowid!=newRowid)                /* Rowid change */
   ){
+    assert( aData[2]!=0 );
     geopolyBBox(0, aData[2], cell.aCoord, &rc);
     if( rc ){
       if( rc==SQLITE_ERROR ){
@@ -195249,7 +200279,10 @@ SQLITE_API int sqlite3_rtree_query_callback(
 
   /* Allocate and populate the context object. */
   pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback));
-  if( !pGeomCtx ) return SQLITE_NOMEM;
+  if( !pGeomCtx ){
+    if( xDestructor ) xDestructor(pContext);
+    return SQLITE_NOMEM;
+  }
   pGeomCtx->xGeom = 0;
   pGeomCtx->xQueryFunc = xQueryFunc;
   pGeomCtx->xDestructor = xDestructor;
@@ -196820,6 +201853,13 @@ SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
 # define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
 #endif
 
+/*
+** Name of the URI option that causes RBU to take an exclusive lock as
+** part of the incremental checkpoint operation.
+*/
+#define RBU_EXCLUSIVE_CHECKPOINT "rbu_exclusive_checkpoint"
+
+
 /*
 ** The rbu_state table is used to save the state of a partially applied
 ** update so that it can be resumed later. The table consists of integer
@@ -197904,7 +202944,9 @@ static void rbuTableType(
   assert( p->rc==SQLITE_OK );
   p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg,
     sqlite3_mprintf(
-          "SELECT (sql LIKE 'create virtual%%'), rootpage"
+          "SELECT "
+          " (sql COLLATE nocase BETWEEN 'CREATE VIRTUAL' AND 'CREATE VIRTUAM'),"
+          " rootpage"
           "  FROM sqlite_schema"
           " WHERE name=%Q", zTab
   ));
@@ -198330,7 +203372,9 @@ char *rbuVacuumIndexStart(
       zSep = "";
       for(iCol=0; iCol<pIter->nCol; iCol++){
         const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
-        if( zQuoted[0]=='N' ){
+        if( zQuoted==0 ){
+          p->rc = SQLITE_NOMEM;
+        }else if( zQuoted[0]=='N' ){
           bFailed = 1;
           break;
         }
@@ -199435,7 +204479,7 @@ static RbuState *rbuLoadState(sqlite3rbu *p){
         break;
 
       case RBU_STATE_OALSZ:
-        pRet->iOalSz = (u32)sqlite3_column_int64(pStmt, 1);
+        pRet->iOalSz = sqlite3_column_int64(pStmt, 1);
         break;
 
       case RBU_STATE_PHASEONESTEP:
@@ -199462,13 +204506,19 @@ static RbuState *rbuLoadState(sqlite3rbu *p){
 /*
 ** Open the database handle and attach the RBU database as "rbu". If an
 ** error occurs, leave an error code and message in the RBU handle.
+**
+** If argument dbMain is not NULL, then it is a database handle already
+** open on the target database. Use this handle instead of opening a new
+** one.
 */
-static void rbuOpenDatabase(sqlite3rbu *p, int *pbRetry){
+static void rbuOpenDatabase(sqlite3rbu *p, sqlite3 *dbMain, int *pbRetry){
   assert( p->rc || (p->dbMain==0 && p->dbRbu==0) );
   assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 );
+  assert( dbMain==0 || rbuIsVacuum(p)==0 );
 
   /* Open the RBU database */
   p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1);
+  p->dbMain = dbMain;
 
   if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
     sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p);
@@ -199834,15 +204884,31 @@ static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){
 
 
 /*
-** Take an EXCLUSIVE lock on the database file.
+** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if
+** successful, or an SQLite error code otherwise.
 */
-static void rbuLockDatabase(sqlite3rbu *p){
-  sqlite3_file *pReal = p->pTargetFd->pReal;
-  assert( p->rc==SQLITE_OK );
-  p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_SHARED);
-  if( p->rc==SQLITE_OK ){
-    p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_EXCLUSIVE);
+static int rbuLockDatabase(sqlite3 *db){
+  int rc = SQLITE_OK;
+  sqlite3_file *fd = 0;
+  sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, &fd);
+
+  if( fd->pMethods ){
+    rc = fd->pMethods->xLock(fd, SQLITE_LOCK_SHARED);
+    if( rc==SQLITE_OK ){
+      rc = fd->pMethods->xLock(fd, SQLITE_LOCK_EXCLUSIVE);
+    }
   }
+  return rc;
+}
+
+/*
+** Return true if the database handle passed as the only argument
+** was opened with the rbu_exclusive_checkpoint=1 URI parameter
+** specified. Or false otherwise.
+*/
+static int rbuExclusiveCheckpoint(sqlite3 *db){
+  const char *zUri = sqlite3_db_filename(db, 0);
+  return sqlite3_uri_boolean(zUri, RBU_EXCLUSIVE_CHECKPOINT, 0);
 }
 
 #if defined(_WIN32_WCE)
@@ -199900,18 +204966,24 @@ static void rbuMoveOalFile(sqlite3rbu *p){
     ** In order to ensure that there are no database readers, an EXCLUSIVE
     ** lock is obtained here before the *-oal is moved to *-wal.
     */
-    rbuLockDatabase(p);
-    if( p->rc==SQLITE_OK ){
-      rbuFileSuffix3(zBase, zWal);
-      rbuFileSuffix3(zBase, zOal);
+    sqlite3 *dbMain = 0;
+    rbuFileSuffix3(zBase, zWal);
+    rbuFileSuffix3(zBase, zOal);
+
+    /* Re-open the databases. */
+    rbuObjIterFinalize(&p->objiter);
+    sqlite3_close(p->dbRbu);
+    sqlite3_close(p->dbMain);
+    p->dbMain = 0;
+    p->dbRbu = 0;
 
-      /* Re-open the databases. */
-      rbuObjIterFinalize(&p->objiter);
-      sqlite3_close(p->dbRbu);
-      sqlite3_close(p->dbMain);
-      p->dbMain = 0;
-      p->dbRbu = 0;
+    dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
+    if( dbMain ){
+      assert( p->rc==SQLITE_OK );
+      p->rc = rbuLockDatabase(dbMain);
+    }
 
+    if( p->rc==SQLITE_OK ){
 #if defined(_WIN32_WCE)
       {
         LPWSTR zWideOal;
@@ -199938,11 +205010,19 @@ static void rbuMoveOalFile(sqlite3rbu *p){
 #else
       p->rc = rename(zOal, zWal) ? SQLITE_IOERR : SQLITE_OK;
 #endif
+    }
 
-      if( p->rc==SQLITE_OK ){
-        rbuOpenDatabase(p, 0);
-        rbuSetupCheckpoint(p, 0);
-      }
+    if( p->rc!=SQLITE_OK
+     || rbuIsVacuum(p)
+     || rbuExclusiveCheckpoint(dbMain)==0
+    ){
+      sqlite3_close(dbMain);
+      dbMain = 0;
+    }
+
+    if( p->rc==SQLITE_OK ){
+      rbuOpenDatabase(p, dbMain, 0);
+      rbuSetupCheckpoint(p, 0);
     }
   }
 
@@ -200693,9 +205773,9 @@ static sqlite3rbu *openRbuHandle(
       ** If this is the case, it will have been checkpointed and deleted
       ** when the handle was closed and a second attempt to open the
       ** database may succeed.  */
-      rbuOpenDatabase(p, &bRetry);
+      rbuOpenDatabase(p, 0, &bRetry);
       if( bRetry ){
-        rbuOpenDatabase(p, 0);
+        rbuOpenDatabase(p, 0, 0);
       }
     }
 
@@ -200790,6 +205870,14 @@ static sqlite3rbu *openRbuHandle(
       }else if( p->eStage==RBU_STAGE_MOVE ){
         /* no-op */
       }else if( p->eStage==RBU_STAGE_CKPT ){
+        if( !rbuIsVacuum(p) && rbuExclusiveCheckpoint(p->dbMain) ){
+          /* If the rbu_exclusive_checkpoint=1 URI parameter was specified
+          ** and an incremental checkpoint is being resumed, attempt an
+          ** exclusive lock on the db file. If this fails, so be it.  */
+          p->eStage = RBU_STAGE_DONE;
+          rbuLockDatabase(p->dbMain);
+          p->eStage = RBU_STAGE_CKPT;
+        }
         rbuSetupCheckpoint(p, pState);
       }else if( p->eStage==RBU_STAGE_DONE ){
         p->rc = SQLITE_DONE;
@@ -200827,7 +205915,6 @@ SQLITE_API sqlite3rbu *sqlite3rbu_open(
   const char *zState
 ){
   if( zTarget==0 || zRbu==0 ){ return rbuMisuseError(); }
-  /* TODO: Check that zTarget and zRbu are non-NULL */
   return openRbuHandle(zTarget, zRbu, zState);
 }
 
@@ -201538,22 +206625,24 @@ static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
 #endif
 
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( pRbu && (pRbu->eStage==RBU_STAGE_OAL || pRbu->eStage==RBU_STAGE_MOVE) ){
-    /* Magic number 1 is the WAL_CKPT_LOCK lock. Preventing SQLite from
-    ** taking this lock also prevents any checkpoints from occurring.
-    ** todo: really, it's not clear why this might occur, as
-    ** wal_autocheckpoint ought to be turned off.  */
+  if( pRbu && (
+       pRbu->eStage==RBU_STAGE_OAL
+    || pRbu->eStage==RBU_STAGE_MOVE
+    || pRbu->eStage==RBU_STAGE_DONE
+  )){
+    /* Prevent SQLite from taking a shm-lock on the target file when it
+    ** is supplying heap memory to the upper layer in place of *-shm
+    ** segments. */
     if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
   }else{
     int bCapture = 0;
     if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
       bCapture = 1;
     }
-
     if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
       rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
       if( bCapture && rc==SQLITE_OK ){
-        pRbu->mLock |= (1 << ofst);
+        pRbu->mLock |= ((1<<n) - 1) << ofst;
       }
     }
   }
@@ -201700,28 +206789,14 @@ static int rbuVfsOpen(
       rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
       if( pDb ){
         if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
-          /* This call is to open a *-wal file. Intead, open the *-oal. This
-          ** code ensures that the string passed to xOpen() is terminated by a
-          ** pair of '\0' bytes in case the VFS attempts to extract a URI
-          ** parameter from it.  */
-          const char *zBase = zName;
-          size_t nCopy;
-          char *zCopy;
+          /* This call is to open a *-wal file. Intead, open the *-oal. */
+          size_t nOpen;
           if( rbuIsVacuum(pDb->pRbu) ){
-            zBase = sqlite3_db_filename(pDb->pRbu->dbRbu, "main");
-            zBase = sqlite3_filename_wal(zBase);
-          }
-          nCopy = strlen(zBase);
-          zCopy = sqlite3_malloc64(nCopy+2);
-          if( zCopy ){
-            memcpy(zCopy, zBase, nCopy);
-            zCopy[nCopy-3] = 'o';
-            zCopy[nCopy] = '\0';
-            zCopy[nCopy+1] = '\0';
-            zOpen = (const char*)(pFd->zDel = zCopy);
-          }else{
-            rc = SQLITE_NOMEM;
+            zOpen = sqlite3_db_filename(pDb->pRbu->dbRbu, "main");
+            zOpen = sqlite3_filename_wal(zOpen);
           }
+          nOpen = strlen(zOpen);
+          ((char*)zOpen)[nOpen-3] = 'o';
           pFd->pRbu = pDb->pRbu;
         }
         pDb->pWalFd = pFd;
@@ -202042,6 +207117,15 @@ SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu *pRbu){
 #if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \
     && !defined(SQLITE_OMIT_VIRTUALTABLE)
 
+/*
+** The pager and btree modules arrange objects in memory so that there are
+** always approximately 200 bytes of addressable memory following each page
+** buffer. This way small buffer overreads caused by corrupt database pages
+** do not cause undefined behaviour. This module pads each page buffer
+** by the following number of bytes for the same purpose.
+*/
+#define DBSTAT_PAGE_PADDING_BYTES 256
+
 /*
 ** Page paths:
 **
@@ -202109,9 +207193,8 @@ struct StatCell {
 /* Size information for a single btree page */
 struct StatPage {
   u32 iPgno;                      /* Page number */
-  DbPage *pPg;                    /* Page content */
+  u8 *aPg;                        /* Page buffer from sqlite3_malloc() */
   int iCell;                      /* Current cell */
-
   char *zPath;                    /* Path to this page */
 
   /* Variables populated by statDecodePage(): */
@@ -202323,18 +207406,25 @@ static void statClearCells(StatPage *p){
 }
 
 static void statClearPage(StatPage *p){
+  u8 *aPg = p->aPg;
   statClearCells(p);
-  sqlite3PagerUnref(p->pPg);
   sqlite3_free(p->zPath);
   memset(p, 0, sizeof(StatPage));
+  p->aPg = aPg;
 }
 
 static void statResetCsr(StatCursor *pCsr){
   int i;
-  sqlite3_reset(pCsr->pStmt);
+  /* In some circumstances, specifically if an OOM has occurred, the call
+  ** to sqlite3_reset() may cause the pager to be reset (emptied). It is
+  ** important that statClearPage() is called to free any page refs before
+  ** this happens. dbsqlfuzz 9ed3e4e3816219d3509d711636c38542bf3f40b1. */
   for(i=0; i<ArraySize(pCsr->aPage); i++){
     statClearPage(&pCsr->aPage[i]);
+    sqlite3_free(pCsr->aPage[i].aPg);
+    pCsr->aPage[i].aPg = 0;
   }
+  sqlite3_reset(pCsr->pStmt);
   pCsr->iPage = 0;
   sqlite3_free(pCsr->zPath);
   pCsr->zPath = 0;
@@ -202399,7 +207489,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){
   int isLeaf;
   int szPage;
 
-  u8 *aData = sqlite3PagerGetData(p->pPg);
+  u8 *aData = p->aPg;
   u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
 
   p->flags = aHdr[0];
@@ -202470,7 +207560,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){
         if( nPayload>(u32)nLocal ){
           int j;
           int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
-          if( iOff+nLocal>nUsable || nPayload>0x7fffffff ){
+          if( iOff+nLocal+4>nUsable || nPayload>0x7fffffff ){
             goto statPageIsCorrupt;
           }
           pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
@@ -202529,6 +207619,38 @@ static void statSizeAndOffset(StatCursor *pCsr){
   }
 }
 
+/*
+** Load a copy of the page data for page iPg into the buffer belonging
+** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
+** if successful, or an SQLite error code otherwise.
+*/
+static int statGetPage(
+  Btree *pBt,                     /* Load page from this b-tree */
+  u32 iPg,                        /* Page number to load */
+  StatPage *pPg                   /* Load page into this object */
+){
+  int pgsz = sqlite3BtreeGetPageSize(pBt);
+  DbPage *pDbPage = 0;
+  int rc;
+
+  if( pPg->aPg==0 ){
+    pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES);
+    if( pPg->aPg==0 ){
+      return SQLITE_NOMEM_BKPT;
+    }
+    memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES);
+  }
+
+  rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPg, &pDbPage, 0);
+  if( rc==SQLITE_OK ){
+    const u8 *a = sqlite3PagerGetData(pDbPage);
+    memcpy(pPg->aPg, a, pgsz);
+    sqlite3PagerUnref(pDbPage);
+  }
+
+  return rc;
+}
+
 /*
 ** Move a DBSTAT cursor to the next entry.  Normally, the next
 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
@@ -202547,7 +207669,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){
   pCsr->zPath = 0;
 
 statNextRestart:
-  if( pCsr->aPage[0].pPg==0 ){
+  if( pCsr->iPage<0 ){
     /* Start measuring space on the next btree */
     statResetCounts(pCsr);
     rc = sqlite3_step(pCsr->pStmt);
@@ -202559,7 +207681,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){
         pCsr->isEof = 1;
         return sqlite3_reset(pCsr->pStmt);
       }
-      rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0);
+      rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]);
       pCsr->aPage[0].iPgno = iRoot;
       pCsr->aPage[0].iCell = 0;
       if( !pCsr->isAgg ){
@@ -202610,9 +207732,8 @@ static int statNext(sqlite3_vtab_cursor *pCursor){
 
     if( !p->iRightChildPg || p->iCell>p->nCell ){
       statClearPage(p);
-      if( pCsr->iPage>0 ){
-        pCsr->iPage--;
-      }else if( pCsr->isAgg ){
+      pCsr->iPage--;
+      if( pCsr->isAgg && pCsr->iPage<0 ){
         /* label-statNext-done:  When computing aggregate space usage over
         ** an entire btree, this is the exit point from this function */
         return SQLITE_OK;
@@ -202631,7 +207752,7 @@ static int statNext(sqlite3_vtab_cursor *pCursor){
     }else{
       p[1].iPgno = p->aCell[p->iCell].iChildPg;
     }
-    rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0);
+    rc = statGetPage(pBt, p[1].iPgno, &p[1]);
     pCsr->nPage++;
     p[1].iCell = 0;
     if( !pCsr->isAgg ){
@@ -202761,6 +207882,7 @@ static int statFilter(
   }
 
   if( rc==SQLITE_OK ){
+    pCsr->iPage = -1;
     rc = statNext(pCursor);
   }
   return rc;
@@ -203334,12 +208456,15 @@ struct SessionHook {
 struct sqlite3_session {
   sqlite3 *db;                    /* Database handle session is attached to */
   char *zDb;                      /* Name of database session is attached to */
+  int bEnableSize;                /* True if changeset_size() enabled */
   int bEnable;                    /* True if currently recording */
   int bIndirect;                  /* True if all changes are indirect */
   int bAutoAttach;                /* True to auto-attach tables */
   int rc;                         /* Non-zero if an error has occurred */
   void *pFilterCtx;               /* First argument to pass to xTableFilter */
   int (*xTableFilter)(void *pCtx, const char *zTab);
+  i64 nMalloc;                    /* Number of bytes of data allocated */
+  i64 nMaxChangesetSize;
   sqlite3_value *pZeroBlob;       /* Value containing X'' */
   sqlite3_session *pNext;         /* Next session object on same db. */
   SessionTable *pTable;           /* List of attached tables */
@@ -203382,6 +208507,7 @@ struct sqlite3_changeset_iter {
   SessionBuffer tblhdr;           /* Buffer to hold apValue/zTab/abPK/ */
   int bPatchset;                  /* True if this is a patchset */
   int bInvert;                    /* True to invert changeset */
+  int bSkipEmpty;                 /* Skip noop UPDATE changes */
   int rc;                         /* Iterator error code */
   sqlite3_stmt *pConflict;        /* Points to conflicting row, if any */
   char *zTab;                     /* Current table */
@@ -203581,8 +208707,9 @@ struct SessionTable {
 ** this structure stored in a SessionTable.aChange[] hash table.
 */
 struct SessionChange {
-  int op;                         /* One of UPDATE, DELETE, INSERT */
-  int bIndirect;                  /* True if this change is "indirect" */
+  u8 op;                          /* One of UPDATE, DELETE, INSERT */
+  u8 bIndirect;                   /* True if this change is "indirect" */
+  int nMaxSize;                   /* Max size of eventual changeset record */
   int nRecord;                    /* Number of bytes in buffer aRecord[] */
   u8 *aRecord;                    /* Buffer containing old.* record */
   SessionChange *pNext;           /* For hash-table collisions */
@@ -203707,7 +208834,7 @@ static int sessionSerializeValue(
 
         if( aBuf ){
           sessionVarintPut(&aBuf[1], n);
-          if( n ) memcpy(&aBuf[nVarint + 1], z, n);
+          if( n>0 ) memcpy(&aBuf[nVarint + 1], z, n);
         }
 
         nByte = 1 + nVarint + n;
@@ -203723,6 +208850,26 @@ static int sessionSerializeValue(
   return SQLITE_OK;
 }
 
+/*
+** Allocate and return a pointer to a buffer nByte bytes in size. If
+** pSession is not NULL, increase the sqlite3_session.nMalloc variable
+** by the number of bytes allocated.
+*/
+static void *sessionMalloc64(sqlite3_session *pSession, i64 nByte){
+  void *pRet = sqlite3_malloc64(nByte);
+  if( pSession ) pSession->nMalloc += sqlite3_msize(pRet);
+  return pRet;
+}
+
+/*
+** Free buffer pFree, which must have been allocated by an earlier
+** call to sessionMalloc64(). If pSession is not NULL, decrease the
+** sqlite3_session.nMalloc counter by the number of bytes freed.
+*/
+static void sessionFree(sqlite3_session *pSession, void *pFree){
+  if( pSession ) pSession->nMalloc -= sqlite3_msize(pFree);
+  sqlite3_free(pFree);
+}
 
 /*
 ** This macro is used to calculate hash key values for data structures. In
@@ -204190,13 +209337,19 @@ static int sessionPreupdateEqual(
 ** Growing the hash table in this case is a performance optimization only,
 ** it is not required for correct operation.
 */
-static int sessionGrowHash(int bPatchset, SessionTable *pTab){
+static int sessionGrowHash(
+  sqlite3_session *pSession,      /* For memory accounting. May be NULL */
+  int bPatchset,
+  SessionTable *pTab
+){
   if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
     int i;
     SessionChange **apNew;
     sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
 
-    apNew = (SessionChange **)sqlite3_malloc64(sizeof(SessionChange *) * nNew);
+    apNew = (SessionChange**)sessionMalloc64(
+        pSession, sizeof(SessionChange*) * nNew
+    );
     if( apNew==0 ){
       if( pTab->nChange==0 ){
         return SQLITE_ERROR;
@@ -204217,7 +209370,7 @@ static int sessionGrowHash(int bPatchset, SessionTable *pTab){
       }
     }
 
-    sqlite3_free(pTab->apChange);
+    sessionFree(pSession, pTab->apChange);
     pTab->nChange = nNew;
     pTab->apChange = apNew;
   }
@@ -204251,6 +209404,7 @@ static int sessionGrowHash(int bPatchset, SessionTable *pTab){
 ** be freed using sqlite3_free() by the caller
 */
 static int sessionTableInfo(
+  sqlite3_session *pSession,      /* For memory accounting. May be NULL */
   sqlite3 *db,                    /* Database connection */
   const char *zDb,                /* Name of attached database (e.g. "main") */
   const char *zThis,              /* Table name */
@@ -204285,16 +209439,32 @@ static int sessionTableInfo(
     }else if( rc==SQLITE_ERROR ){
       zPragma = sqlite3_mprintf("");
     }else{
+      *pazCol = 0;
+      *pabPK = 0;
+      *pnCol = 0;
+      if( pzTab ) *pzTab = 0;
       return rc;
     }
   }else{
     zPragma = sqlite3_mprintf("PRAGMA '%q'.table_info('%q')", zDb, zThis);
   }
-  if( !zPragma ) return SQLITE_NOMEM;
+  if( !zPragma ){
+    *pazCol = 0;
+    *pabPK = 0;
+    *pnCol = 0;
+    if( pzTab ) *pzTab = 0;
+    return SQLITE_NOMEM;
+  }
 
   rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0);
   sqlite3_free(zPragma);
-  if( rc!=SQLITE_OK ) return rc;
+  if( rc!=SQLITE_OK ){
+    *pazCol = 0;
+    *pabPK = 0;
+    *pnCol = 0;
+    if( pzTab ) *pzTab = 0;
+    return rc;
+  }
 
   nByte = nThis + 1;
   while( SQLITE_ROW==sqlite3_step(pStmt) ){
@@ -204305,7 +209475,7 @@ static int sessionTableInfo(
 
   if( rc==SQLITE_OK ){
     nByte += nDbCol * (sizeof(const char *) + sizeof(u8) + 1);
-    pAlloc = sqlite3_malloc64(nByte);
+    pAlloc = sessionMalloc64(pSession, nByte);
     if( pAlloc==0 ){
       rc = SQLITE_NOMEM;
     }
@@ -204348,7 +209518,7 @@ static int sessionTableInfo(
     *pabPK = 0;
     *pnCol = 0;
     if( pzTab ) *pzTab = 0;
-    sqlite3_free(azCol);
+    sessionFree(pSession, azCol);
   }
   sqlite3_finalize(pStmt);
   return rc;
@@ -204370,7 +209540,7 @@ static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){
   if( pTab->nCol==0 ){
     u8 *abPK;
     assert( pTab->azCol==0 || pTab->abPK==0 );
-    pSession->rc = sessionTableInfo(pSession->db, pSession->zDb,
+    pSession->rc = sessionTableInfo(pSession, pSession->db, pSession->zDb,
         pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
     );
     if( pSession->rc==SQLITE_OK ){
@@ -204384,6 +209554,12 @@ static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){
       if( 0==sqlite3_stricmp("sqlite_stat1", pTab->zName) ){
         pTab->bStat1 = 1;
       }
+
+      if( pSession->bEnableSize ){
+        pSession->nMaxChangesetSize += (
+          1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
+        );
+      }
     }
   }
   return (pSession->rc || pTab->abPK==0);
@@ -204429,6 +209605,103 @@ static int sessionStat1Depth(void *pCtx){
   return p->hook.xDepth(p->hook.pCtx);
 }
 
+static int sessionUpdateMaxSize(
+  int op,
+  sqlite3_session *pSession,      /* Session object pTab is attached to */
+  SessionTable *pTab,             /* Table that change applies to */
+  SessionChange *pC               /* Update pC->nMaxSize */
+){
+  i64 nNew = 2;
+  if( pC->op==SQLITE_INSERT ){
+    if( op!=SQLITE_DELETE ){
+      int ii;
+      for(ii=0; ii<pTab->nCol; ii++){
+        sqlite3_value *p = 0;
+        pSession->hook.xNew(pSession->hook.pCtx, ii, &p);
+        sessionSerializeValue(0, p, &nNew);
+      }
+    }
+  }else if( op==SQLITE_DELETE ){
+    nNew += pC->nRecord;
+    if( sqlite3_preupdate_blobwrite(pSession->db)>=0 ){
+      nNew += pC->nRecord;
+    }
+  }else{
+    int ii;
+    u8 *pCsr = pC->aRecord;
+    for(ii=0; ii<pTab->nCol; ii++){
+      int bChanged = 1;
+      int nOld = 0;
+      int eType;
+      sqlite3_value *p = 0;
+      pSession->hook.xNew(pSession->hook.pCtx, ii, &p);
+      if( p==0 ){
+        return SQLITE_NOMEM;
+      }
+
+      eType = *pCsr++;
+      switch( eType ){
+        case SQLITE_NULL:
+          bChanged = sqlite3_value_type(p)!=SQLITE_NULL;
+          break;
+
+        case SQLITE_FLOAT:
+        case SQLITE_INTEGER: {
+          if( eType==sqlite3_value_type(p) ){
+            sqlite3_int64 iVal = sessionGetI64(pCsr);
+            if( eType==SQLITE_INTEGER ){
+              bChanged = (iVal!=sqlite3_value_int64(p));
+            }else{
+              double dVal;
+              memcpy(&dVal, &iVal, 8);
+              bChanged = (dVal!=sqlite3_value_double(p));
+            }
+          }
+          nOld = 8;
+          pCsr += 8;
+          break;
+        }
+
+        default: {
+          int nByte;
+          nOld = sessionVarintGet(pCsr, &nByte);
+          pCsr += nOld;
+          nOld += nByte;
+          assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
+          if( eType==sqlite3_value_type(p)
+           && nByte==sqlite3_value_bytes(p)
+           && (nByte==0 || 0==memcmp(pCsr, sqlite3_value_blob(p), nByte))
+          ){
+            bChanged = 0;
+          }
+          pCsr += nByte;
+          break;
+        }
+      }
+
+      if( bChanged && pTab->abPK[ii] ){
+        nNew = pC->nRecord + 2;
+        break;
+      }
+
+      if( bChanged ){
+        nNew += 1 + nOld;
+        sessionSerializeValue(0, p, &nNew);
+      }else if( pTab->abPK[ii] ){
+        nNew += 2 + nOld;
+      }else{
+        nNew += 2;
+      }
+    }
+  }
+
+  if( nNew>pC->nMaxSize ){
+    int nIncr = nNew - pC->nMaxSize;
+    pC->nMaxSize = nNew;
+    pSession->nMaxChangesetSize += nIncr;
+  }
+  return SQLITE_OK;
+}
 
 /*
 ** This function is only called from with a pre-update-hook reporting a
@@ -204461,7 +209734,7 @@ static void sessionPreupdateOneChange(
   }
 
   /* Grow the hash table if required */
-  if( sessionGrowHash(0, pTab) ){
+  if( sessionGrowHash(pSession, 0, pTab) ){
     pSession->rc = SQLITE_NOMEM;
     return;
   }
@@ -204502,7 +209775,6 @@ static void sessionPreupdateOneChange(
       /* Create a new change object containing all the old values (if
       ** this is an SQLITE_UPDATE or SQLITE_DELETE), or just the PK
       ** values (if this is an INSERT). */
-      SessionChange *pChange; /* New change object */
       sqlite3_int64 nByte;    /* Number of bytes to allocate */
       int i;                  /* Used to iterate through columns */
 
@@ -204528,13 +209800,13 @@ static void sessionPreupdateOneChange(
       }
 
       /* Allocate the change object */
-      pChange = (SessionChange *)sqlite3_malloc64(nByte);
-      if( !pChange ){
+      pC = (SessionChange *)sessionMalloc64(pSession, nByte);
+      if( !pC ){
         rc = SQLITE_NOMEM;
         goto error_out;
       }else{
-        memset(pChange, 0, sizeof(SessionChange));
-        pChange->aRecord = (u8 *)&pChange[1];
+        memset(pC, 0, sizeof(SessionChange));
+        pC->aRecord = (u8 *)&pC[1];
       }
 
       /* Populate the change object. None of the preupdate_old(),
@@ -204549,17 +209821,17 @@ static void sessionPreupdateOneChange(
         }else if( pTab->abPK[i] ){
           pSession->hook.xNew(pSession->hook.pCtx, i, &p);
         }
-        sessionSerializeValue(&pChange->aRecord[nByte], p, &nByte);
+        sessionSerializeValue(&pC->aRecord[nByte], p, &nByte);
       }
 
       /* Add the change to the hash-table */
       if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
-        pChange->bIndirect = 1;
+        pC->bIndirect = 1;
       }
-      pChange->nRecord = nByte;
-      pChange->op = op;
-      pChange->pNext = pTab->apChange[iHash];
-      pTab->apChange[iHash] = pChange;
+      pC->nRecord = nByte;
+      pC->op = op;
+      pC->pNext = pTab->apChange[iHash];
+      pTab->apChange[iHash] = pC;
 
     }else if( pC->bIndirect ){
       /* If the existing change is considered "indirect", but this current
@@ -204570,8 +209842,14 @@ static void sessionPreupdateOneChange(
         pC->bIndirect = 0;
       }
     }
+
+    assert( rc==SQLITE_OK );
+    if( pSession->bEnableSize ){
+      rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
+    }
   }
 
+
   /* If an error has occurred, mark the session object as failed. */
  error_out:
   if( pTab->bStat1 ){
@@ -204604,7 +209882,11 @@ static int sessionFindTable(
     ){
       rc = sqlite3session_attach(pSession, zName);
       if( rc==SQLITE_OK ){
-        for(pRet=pSession->pTable; pRet->pNext; pRet=pRet->pNext);
+        pRet = pSession->pTable;
+        while( ALWAYS(pRet) && pRet->pNext ){
+          pRet = pRet->pNext;
+        }
+        assert( pRet!=0 );
         assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
       }
     }
@@ -204901,7 +210183,7 @@ SQLITE_API int sqlite3session_diff(
       int nCol;                   /* Columns in zFrom.zTbl */
       u8 *abPK;
       const char **azCol = 0;
-      rc = sessionTableInfo(db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
+      rc = sessionTableInfo(0, db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
       if( rc==SQLITE_OK ){
         if( pTo->nCol!=nCol ){
           bMismatch = 1;
@@ -204999,7 +210281,7 @@ SQLITE_API int sqlite3session_create(
 ** Free the list of table objects passed as the first argument. The contents
 ** of the changed-rows hash tables are also deleted.
 */
-static void sessionDeleteTable(SessionTable *pList){
+static void sessionDeleteTable(sqlite3_session *pSession, SessionTable *pList){
   SessionTable *pNext;
   SessionTable *pTab;
 
@@ -205011,12 +210293,12 @@ static void sessionDeleteTable(SessionTable *pList){
       SessionChange *pNextChange;
       for(p=pTab->apChange[i]; p; p=pNextChange){
         pNextChange = p->pNext;
-        sqlite3_free(p);
+        sessionFree(pSession, p);
       }
     }
-    sqlite3_free((char*)pTab->azCol);  /* cast works around VC++ bug */
-    sqlite3_free(pTab->apChange);
-    sqlite3_free(pTab);
+    sessionFree(pSession, (char*)pTab->azCol);  /* cast works around VC++ bug */
+    sessionFree(pSession, pTab->apChange);
+    sessionFree(pSession, pTab);
   }
 }
 
@@ -205044,9 +210326,11 @@ SQLITE_API void sqlite3session_delete(sqlite3_session *pSession){
 
   /* Delete all attached table objects. And the contents of their
   ** associated hash-tables. */
-  sessionDeleteTable(pSession->pTable);
+  sessionDeleteTable(pSession, pSession->pTable);
 
-  /* Free the session object itself. */
+  /* Assert that all allocations have been freed and then free the
+  ** session object itself. */
+  assert( pSession->nMalloc==0 );
   sqlite3_free(pSession);
 }
 
@@ -205093,7 +210377,8 @@ SQLITE_API int sqlite3session_attach(
 
     if( !pTab ){
       /* Allocate new SessionTable object. */
-      pTab = (SessionTable *)sqlite3_malloc64(sizeof(SessionTable) + nName + 1);
+      int nByte = sizeof(SessionTable) + nName + 1;
+      pTab = (SessionTable*)sessionMalloc64(pSession, nByte);
       if( !pTab ){
         rc = SQLITE_NOMEM;
       }else{
@@ -205123,13 +210408,29 @@ SQLITE_API int sqlite3session_attach(
 ** If successful, return zero. Otherwise, if an OOM condition is encountered,
 ** set *pRc to SQLITE_NOMEM and return non-zero.
 */
-static int sessionBufferGrow(SessionBuffer *p, size_t nByte, int *pRc){
-  if( *pRc==SQLITE_OK && (size_t)(p->nAlloc-p->nBuf)<nByte ){
+static int sessionBufferGrow(SessionBuffer *p, i64 nByte, int *pRc){
+#define SESSION_MAX_BUFFER_SZ (0x7FFFFF00 - 1)
+  i64 nReq = p->nBuf + nByte;
+  if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
     u8 *aNew;
     i64 nNew = p->nAlloc ? p->nAlloc : 128;
+
     do {
       nNew = nNew*2;
-    }while( (size_t)(nNew-p->nBuf)<nByte );
+    }while( nNew<nReq );
+
+    /* The value of SESSION_MAX_BUFFER_SZ is copied from the implementation
+    ** of sqlite3_realloc64(). Allocations greater than this size in bytes
+    ** always fail. It is used here to ensure that this routine can always
+    ** allocate up to this limit - instead of up to the largest power of
+    ** two smaller than the limit.  */
+    if( nNew>SESSION_MAX_BUFFER_SZ ){
+      nNew = SESSION_MAX_BUFFER_SZ;
+      if( nNew<nReq ){
+        *pRc = SQLITE_NOMEM;
+        return 1;
+      }
+    }
 
     aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
     if( 0==aNew ){
@@ -205358,6 +210659,7 @@ static int sessionAppendUpdate(
   int i;                        /* Used to iterate through columns */
   u8 *pCsr = p->aRecord;        /* Used to iterate through old.* values */
 
+  assert( abPK!=0 );
   sessionAppendByte(pBuf, SQLITE_UPDATE, &rc);
   sessionAppendByte(pBuf, p->bIndirect, &rc);
   for(i=0; i<sqlite3_column_count(pStmt); i++){
@@ -205662,12 +210964,14 @@ static int sessionGenerateChangeset(
   SessionBuffer buf = {0,0,0};    /* Buffer in which to accumlate changeset */
   int rc;                         /* Return code */
 
-  assert( xOutput==0 || (pnChangeset==0 && ppChangeset==0 ) );
+  assert( xOutput==0 || (pnChangeset==0 && ppChangeset==0) );
+  assert( xOutput!=0 || (pnChangeset!=0 && ppChangeset!=0) );
 
   /* Zero the output variables in case an error occurs. If this session
   ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
   ** this call will be a no-op.  */
   if( xOutput==0 ){
+    assert( pnChangeset!=0  && ppChangeset!=0 );
     *pnChangeset = 0;
     *ppChangeset = 0;
   }
@@ -205681,8 +210985,8 @@ static int sessionGenerateChangeset(
   for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
     if( pTab->nEntry ){
       const char *zName = pTab->zName;
-      int nCol;                   /* Number of columns in table */
-      u8 *abPK;                   /* Primary key array */
+      int nCol = 0;               /* Number of columns in table */
+      u8 *abPK = 0;               /* Primary key array */
       const char **azCol = 0;     /* Table columns */
       int i;                      /* Used to iterate through hash buckets */
       sqlite3_stmt *pSel = 0;     /* SELECT statement to query table pTab */
@@ -205690,7 +210994,7 @@ static int sessionGenerateChangeset(
       int nNoop;                  /* Size of buffer after writing tbl header */
 
       /* Check the table schema is still Ok. */
-      rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
+      rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
       if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
         rc = SQLITE_SCHEMA;
       }
@@ -205720,6 +211024,7 @@ static int sessionGenerateChangeset(
                 sessionAppendCol(&buf, pSel, iCol, &rc);
               }
             }else{
+              assert( abPK!=0 );  /* Because sessionSelectStmt() returned ok */
               rc = sessionAppendUpdate(&buf, bPatchset, pSel, p, abPK);
             }
           }else if( p->op!=SQLITE_INSERT ){
@@ -205780,7 +211085,14 @@ SQLITE_API int sqlite3session_changeset(
   int *pnChangeset,               /* OUT: Size of buffer at *ppChangeset */
   void **ppChangeset              /* OUT: Buffer containing changeset */
 ){
-  return sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset, ppChangeset);
+  int rc;
+
+  if( pnChangeset==0 || ppChangeset==0 ) return SQLITE_MISUSE;
+  rc = sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset,ppChangeset);
+  assert( rc || pnChangeset==0
+       || pSession->bEnableSize==0 || *pnChangeset<=pSession->nMaxChangesetSize
+  );
+  return rc;
 }
 
 /*
@@ -205791,6 +211103,7 @@ SQLITE_API int sqlite3session_changeset_strm(
   int (*xOutput)(void *pOut, const void *pData, int nData),
   void *pOut
 ){
+  if( xOutput==0 ) return SQLITE_MISUSE;
   return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
 }
 
@@ -205802,6 +211115,7 @@ SQLITE_API int sqlite3session_patchset_strm(
   int (*xOutput)(void *pOut, const void *pData, int nData),
   void *pOut
 ){
+  if( xOutput==0 ) return SQLITE_MISUSE;
   return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
 }
 
@@ -205817,6 +211131,7 @@ SQLITE_API int sqlite3session_patchset(
   int *pnPatchset,                /* OUT: Size of buffer at *ppChangeset */
   void **ppPatchset               /* OUT: Buffer containing changeset */
 ){
+  if( pnPatchset==0 || ppPatchset==0 ) return SQLITE_MISUSE;
   return sessionGenerateChangeset(pSession, 1, 0, 0, pnPatchset, ppPatchset);
 }
 
@@ -205865,6 +211180,46 @@ SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession){
   return (ret==0);
 }
 
+/*
+** Return the amount of heap memory in use.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession){
+  return pSession->nMalloc;
+}
+
+/*
+** Configure the session object passed as the first argument.
+*/
+SQLITE_API int sqlite3session_object_config(sqlite3_session *pSession, int op, void *pArg){
+  int rc = SQLITE_OK;
+  switch( op ){
+    case SQLITE_SESSION_OBJCONFIG_SIZE: {
+      int iArg = *(int*)pArg;
+      if( iArg>=0 ){
+        if( pSession->pTable ){
+          rc = SQLITE_MISUSE;
+        }else{
+          pSession->bEnableSize = (iArg!=0);
+        }
+      }
+      *(int*)pArg = pSession->bEnableSize;
+      break;
+    }
+
+    default:
+      rc = SQLITE_MISUSE;
+  }
+
+  return rc;
+}
+
+/*
+** Return the maximum size of sqlite3session_changeset() output.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession){
+  return pSession->nMaxChangesetSize;
+}
+
 /*
 ** Do the work for either sqlite3changeset_start() or start_strm().
 */
@@ -205874,7 +211229,8 @@ static int sessionChangesetStart(
   void *pIn,
   int nChangeset,                 /* Size of buffer pChangeset in bytes */
   void *pChangeset,               /* Pointer to buffer containing changeset */
-  int bInvert                     /* True to invert changeset */
+  int bInvert,                    /* True to invert changeset */
+  int bSkipEmpty                  /* True to skip empty UPDATE changes */
 ){
   sqlite3_changeset_iter *pRet;   /* Iterator to return */
   int nByte;                      /* Number of bytes to allocate for iterator */
@@ -205895,6 +211251,7 @@ static int sessionChangesetStart(
   pRet->in.pIn = pIn;
   pRet->in.bEof = (xInput ? 0 : 1);
   pRet->bInvert = bInvert;
+  pRet->bSkipEmpty = bSkipEmpty;
 
   /* Populate the output variable and return success. */
   *pp = pRet;
@@ -205909,7 +211266,7 @@ SQLITE_API int sqlite3changeset_start(
   int nChangeset,                 /* Size of buffer pChangeset in bytes */
   void *pChangeset                /* Pointer to buffer containing changeset */
 ){
-  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0);
+  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0, 0);
 }
 SQLITE_API int sqlite3changeset_start_v2(
   sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
@@ -205918,7 +211275,7 @@ SQLITE_API int sqlite3changeset_start_v2(
   int flags
 ){
   int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
-  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert);
+  return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert, 0);
 }
 
 /*
@@ -205929,7 +211286,7 @@ SQLITE_API int sqlite3changeset_start_strm(
   int (*xInput)(void *pIn, void *pData, int *pnData),
   void *pIn
 ){
-  return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0);
+  return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0, 0);
 }
 SQLITE_API int sqlite3changeset_start_v2_strm(
   sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
@@ -205938,7 +211295,7 @@ SQLITE_API int sqlite3changeset_start_v2_strm(
   int flags
 ){
   int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
-  return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert);
+  return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert, 0);
 }
 
 /*
@@ -206064,11 +211421,14 @@ static int sessionReadRecord(
   SessionInput *pIn,              /* Input data */
   int nCol,                       /* Number of values in record */
   u8 *abPK,                       /* Array of primary key flags, or NULL */
-  sqlite3_value **apOut           /* Write values to this array */
+  sqlite3_value **apOut,          /* Write values to this array */
+  int *pbEmpty
 ){
   int i;                          /* Used to iterate through columns */
   int rc = SQLITE_OK;
 
+  assert( pbEmpty==0 || *pbEmpty==0 );
+  if( pbEmpty ) *pbEmpty = 1;
   for(i=0; i<nCol && rc==SQLITE_OK; i++){
     int eType = 0;                /* Type of value (SQLITE_NULL, TEXT etc.) */
     if( abPK && abPK[i]==0 ) continue;
@@ -206080,6 +211440,7 @@ static int sessionReadRecord(
         eType = pIn->aData[pIn->iNext++];
         assert( apOut[i]==0 );
         if( eType ){
+          if( pbEmpty ) *pbEmpty = 0;
           apOut[i] = sqlite3ValueNew(0);
           if( !apOut[i] ) rc = SQLITE_NOMEM;
         }
@@ -206259,31 +211620,27 @@ static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){
 }
 
 /*
-** Advance the changeset iterator to the next change.
+** Advance the changeset iterator to the next change. The differences between
+** this function and sessionChangesetNext() are that
 **
-** If both paRec and pnRec are NULL, then this function works like the public
-** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the
-** sqlite3changeset_new() and old() APIs may be used to query for values.
+**   * If pbEmpty is not NULL and the change is a no-op UPDATE (an UPDATE
+**     that modifies no columns), this function sets (*pbEmpty) to 1.
 **
-** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change
-** record is written to *paRec before returning and the number of bytes in
-** the record to *pnRec.
-**
-** Either way, this function returns SQLITE_ROW if the iterator is
-** successfully advanced to the next change in the changeset, an SQLite
-** error code if an error occurs, or SQLITE_DONE if there are no further
-** changes in the changeset.
+**   * If the iterator is configured to skip no-op UPDATEs,
+**     sessionChangesetNext() does that. This function does not.
 */
-static int sessionChangesetNext(
+static int sessionChangesetNextOne(
   sqlite3_changeset_iter *p,      /* Changeset iterator */
   u8 **paRec,                     /* If non-NULL, store record pointer here */
   int *pnRec,                     /* If non-NULL, store size of record here */
-  int *pbNew                      /* If non-NULL, true if new table */
+  int *pbNew,                     /* If non-NULL, true if new table */
+  int *pbEmpty
 ){
   int i;
   u8 op;
 
   assert( (paRec==0 && pnRec==0) || (paRec && pnRec) );
+  assert( pbEmpty==0 || *pbEmpty==0 );
 
   /* If the iterator is in the error-state, return immediately. */
   if( p->rc!=SQLITE_OK ) return p->rc;
@@ -206356,13 +211713,13 @@ static int sessionChangesetNext(
     /* If this is an UPDATE or DELETE, read the old.* record. */
     if( p->op!=SQLITE_INSERT && (p->bPatchset==0 || p->op==SQLITE_DELETE) ){
       u8 *abPK = p->bPatchset ? p->abPK : 0;
-      p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld);
+      p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
       if( p->rc!=SQLITE_OK ) return p->rc;
     }
 
     /* If this is an INSERT or UPDATE, read the new.* record. */
     if( p->op!=SQLITE_DELETE ){
-      p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew);
+      p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
       if( p->rc!=SQLITE_OK ) return p->rc;
     }
 
@@ -206389,6 +211746,37 @@ static int sessionChangesetNext(
   return SQLITE_ROW;
 }
 
+/*
+** Advance the changeset iterator to the next change.
+**
+** If both paRec and pnRec are NULL, then this function works like the public
+** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the
+** sqlite3changeset_new() and old() APIs may be used to query for values.
+**
+** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change
+** record is written to *paRec before returning and the number of bytes in
+** the record to *pnRec.
+**
+** Either way, this function returns SQLITE_ROW if the iterator is
+** successfully advanced to the next change in the changeset, an SQLite
+** error code if an error occurs, or SQLITE_DONE if there are no further
+** changes in the changeset.
+*/
+static int sessionChangesetNext(
+  sqlite3_changeset_iter *p,      /* Changeset iterator */
+  u8 **paRec,                     /* If non-NULL, store record pointer here */
+  int *pnRec,                     /* If non-NULL, store size of record here */
+  int *pbNew                      /* If non-NULL, true if new table */
+){
+  int bEmpty;
+  int rc;
+  do {
+    bEmpty = 0;
+    rc = sessionChangesetNextOne(p, paRec, pnRec, pbNew, &bEmpty);
+  }while( rc==SQLITE_ROW && p->bSkipEmpty && bEmpty);
+  return rc;
+}
+
 /*
 ** Advance an iterator created by sqlite3changeset_start() to the next
 ** change in the changeset. This function may return SQLITE_ROW, SQLITE_DONE
@@ -206661,9 +212049,9 @@ static int sessionChangesetInvert(
 
         /* Read the old.* and new.* records for the update change. */
         pInput->iNext += 2;
-        rc = sessionReadRecord(pInput, nCol, 0, &apVal[0]);
+        rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
         if( rc==SQLITE_OK ){
-          rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol]);
+          rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
         }
 
         /* Write the new old.* record. Consists of the PK columns from the
@@ -206707,11 +212095,11 @@ static int sessionChangesetInvert(
   }
 
   assert( rc==SQLITE_OK );
-  if( pnInverted ){
+  if( pnInverted && ALWAYS(ppInverted) ){
     *pnInverted = sOut.nBuf;
     *ppInverted = sOut.aBuf;
     sOut.aBuf = 0;
-  }else if( sOut.nBuf>0 ){
+  }else if( sOut.nBuf>0 && ALWAYS(xOutput!=0) ){
     rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
   }
 
@@ -206764,16 +212152,25 @@ SQLITE_API int sqlite3changeset_invert_strm(
   return rc;
 }
 
+
+typedef struct SessionUpdate SessionUpdate;
+struct SessionUpdate {
+  sqlite3_stmt *pStmt;
+  u32 *aMask;
+  SessionUpdate *pNext;
+};
+
 typedef struct SessionApplyCtx SessionApplyCtx;
 struct SessionApplyCtx {
   sqlite3 *db;
   sqlite3_stmt *pDelete;          /* DELETE statement */
-  sqlite3_stmt *pUpdate;          /* UPDATE statement */
   sqlite3_stmt *pInsert;          /* INSERT statement */
   sqlite3_stmt *pSelect;          /* SELECT statement */
   int nCol;                       /* Size of azCol[] and abPK[] arrays */
   const char **azCol;             /* Array of column names */
   u8 *abPK;                       /* Boolean array - true if column is in PK */
+  u32 *aUpdateMask;               /* Used by sessionUpdateFind */
+  SessionUpdate *pUp;
   int bStat1;                     /* True if table is sqlite_stat1 */
   int bDeferConstraints;          /* True to defer constraints */
   int bInvertConstraints;         /* Invert when iterating constraints buffer */
@@ -206783,6 +212180,167 @@ struct SessionApplyCtx {
   u8 bRebase;                     /* True to collect rebase information */
 };
 
+/* Number of prepared UPDATE statements to cache. */
+#define SESSION_UPDATE_CACHE_SZ 12
+
+/*
+** Find a prepared UPDATE statement suitable for the UPDATE step currently
+** being visited by the iterator. The UPDATE is of the form:
+**
+**   UPDATE tbl SET col = ?, col2 = ? WHERE pk1 IS ? AND pk2 IS ?
+*/
+static int sessionUpdateFind(
+  sqlite3_changeset_iter *pIter,
+  SessionApplyCtx *p,
+  int bPatchset,
+  sqlite3_stmt **ppStmt
+){
+  int rc = SQLITE_OK;
+  SessionUpdate *pUp = 0;
+  int nCol = pIter->nCol;
+  int nU32 = (pIter->nCol+33)/32;
+  int ii;
+
+  if( p->aUpdateMask==0 ){
+    p->aUpdateMask = sqlite3_malloc(nU32*sizeof(u32));
+    if( p->aUpdateMask==0 ){
+      rc = SQLITE_NOMEM;
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    memset(p->aUpdateMask, 0, nU32*sizeof(u32));
+    rc = SQLITE_CORRUPT;
+    for(ii=0; ii<pIter->nCol; ii++){
+      if( sessionChangesetNew(pIter, ii) ){
+        p->aUpdateMask[ii/32] |= (1<<(ii%32));
+        rc = SQLITE_OK;
+      }
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
+
+    if( p->pUp ){
+      int nUp = 0;
+      SessionUpdate **pp = &p->pUp;
+      while( 1 ){
+        nUp++;
+        if( 0==memcmp(p->aUpdateMask, (*pp)->aMask, nU32*sizeof(u32)) ){
+          pUp = *pp;
+          *pp = pUp->pNext;
+          pUp->pNext = p->pUp;
+          p->pUp = pUp;
+          break;
+        }
+
+        if( (*pp)->pNext ){
+          pp = &(*pp)->pNext;
+        }else{
+          if( nUp>=SESSION_UPDATE_CACHE_SZ ){
+            sqlite3_finalize((*pp)->pStmt);
+            sqlite3_free(*pp);
+            *pp = 0;
+          }
+          break;
+        }
+      }
+    }
+
+    if( pUp==0 ){
+      int nByte = sizeof(SessionUpdate) * nU32*sizeof(u32);
+      int bStat1 = (sqlite3_stricmp(pIter->zTab, "sqlite_stat1")==0);
+      pUp = (SessionUpdate*)sqlite3_malloc(nByte);
+      if( pUp==0 ){
+        rc = SQLITE_NOMEM;
+      }else{
+        const char *zSep = "";
+        SessionBuffer buf;
+
+        memset(&buf, 0, sizeof(buf));
+        pUp->aMask = (u32*)&pUp[1];
+        memcpy(pUp->aMask, p->aUpdateMask, nU32*sizeof(u32));
+
+        sessionAppendStr(&buf, "UPDATE main.", &rc);
+        sessionAppendIdent(&buf, pIter->zTab, &rc);
+        sessionAppendStr(&buf, " SET ", &rc);
+
+        /* Create the assignments part of the UPDATE */
+        for(ii=0; ii<pIter->nCol; ii++){
+          if( p->abPK[ii]==0 && sessionChangesetNew(pIter, ii) ){
+            sessionAppendStr(&buf, zSep, &rc);
+            sessionAppendIdent(&buf, p->azCol[ii], &rc);
+            sessionAppendStr(&buf, " = ?", &rc);
+            sessionAppendInteger(&buf, ii*2+1, &rc);
+            zSep = ", ";
+          }
+        }
+
+        /* Create the WHERE clause part of the UPDATE */
+        zSep = "";
+        sessionAppendStr(&buf, " WHERE ", &rc);
+        for(ii=0; ii<pIter->nCol; ii++){
+          if( p->abPK[ii] || (bPatchset==0 && sessionChangesetOld(pIter, ii)) ){
+            sessionAppendStr(&buf, zSep, &rc);
+            if( bStat1 && ii==1 ){
+              assert( sqlite3_stricmp(p->azCol[ii], "idx")==0 );
+              sessionAppendStr(&buf,
+                  "idx IS CASE "
+                  "WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL "
+                  "ELSE ?4 END ", &rc
+              );
+            }else{
+              sessionAppendIdent(&buf, p->azCol[ii], &rc);
+              sessionAppendStr(&buf, " IS ?", &rc);
+              sessionAppendInteger(&buf, ii*2+2, &rc);
+            }
+            zSep = " AND ";
+          }
+        }
+
+        if( rc==SQLITE_OK ){
+          char *zSql = (char*)buf.aBuf;
+          rc = sqlite3_prepare_v2(p->db, zSql, buf.nBuf, &pUp->pStmt, 0);
+        }
+
+        if( rc!=SQLITE_OK ){
+          sqlite3_free(pUp);
+          pUp = 0;
+        }else{
+          pUp->pNext = p->pUp;
+          p->pUp = pUp;
+        }
+        sqlite3_free(buf.aBuf);
+      }
+    }
+  }
+
+  assert( (rc==SQLITE_OK)==(pUp!=0) );
+  if( pUp ){
+    *ppStmt = pUp->pStmt;
+  }else{
+    *ppStmt = 0;
+  }
+  return rc;
+}
+
+/*
+** Free all cached UPDATE statements.
+*/
+static void sessionUpdateFree(SessionApplyCtx *p){
+  SessionUpdate *pUp;
+  SessionUpdate *pNext;
+  for(pUp=p->pUp; pUp; pUp=pNext){
+    pNext = pUp->pNext;
+    sqlite3_finalize(pUp->pStmt);
+    sqlite3_free(pUp);
+  }
+  p->pUp = 0;
+  sqlite3_free(p->aUpdateMask);
+  p->aUpdateMask = 0;
+}
+
 /*
 ** Formulate a statement to DELETE a row from database db. Assuming a table
 ** structure like this:
@@ -206852,103 +212410,6 @@ static int sessionDeleteRow(
   return rc;
 }
 
-/*
-** Formulate and prepare a statement to UPDATE a row from database db.
-** Assuming a table structure like this:
-**
-**     CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
-**
-** The UPDATE statement looks like this:
-**
-**     UPDATE x SET
-**     a = CASE WHEN ?2  THEN ?3  ELSE a END,
-**     b = CASE WHEN ?5  THEN ?6  ELSE b END,
-**     c = CASE WHEN ?8  THEN ?9  ELSE c END,
-**     d = CASE WHEN ?11 THEN ?12 ELSE d END
-**     WHERE a = ?1 AND c = ?7 AND (?13 OR
-**       (?5==0 OR b IS ?4) AND (?11==0 OR d IS ?10) AND
-**     )
-**
-** For each column in the table, there are three variables to bind:
-**
-**     ?(i*3+1)    The old.* value of the column, if any.
-**     ?(i*3+2)    A boolean flag indicating that the value is being modified.
-**     ?(i*3+3)    The new.* value of the column, if any.
-**
-** Also, a boolean flag that, if set to true, causes the statement to update
-** a row even if the non-PK values do not match. This is required if the
-** conflict-handler is invoked with CHANGESET_DATA and returns
-** CHANGESET_REPLACE. This is variable "?(nCol*3+1)".
-**
-** If successful, SQLITE_OK is returned and SessionApplyCtx.pUpdate is left
-** pointing to the prepared version of the SQL statement.
-*/
-static int sessionUpdateRow(
-  sqlite3 *db,                    /* Database handle */
-  const char *zTab,               /* Table name */
-  SessionApplyCtx *p              /* Session changeset-apply context */
-){
-  int rc = SQLITE_OK;
-  int i;
-  const char *zSep = "";
-  SessionBuffer buf = {0, 0, 0};
-
-  /* Append "UPDATE tbl SET " */
-  sessionAppendStr(&buf, "UPDATE main.", &rc);
-  sessionAppendIdent(&buf, zTab, &rc);
-  sessionAppendStr(&buf, " SET ", &rc);
-
-  /* Append the assignments */
-  for(i=0; i<p->nCol; i++){
-    sessionAppendStr(&buf, zSep, &rc);
-    sessionAppendIdent(&buf, p->azCol[i], &rc);
-    sessionAppendStr(&buf, " = CASE WHEN ?", &rc);
-    sessionAppendInteger(&buf, i*3+2, &rc);
-    sessionAppendStr(&buf, " THEN ?", &rc);
-    sessionAppendInteger(&buf, i*3+3, &rc);
-    sessionAppendStr(&buf, " ELSE ", &rc);
-    sessionAppendIdent(&buf, p->azCol[i], &rc);
-    sessionAppendStr(&buf, " END", &rc);
-    zSep = ", ";
-  }
-
-  /* Append the PK part of the WHERE clause */
-  sessionAppendStr(&buf, " WHERE ", &rc);
-  for(i=0; i<p->nCol; i++){
-    if( p->abPK[i] ){
-      sessionAppendIdent(&buf, p->azCol[i], &rc);
-      sessionAppendStr(&buf, " = ?", &rc);
-      sessionAppendInteger(&buf, i*3+1, &rc);
-      sessionAppendStr(&buf, " AND ", &rc);
-    }
-  }
-
-  /* Append the non-PK part of the WHERE clause */
-  sessionAppendStr(&buf, " (?", &rc);
-  sessionAppendInteger(&buf, p->nCol*3+1, &rc);
-  sessionAppendStr(&buf, " OR 1", &rc);
-  for(i=0; i<p->nCol; i++){
-    if( !p->abPK[i] ){
-      sessionAppendStr(&buf, " AND (?", &rc);
-      sessionAppendInteger(&buf, i*3+2, &rc);
-      sessionAppendStr(&buf, "=0 OR ", &rc);
-      sessionAppendIdent(&buf, p->azCol[i], &rc);
-      sessionAppendStr(&buf, " IS ?", &rc);
-      sessionAppendInteger(&buf, i*3+1, &rc);
-      sessionAppendStr(&buf, ")", &rc);
-    }
-  }
-  sessionAppendStr(&buf, ")", &rc);
-
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, &p->pUpdate, 0);
-  }
-  sqlite3_free(buf.aBuf);
-
-  return rc;
-}
-
-
 /*
 ** Formulate and prepare an SQL statement to query table zTab by primary
 ** key. Assuming the following table structure:
@@ -207029,17 +212490,6 @@ static int sessionStat1Sql(sqlite3 *db, SessionApplyCtx *p){
         "?3)"
     );
   }
-  if( rc==SQLITE_OK ){
-    rc = sessionPrepare(db, &p->pUpdate,
-        "UPDATE main.sqlite_stat1 SET "
-        "tbl = CASE WHEN ?2 THEN ?3 ELSE tbl END, "
-        "idx = CASE WHEN ?5 THEN ?6 ELSE idx END, "
-        "stat = CASE WHEN ?8 THEN ?9 ELSE stat END  "
-        "WHERE tbl=?1 AND idx IS "
-        "CASE WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL ELSE ?4 END "
-        "AND (?10 OR ?8=0 OR stat IS ?7)"
-    );
-  }
   if( rc==SQLITE_OK ){
     rc = sessionPrepare(db, &p->pDelete,
         "DELETE FROM main.sqlite_stat1 WHERE tbl=?1 AND idx IS "
@@ -207105,7 +212555,7 @@ static int sessionBindRow(
 
   for(i=0; rc==SQLITE_OK && i<nCol; i++){
     if( !abPK || abPK[i] ){
-      sqlite3_value *pVal;
+      sqlite3_value *pVal = 0;
       (void)xValue(pIter, i, &pVal);
       if( pVal==0 ){
         /* The value in the changeset was "undefined". This indicates a
@@ -207356,7 +212806,7 @@ static int sessionApplyOneOp(
   int nCol;
   int rc = SQLITE_OK;
 
-  assert( p->pDelete && p->pUpdate && p->pInsert && p->pSelect );
+  assert( p->pDelete && p->pInsert && p->pSelect );
   assert( p->azCol && p->abPK );
   assert( !pbReplace || *pbReplace==0 );
 
@@ -207396,29 +212846,28 @@ static int sessionApplyOneOp(
 
   }else if( op==SQLITE_UPDATE ){
     int i;
+    sqlite3_stmt *pUp = 0;
+    int bPatchset = (pbRetry==0 || pIter->bPatchset);
+
+    rc = sessionUpdateFind(pIter, p, bPatchset, &pUp);
 
     /* Bind values to the UPDATE statement. */
     for(i=0; rc==SQLITE_OK && i<nCol; i++){
       sqlite3_value *pOld = sessionChangesetOld(pIter, i);
       sqlite3_value *pNew = sessionChangesetNew(pIter, i);
-
-      sqlite3_bind_int(p->pUpdate, i*3+2, !!pNew);
-      if( pOld ){
-        rc = sessionBindValue(p->pUpdate, i*3+1, pOld);
+      if( p->abPK[i] || (bPatchset==0 && pOld) ){
+        rc = sessionBindValue(pUp, i*2+2, pOld);
       }
       if( rc==SQLITE_OK && pNew ){
-        rc = sessionBindValue(p->pUpdate, i*3+3, pNew);
+        rc = sessionBindValue(pUp, i*2+1, pNew);
       }
     }
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset);
-    }
     if( rc!=SQLITE_OK ) return rc;
 
     /* Attempt the UPDATE. In the case of a NOTFOUND or DATA conflict,
     ** the result will be SQLITE_OK with 0 rows modified. */
-    sqlite3_step(p->pUpdate);
-    rc = sqlite3_reset(p->pUpdate);
+    sqlite3_step(pUp);
+    rc = sqlite3_reset(pUp);
 
     if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
       /* A NOTFOUND or DATA error. Search the table to see if it contains
@@ -207550,7 +212999,7 @@ static int sessionRetryConstraints(
     memset(&pApply->constraints, 0, sizeof(SessionBuffer));
 
     rc = sessionChangesetStart(
-        &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints
+        &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints, 1
     );
     if( rc==SQLITE_OK ){
       size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
@@ -207641,14 +213090,13 @@ static int sessionChangesetApply(
       );
       if( rc!=SQLITE_OK ) break;
 
+      sessionUpdateFree(&sApply);
       sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
       sqlite3_finalize(sApply.pDelete);
-      sqlite3_finalize(sApply.pUpdate);
       sqlite3_finalize(sApply.pInsert);
       sqlite3_finalize(sApply.pSelect);
       sApply.db = db;
       sApply.pDelete = 0;
-      sApply.pUpdate = 0;
       sApply.pInsert = 0;
       sApply.pSelect = 0;
       sApply.nCol = 0;
@@ -207676,7 +213124,7 @@ static int sessionChangesetApply(
         int i;
 
         sqlite3changeset_pk(pIter, &abPK, 0);
-        rc = sessionTableInfo(
+        rc = sessionTableInfo(0,
             db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
         );
         if( rc!=SQLITE_OK ) break;
@@ -207712,11 +213160,10 @@ static int sessionChangesetApply(
             }
             sApply.bStat1 = 1;
           }else{
-            if((rc = sessionSelectRow(db, zTab, &sApply))
-                || (rc = sessionUpdateRow(db, zTab, &sApply))
-                || (rc = sessionDeleteRow(db, zTab, &sApply))
-                || (rc = sessionInsertRow(db, zTab, &sApply))
-              ){
+            if( (rc = sessionSelectRow(db, zTab, &sApply))
+             || (rc = sessionDeleteRow(db, zTab, &sApply))
+             || (rc = sessionInsertRow(db, zTab, &sApply))
+            ){
               break;
             }
             sApply.bStat1 = 0;
@@ -207775,9 +213222,9 @@ static int sessionChangesetApply(
     *pnRebase = sApply.rebase.nBuf;
     sApply.rebase.aBuf = 0;
   }
+  sessionUpdateFree(&sApply);
   sqlite3_finalize(sApply.pInsert);
   sqlite3_finalize(sApply.pDelete);
-  sqlite3_finalize(sApply.pUpdate);
   sqlite3_finalize(sApply.pSelect);
   sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
   sqlite3_free((char*)sApply.constraints.aBuf);
@@ -207808,8 +213255,8 @@ SQLITE_API int sqlite3changeset_apply_v2(
   int flags
 ){
   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
-  int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
-  int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset,bInverse);
+  int bInv = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
+  int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
   if( rc==SQLITE_OK ){
     rc = sessionChangesetApply(
         db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
@@ -207867,7 +213314,7 @@ SQLITE_API int sqlite3changeset_apply_v2_strm(
 ){
   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
   int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
-  int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse);
+  int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
   if( rc==SQLITE_OK ){
     rc = sessionChangesetApply(
         db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
@@ -208155,7 +213602,7 @@ static int sessionChangesetToHash(
       }
     }
 
-    if( sessionGrowHash(pIter->bPatchset, pTab) ){
+    if( sessionGrowHash(0, pIter->bPatchset, pTab) ){
       rc = SQLITE_NOMEM;
       break;
     }
@@ -208251,9 +213698,9 @@ static int sessionChangegroupOutput(
   if( rc==SQLITE_OK ){
     if( xOutput ){
       if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
-    }else{
+    }else if( ppOut ){
       *ppOut = buf.aBuf;
-      *pnOut = buf.nBuf;
+      if( pnOut ) *pnOut = buf.nBuf;
       buf.aBuf = 0;
     }
   }
@@ -208341,7 +213788,7 @@ SQLITE_API int sqlite3changegroup_output_strm(
 */
 SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup *pGrp){
   if( pGrp ){
-    sessionDeleteTable(pGrp->pList);
+    sessionDeleteTable(0, pGrp->pList);
     sqlite3_free(pGrp);
   }
 }
@@ -208487,7 +213934,7 @@ static void sessionAppendPartialUpdate(
       int n1 = sessionSerialLen(a1);
       int n2 = sessionSerialLen(a2);
       if( pIter->abPK[i] || a2[0]==0 ){
-        if( !pIter->abPK[i] ) bData = 1;
+        if( !pIter->abPK[i] && a1[0] ) bData = 1;
         memcpy(pOut, a1, n1);
         pOut += n1;
       }else if( a2[0]!=0xFF ){
@@ -208653,7 +214100,7 @@ static int sessionRebase(
       if( sOut.nBuf>0 ){
         rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
       }
-    }else{
+    }else if( ppOut ){
       *ppOut = (void*)sOut.aBuf;
       *pnOut = sOut.nBuf;
       sOut.aBuf = 0;
@@ -208742,7 +214189,7 @@ SQLITE_API int sqlite3rebaser_rebase_strm(
 */
 SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){
   if( p ){
-    sessionDeleteTable(p->grp.pList);
+    sessionDeleteTable(0, p->grp.pList);
     sqlite3_free(p);
   }
 }
@@ -209396,8 +214843,20 @@ typedef sqlite3_uint64 u64;
 #endif
 
 #define testcase(x)
-#define ALWAYS(x) 1
-#define NEVER(x) 0
+
+#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
+# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
+#endif
+#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
+# define ALWAYS(X)      (1)
+# define NEVER(X)       (0)
+#elif !defined(NDEBUG)
+# define ALWAYS(X)      ((X)?1:(assert(0),0))
+# define NEVER(X)       ((X)?(assert(0),1):0)
+#else
+# define ALWAYS(X)      (X)
+# define NEVER(X)       (X)
+#endif
 
 #define MIN(x,y) (((x) < (y)) ? (x) : (y))
 #define MAX(x,y) (((x) > (y)) ? (x) : (y))
@@ -209457,7 +214916,7 @@ SQLITE_API extern int sqlite3_fts5_may_be_corrupt;
 ** A version of memcmp() that does not cause asan errors if one of the pointer
 ** parameters is NULL and the number of bytes to compare is zero.
 */
-#define fts5Memcmp(s1, s2, n) ((n)==0 ? 0 : memcmp((s1), (s2), (n)))
+#define fts5Memcmp(s1, s2, n) ((n)<=0 ? 0 : memcmp((s1), (s2), (n)))
 
 /* Mark a function parameter as unused, to suppress nuisance compiler
 ** warnings. */
@@ -209796,6 +215255,9 @@ static void sqlite3Fts5IndexCloseReader(Fts5Index*);
 */
 static const char *sqlite3Fts5IterTerm(Fts5IndexIter*, int*);
 static int sqlite3Fts5IterNextScan(Fts5IndexIter*);
+static void *sqlite3Fts5StructureRef(Fts5Index*);
+static void sqlite3Fts5StructureRelease(void*);
+static int sqlite3Fts5StructureTest(Fts5Index*, void*);
 
 
 /*
@@ -210573,9 +216035,9 @@ struct fts5yyParser {
 };
 typedef struct fts5yyParser fts5yyParser;
 
+/* #include <assert.h> */
 #ifndef NDEBUG
 /* #include <stdio.h> */
-/* #include <assert.h> */
 static FILE *fts5yyTraceFILE = 0;
 static char *fts5yyTracePrompt = 0;
 #endif /* NDEBUG */
@@ -211204,55 +216666,6 @@ static fts5YYACTIONTYPE fts5yy_reduce(
   (void)fts5yyLookahead;
   (void)fts5yyLookaheadToken;
   fts5yymsp = fts5yypParser->fts5yytos;
-  assert( fts5yyruleno<(int)(sizeof(fts5yyRuleName)/sizeof(fts5yyRuleName[0])) );
-#ifndef NDEBUG
-  if( fts5yyTraceFILE ){
-    fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno];
-    if( fts5yysize ){
-      fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
-        fts5yyTracePrompt,
-        fts5yyruleno, fts5yyRuleName[fts5yyruleno],
-        fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action",
-        fts5yymsp[fts5yysize].stateno);
-    }else{
-      fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s.\n",
-        fts5yyTracePrompt, fts5yyruleno, fts5yyRuleName[fts5yyruleno],
-        fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action");
-    }
-  }
-#endif /* NDEBUG */
-
-  /* Check that the stack is large enough to grow by a single entry
-  ** if the RHS of the rule is empty.  This ensures that there is room
-  ** enough on the stack to push the LHS value */
-  if( fts5yyRuleInfoNRhs[fts5yyruleno]==0 ){
-#ifdef fts5YYTRACKMAXSTACKDEPTH
-    if( (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){
-      fts5yypParser->fts5yyhwm++;
-      assert( fts5yypParser->fts5yyhwm == (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack));
-    }
-#endif
-#if fts5YYSTACKDEPTH>0
-    if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){
-      fts5yyStackOverflow(fts5yypParser);
-      /* The call to fts5yyStackOverflow() above pops the stack until it is
-      ** empty, causing the main parser loop to exit.  So the return value
-      ** is never used and does not matter. */
-      return 0;
-    }
-#else
-    if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz-1] ){
-      if( fts5yyGrowStack(fts5yypParser) ){
-        fts5yyStackOverflow(fts5yypParser);
-        /* The call to fts5yyStackOverflow() above pops the stack until it is
-        ** empty, causing the main parser loop to exit.  So the return value
-        ** is never used and does not matter. */
-        return 0;
-      }
-      fts5yymsp = fts5yypParser->fts5yytos;
-    }
-#endif
-  }
 
   switch( fts5yyruleno ){
   /* Beginning here are the reduction cases.  A typical example
@@ -211555,12 +216968,56 @@ static void sqlite3Fts5Parser(
   }
 #endif
 
-  do{
+  while(1){ /* Exit by "break" */
+    assert( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystack );
     assert( fts5yyact==fts5yypParser->fts5yytos->stateno );
     fts5yyact = fts5yy_find_shift_action((fts5YYCODETYPE)fts5yymajor,fts5yyact);
     if( fts5yyact >= fts5YY_MIN_REDUCE ){
-      fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyact-fts5YY_MIN_REDUCE,fts5yymajor,
-                        fts5yyminor sqlite3Fts5ParserCTX_PARAM);
+      unsigned int fts5yyruleno = fts5yyact - fts5YY_MIN_REDUCE; /* Reduce by this rule */
+#ifndef NDEBUG
+      assert( fts5yyruleno<(int)(sizeof(fts5yyRuleName)/sizeof(fts5yyRuleName[0])) );
+      if( fts5yyTraceFILE ){
+        int fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno];
+        if( fts5yysize ){
+          fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
+            fts5yyTracePrompt,
+            fts5yyruleno, fts5yyRuleName[fts5yyruleno],
+            fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action",
+            fts5yypParser->fts5yytos[fts5yysize].stateno);
+        }else{
+          fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s.\n",
+            fts5yyTracePrompt, fts5yyruleno, fts5yyRuleName[fts5yyruleno],
+            fts5yyruleno<fts5YYNRULE_WITH_ACTION ? "" : " without external action");
+        }
+      }
+#endif /* NDEBUG */
+
+      /* Check that the stack is large enough to grow by a single entry
+      ** if the RHS of the rule is empty.  This ensures that there is room
+      ** enough on the stack to push the LHS value */
+      if( fts5yyRuleInfoNRhs[fts5yyruleno]==0 ){
+#ifdef fts5YYTRACKMAXSTACKDEPTH
+        if( (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack)>fts5yypParser->fts5yyhwm ){
+          fts5yypParser->fts5yyhwm++;
+          assert( fts5yypParser->fts5yyhwm ==
+                  (int)(fts5yypParser->fts5yytos - fts5yypParser->fts5yystack));
+        }
+#endif
+#if fts5YYSTACKDEPTH>0
+        if( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystackEnd ){
+          fts5yyStackOverflow(fts5yypParser);
+          break;
+        }
+#else
+        if( fts5yypParser->fts5yytos>=&fts5yypParser->fts5yystack[fts5yypParser->fts5yystksz-1] ){
+          if( fts5yyGrowStack(fts5yypParser) ){
+            fts5yyStackOverflow(fts5yypParser);
+            break;
+          }
+        }
+#endif
+      }
+      fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyruleno,fts5yymajor,fts5yyminor sqlite3Fts5ParserCTX_PARAM);
     }else if( fts5yyact <= fts5YY_MAX_SHIFTREDUCE ){
       fts5yy_shift(fts5yypParser,fts5yyact,(fts5YYCODETYPE)fts5yymajor,fts5yyminor);
 #ifndef fts5YYNOERRORRECOVERY
@@ -211616,14 +217073,13 @@ static void sqlite3Fts5Parser(
         fts5yy_destructor(fts5yypParser, (fts5YYCODETYPE)fts5yymajor, &fts5yyminorunion);
         fts5yymajor = fts5YYNOCODE;
       }else{
-        while( fts5yypParser->fts5yytos >= fts5yypParser->fts5yystack
-            && (fts5yyact = fts5yy_find_reduce_action(
-                        fts5yypParser->fts5yytos->stateno,
-                        fts5YYERRORSYMBOL)) > fts5YY_MAX_SHIFTREDUCE
-        ){
+        while( fts5yypParser->fts5yytos > fts5yypParser->fts5yystack ){
+          fts5yyact = fts5yy_find_reduce_action(fts5yypParser->fts5yytos->stateno,
+                                        fts5YYERRORSYMBOL);
+          if( fts5yyact<=fts5YY_MAX_SHIFTREDUCE ) break;
           fts5yy_pop_parser_stack(fts5yypParser);
         }
-        if( fts5yypParser->fts5yytos < fts5yypParser->fts5yystack || fts5yymajor==0 ){
+        if( fts5yypParser->fts5yytos <= fts5yypParser->fts5yystack || fts5yymajor==0 ){
           fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
           fts5yy_parse_failed(fts5yypParser);
 #ifndef fts5YYNOERRORRECOVERY
@@ -211673,7 +217129,7 @@ static void sqlite3Fts5Parser(
       break;
 #endif
     }
-  }while( fts5yypParser->fts5yytos>fts5yypParser->fts5yystack );
+  }
 #ifndef NDEBUG
   if( fts5yyTraceFILE ){
     fts5yyStackEntry *i;
@@ -212486,7 +217942,6 @@ static void sqlite3Fts5BufferAppendBlob(
   u32 nData,
   const u8 *pData
 ){
-  assert_nc( *pRc || nData>=0 );
   if( nData ){
     if( fts5BufferGrow(pRc, pBuf, nData) ) return;
     memcpy(&pBuf->p[pBuf->n], pData, nData);
@@ -212596,7 +218051,7 @@ static int sqlite3Fts5PoslistNext64(
     return 1;
   }else{
     i64 iOff = *piOff;
-    int iVal;
+    u32 iVal;
     fts5FastGetVarint32(a, i, iVal);
     if( iVal<=1 ){
       if( iVal==0 ){
@@ -212605,15 +218060,19 @@ static int sqlite3Fts5PoslistNext64(
       }
       fts5FastGetVarint32(a, i, iVal);
       iOff = ((i64)iVal) << 32;
+      assert( iOff>=0 );
       fts5FastGetVarint32(a, i, iVal);
       if( iVal<2 ){
         /* This is a corrupt record. So stop parsing it here. */
         *piOff = -1;
         return 1;
       }
+      *piOff = iOff + ((iVal-2) & 0x7FFFFFFF);
+    }else{
+      *piOff = (iOff & (i64)0x7FFFFFFF<<32)+((iOff + (iVal-2)) & 0x7FFFFFFF);
     }
-    *piOff = iOff + ((iVal-2) & 0x7FFFFFFF);
     *pi = i;
+    assert_nc( *piOff>=iOff );
     return 0;
   }
 }
@@ -212652,14 +218111,16 @@ static void sqlite3Fts5PoslistSafeAppend(
   i64 *piPrev,
   i64 iPos
 ){
-  static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
-  if( (iPos & colmask) != (*piPrev & colmask) ){
-    pBuf->p[pBuf->n++] = 1;
-    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
-    *piPrev = (iPos & colmask);
+  if( iPos>=*piPrev ){
+    static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
+    if( (iPos & colmask) != (*piPrev & colmask) ){
+      pBuf->p[pBuf->n++] = 1;
+      pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
+      *piPrev = (iPos & colmask);
+    }
+    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
+    *piPrev = iPos;
   }
-  pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
-  *piPrev = iPos;
 }
 
 static int sqlite3Fts5PoslistWriterAppend(
@@ -213361,7 +218822,7 @@ static int sqlite3Fts5ConfigParse(
 
   nByte = nArg * (sizeof(char*) + sizeof(u8));
   pRet->azCol = (char**)sqlite3Fts5MallocZero(&rc, nByte);
-  pRet->abUnindexed = (u8*)&pRet->azCol[nArg];
+  pRet->abUnindexed = pRet->azCol ? (u8*)&pRet->azCol[nArg] : 0;
   pRet->zDb = sqlite3Fts5Strndup(&rc, azArg[1], -1);
   pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
   pRet->bColumnsize = 1;
@@ -213386,6 +218847,7 @@ static int sqlite3Fts5ConfigParse(
     z = fts5ConfigSkipWhitespace(z);
     if( z && *z=='=' ){
       bOption = 1;
+      assert( zOne!=0 );
       z++;
       if( bMustBeCol ) z = 0;
     }
@@ -213402,7 +218864,11 @@ static int sqlite3Fts5ConfigParse(
         rc = SQLITE_ERROR;
       }else{
         if( bOption ){
-          rc = fts5ConfigParseSpecial(pGlobal, pRet, zOne, zTwo?zTwo:"", pzErr);
+          rc = fts5ConfigParseSpecial(pGlobal, pRet,
+            ALWAYS(zOne)?zOne:"",
+            zTwo?zTwo:"",
+            pzErr
+          );
         }else{
           rc = fts5ConfigParseColumn(pRet, zOne, zTwo, pzErr);
           zOne = 0;
@@ -213920,6 +219386,7 @@ static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...){
   va_list ap;
   va_start(ap, zFmt);
   if( pParse->rc==SQLITE_OK ){
+    assert( pParse->zErr==0 );
     pParse->zErr = sqlite3_vmprintf(zFmt, ap);
     pParse->rc = SQLITE_ERROR;
   }
@@ -214218,6 +219685,7 @@ static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){
   int bRetValid = 0;
   Fts5ExprTerm *p;
 
+  assert( pTerm );
   assert( pTerm->pSynonym );
   assert( bDesc==0 || bDesc==1 );
   for(p=pTerm; p; p=p->pSynonym){
@@ -215285,8 +220753,8 @@ static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bD
   }
 
   /* If the iterator is not at a real match, skip forward until it is. */
-  while( pRoot->bNomatch ){
-    assert( pRoot->bEof==0 && rc==SQLITE_OK );
+  while( pRoot->bNomatch && rc==SQLITE_OK ){
+    assert( pRoot->bEof==0 );
     rc = fts5ExprNodeNext(p, pRoot, 0, 0);
   }
   return rc;
@@ -215658,7 +221126,7 @@ static int sqlite3Fts5ExprClonePhrase(
     sCtx.pPhrase = sqlite3Fts5MallocZero(&rc, sizeof(Fts5ExprPhrase));
   }
 
-  if( rc==SQLITE_OK ){
+  if( rc==SQLITE_OK && ALWAYS(sCtx.pPhrase) ){
     /* All the allocations succeeded. Put the expression object together. */
     pNew->pIndex = pExpr->pIndex;
     pNew->pConfig = pExpr->pConfig;
@@ -215929,9 +221397,8 @@ static void sqlite3Fts5ParseSetColset(
 ){
   Fts5Colset *pFree = pColset;
   if( pParse->pConfig->eDetail==FTS5_DETAIL_NONE ){
-    pParse->rc = SQLITE_ERROR;
-    pParse->zErr = sqlite3_mprintf(
-      "fts5: column queries are not supported (detail=none)"
+    sqlite3Fts5ParseError(pParse,
+        "fts5: column queries are not supported (detail=none)"
     );
   }else{
     fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
@@ -216105,13 +221572,10 @@ static Fts5ExprNode *sqlite3Fts5ParseNode(
                 || pPhrase->nTerm>1
                 || (pPhrase->nTerm>0 && pPhrase->aTerm[0].bFirst)
               ){
-              assert( pParse->rc==SQLITE_OK );
-              pParse->rc = SQLITE_ERROR;
-              assert( pParse->zErr==0 );
-              pParse->zErr = sqlite3_mprintf(
+              sqlite3Fts5ParseError(pParse,
                   "fts5: %s queries are not supported (detail!=full)",
                   pNear->nPhrase==1 ? "phrase": "NEAR"
-                  );
+              );
               sqlite3_free(pRet);
               pRet = 0;
             }
@@ -216197,6 +221661,7 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
   return pRet;
 }
 
+#ifdef SQLITE_TEST
 static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){
   sqlite3_int64 nByte = 0;
   Fts5ExprTerm *p;
@@ -216563,12 +222028,14 @@ static void fts5ExprFold(
     sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics));
   }
 }
+#endif /* ifdef SQLITE_TEST */
 
 /*
 ** This is called during initialization to register the fts5_expr() scalar
 ** UDF with the SQLite handle passed as the only argument.
 */
 static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){
+#ifdef SQLITE_TEST
   struct Fts5ExprFunc {
     const char *z;
     void (*x)(sqlite3_context*,int,sqlite3_value**);
@@ -216586,6 +222053,10 @@ static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){
     struct Fts5ExprFunc *p = &aFunc[i];
     rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
   }
+#else
+  int rc = SQLITE_OK;
+  UNUSED_PARAM2(pGlobal,db);
+#endif
 
   /* Avoid warnings indicating that sqlite3Fts5ParserTrace() and
   ** sqlite3Fts5ParserFallback() are unused */
@@ -216636,6 +222107,15 @@ struct Fts5PoslistPopulator {
   int bMiss;
 };
 
+/*
+** Clear the position lists associated with all phrases in the expression
+** passed as the first argument. Argument bLive is true if the expression
+** might be pointing to a real entry, otherwise it has just been reset.
+**
+** At present this function is only used for detail=col and detail=none
+** fts5 tables. This implies that all phrases must be at most 1 token
+** in size, as phrase matches are not supported without detail=full.
+*/
 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
   Fts5PoslistPopulator *pRet;
   pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
@@ -216645,7 +222125,7 @@ static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int b
     for(i=0; i<pExpr->nPhrase; i++){
       Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
       Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
-      assert( pExpr->apExprPhrase[i]->nTerm==1 );
+      assert( pExpr->apExprPhrase[i]->nTerm<=1 );
       if( bLive &&
           (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
       ){
@@ -217196,7 +222676,7 @@ static int sqlite3Fts5HashWrite(
       p->bContent = 1;
     }else{
       /* Append a new column value, if necessary */
-      assert( iCol>=p->iCol );
+      assert_nc( iCol>=p->iCol );
       if( iCol!=p->iCol ){
         if( pHash->eDetail==FTS5_DETAIL_FULL ){
           pPtr[p->nData++] = 0x01;
@@ -217832,7 +223312,7 @@ struct Fts5SegIter {
   int iLeafPgno;                  /* Current leaf page number */
   Fts5Data *pLeaf;                /* Current leaf data */
   Fts5Data *pNextLeaf;            /* Leaf page (iLeafPgno+1) */
-  int iLeafOffset;                /* Byte offset within current leaf */
+  i64 iLeafOffset;                /* Byte offset within current leaf */
 
   /* Next method */
   void (*xNext)(Fts5Index*, Fts5SegIter*, int*);
@@ -218001,8 +223481,11 @@ static int fts5BufferCompareBlob(
 **     res = *pLeft - *pRight
 */
 static int fts5BufferCompare(Fts5Buffer *pLeft, Fts5Buffer *pRight){
-  int nCmp = MIN(pLeft->n, pRight->n);
-  int res = fts5Memcmp(pLeft->p, pRight->p, nCmp);
+  int nCmp, res;
+  nCmp = MIN(pLeft->n, pRight->n);
+  assert( nCmp<=0 || pLeft->p!=0 );
+  assert( nCmp<=0 || pRight->p!=0 );
+  res = fts5Memcmp(pLeft->p, pRight->p, nCmp);
   return (res==0 ? (pLeft->n - pRight->n) : res);
 }
 
@@ -218098,6 +223581,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
   return pRet;
 }
 
+
 /*
 ** Release a reference to data record returned by an earlier call to
 ** fts5DataRead().
@@ -218222,6 +223706,58 @@ static void fts5StructureRef(Fts5Structure *pStruct){
   pStruct->nRef++;
 }
 
+static void *sqlite3Fts5StructureRef(Fts5Index *p){
+  fts5StructureRef(p->pStruct);
+  return (void*)p->pStruct;
+}
+static void sqlite3Fts5StructureRelease(void *p){
+  if( p ){
+    fts5StructureRelease((Fts5Structure*)p);
+  }
+}
+static int sqlite3Fts5StructureTest(Fts5Index *p, void *pStruct){
+  if( p->pStruct!=(Fts5Structure*)pStruct ){
+    return SQLITE_ABORT;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Ensure that structure object (*pp) is writable.
+**
+** This function is a no-op if (*pRc) is not SQLITE_OK when it is called. If
+** an error occurs, (*pRc) is set to an SQLite error code before returning.
+*/
+static void fts5StructureMakeWritable(int *pRc, Fts5Structure **pp){
+  Fts5Structure *p = *pp;
+  if( *pRc==SQLITE_OK && p->nRef>1 ){
+    i64 nByte = sizeof(Fts5Structure)+(p->nLevel-1)*sizeof(Fts5StructureLevel);
+    Fts5Structure *pNew;
+    pNew = (Fts5Structure*)sqlite3Fts5MallocZero(pRc, nByte);
+    if( pNew ){
+      int i;
+      memcpy(pNew, p, nByte);
+      for(i=0; i<p->nLevel; i++) pNew->aLevel[i].aSeg = 0;
+      for(i=0; i<p->nLevel; i++){
+        Fts5StructureLevel *pLvl = &pNew->aLevel[i];
+        nByte = sizeof(Fts5StructureSegment) * pNew->aLevel[i].nSeg;
+        pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(pRc, nByte);
+        if( pLvl->aSeg==0 ){
+          for(i=0; i<p->nLevel; i++){
+            sqlite3_free(pNew->aLevel[i].aSeg);
+          }
+          sqlite3_free(pNew);
+          return;
+        }
+        memcpy(pLvl->aSeg, p->aLevel[i].aSeg, nByte);
+      }
+      p->nRef--;
+      pNew->nRef = 1;
+    }
+    *pp = pNew;
+  }
+}
+
 /*
 ** Deserialize and return the structure record currently stored in serialized
 ** form within buffer pData/nData.
@@ -218323,9 +223859,11 @@ static int fts5StructureDecode(
 }
 
 /*
-**
+** Add a level to the Fts5Structure.aLevel[] array of structure object
+** (*ppStruct).
 */
 static void fts5StructureAddLevel(int *pRc, Fts5Structure **ppStruct){
+  fts5StructureMakeWritable(pRc, ppStruct);
   if( *pRc==SQLITE_OK ){
     Fts5Structure *pStruct = *ppStruct;
     int nLevel = pStruct->nLevel;
@@ -219012,7 +224550,7 @@ static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
 
 static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
   u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
-  int iOff = pIter->iLeafOffset;
+  i64 iOff = pIter->iLeafOffset;
 
   ASSERT_SZLEAF_OK(pIter->pLeaf);
   if( iOff>=pIter->pLeaf->szLeaf ){
@@ -219045,7 +224583,7 @@ static void fts5SegIterLoadRowid(Fts5Index *p, Fts5SegIter *pIter){
 */
 static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
   u8 *a = pIter->pLeaf->p;        /* Buffer to read data from */
-  int iOff = pIter->iLeafOffset;  /* Offset to read at */
+  i64 iOff = pIter->iLeafOffset;  /* Offset to read at */
   int nNew;                       /* Bytes of new data */
 
   iOff += fts5GetVarint32(&a[iOff], nNew);
@@ -219119,6 +224657,7 @@ static void fts5SegIterInit(
 
   if( p->rc==SQLITE_OK ){
     pIter->iLeafOffset = 4;
+    assert( pIter->pLeaf!=0 );
     assert_nc( pIter->pLeaf->nn>4 );
     assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
     pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
@@ -219471,14 +225010,9 @@ static void fts5SegIterNext(
     }else{
       /* The following could be done by calling fts5SegIterLoadNPos(). But
       ** this block is particularly performance critical, so equivalent
-      ** code is inlined.
-      **
-      ** Later: Switched back to fts5SegIterLoadNPos() because it supports
-      ** detail=none mode. Not ideal.
-      */
+      ** code is inlined.  */
       int nSz;
-      assert( p->rc==SQLITE_OK );
-      assert( pIter->iLeafOffset<=pIter->pLeaf->nn );
+      assert_nc( pIter->iLeafOffset<=pIter->pLeaf->nn );
       fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
       pIter->bDel = (nSz & 0x0001);
       pIter->nPos = nSz>>1;
@@ -219507,7 +225041,7 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
   if( pDlidx ){
     int iSegid = pIter->pSeg->iSegid;
     pgnoLast = fts5DlidxIterPgno(pDlidx);
-    pLast = fts5DataRead(p, FTS5_SEGMENT_ROWID(iSegid, pgnoLast));
+    pLast = fts5LeafRead(p, FTS5_SEGMENT_ROWID(iSegid, pgnoLast));
   }else{
     Fts5Data *pLeaf = pIter->pLeaf;         /* Current leaf data */
 
@@ -219534,7 +225068,7 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
       ** forward to find the page containing the last rowid.  */
       for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
         i64 iAbs = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno);
-        Fts5Data *pNew = fts5DataRead(p, iAbs);
+        Fts5Data *pNew = fts5LeafRead(p, iAbs);
         if( pNew ){
           int iRowid, bTermless;
           iRowid = fts5LeafFirstRowidOff(pNew);
@@ -219565,6 +225099,10 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
     pIter->pLeaf = pLast;
     pIter->iLeafPgno = pgnoLast;
     iOff = fts5LeafFirstRowidOff(pLast);
+    if( iOff>pLast->szLeaf ){
+      p->rc = FTS5_CORRUPT;
+      return;
+    }
     iOff += fts5GetVarint(&pLast->p[iOff], (u64*)&pIter->iRowid);
     pIter->iLeafOffset = iOff;
 
@@ -219573,7 +225111,6 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
     }else{
       pIter->iEndofDoclist = fts5LeafFirstTermOff(pLast);
     }
-
   }
 
   fts5SegIterReverseInitPage(p, pIter);
@@ -219625,21 +225162,20 @@ static void fts5LeafSeek(
   Fts5SegIter *pIter,             /* Iterator to seek */
   const u8 *pTerm, int nTerm      /* Term to search for */
 ){
-  int iOff;
+  u32 iOff;
   const u8 *a = pIter->pLeaf->p;
-  int szLeaf = pIter->pLeaf->szLeaf;
-  int n = pIter->pLeaf->nn;
+  u32 n = (u32)pIter->pLeaf->nn;
 
   u32 nMatch = 0;
   u32 nKeep = 0;
   u32 nNew = 0;
   u32 iTermOff;
-  int iPgidx;                     /* Current offset in pgidx */
+  u32 iPgidx;                     /* Current offset in pgidx */
   int bEndOfPage = 0;
 
   assert( p->rc==SQLITE_OK );
 
-  iPgidx = szLeaf;
+  iPgidx = (u32)pIter->pLeaf->szLeaf;
   iPgidx += fts5GetVarint32(&a[iPgidx], iTermOff);
   iOff = iTermOff;
   if( iOff>n ){
@@ -219705,15 +225241,15 @@ static void fts5LeafSeek(
       if( pIter->pLeaf==0 ) return;
       a = pIter->pLeaf->p;
       if( fts5LeafIsTermless(pIter->pLeaf)==0 ){
-        iPgidx = pIter->pLeaf->szLeaf;
+        iPgidx = (u32)pIter->pLeaf->szLeaf;
         iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
-        if( iOff<4 || iOff>=pIter->pLeaf->szLeaf ){
+        if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
           p->rc = FTS5_CORRUPT;
           return;
         }else{
           nKeep = 0;
           iTermOff = iOff;
-          n = pIter->pLeaf->nn;
+          n = (u32)pIter->pLeaf->nn;
           iOff += fts5GetVarint32(&a[iOff], nNew);
           break;
         }
@@ -220081,7 +225617,7 @@ static void fts5SegIterGotoPage(
     fts5SegIterNextPage(p, pIter);
     assert( p->rc!=SQLITE_OK || pIter->iLeafPgno==iLeafPgno );
 
-    if( p->rc==SQLITE_OK ){
+    if( p->rc==SQLITE_OK && ALWAYS(pIter->pLeaf!=0) ){
       int iOff;
       u8 *a = pIter->pLeaf->p;
       int n = pIter->pLeaf->szLeaf;
@@ -220470,7 +226006,7 @@ static void fts5ChunkIterate(
   int pgno = pSeg->iLeafPgno;
   int pgnoSave = 0;
 
-  /* This function does notmwork with detail=none databases. */
+  /* This function does not work with detail=none databases. */
   assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
 
   if( (pSeg->flags & FTS5_SEGITER_REVERSE)==0 ){
@@ -220483,6 +226019,9 @@ static void fts5ChunkIterate(
     fts5DataRelease(pData);
     if( nRem<=0 ){
       break;
+    }else if( pSeg->pSeg==0 ){
+      p->rc = FTS5_CORRUPT;
+      return;
     }else{
       pgno++;
       pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
@@ -220510,7 +226049,11 @@ static void fts5SegiterPoslist(
   Fts5Colset *pColset,
   Fts5Buffer *pBuf
 ){
+  assert( pBuf!=0 );
+  assert( pSeg!=0 );
   if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){
+    assert( pBuf->p!=0 );
+    assert( pBuf->nSpace >= pBuf->n+pSeg->nPos+FTS5_DATA_ZERO_PADDING );
     memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING);
     if( pColset==0 ){
       fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
@@ -220534,66 +226077,72 @@ static void fts5SegiterPoslist(
 }
 
 /*
-** IN/OUT parameter (*pa) points to a position list n bytes in size. If
-** the position list contains entries for column iCol, then (*pa) is set
-** to point to the sub-position-list for that column and the number of
-** bytes in it returned. Or, if the argument position list does not
-** contain any entries for column iCol, return 0.
+** Parameter pPos points to a buffer containing a position list, size nPos.
+** This function filters it according to pColset (which must be non-NULL)
+** and sets pIter->base.pData/nData to point to the new position list.
+** If memory is required for the new position list, use buffer pIter->poslist.
+** Or, if the new position list is a contiguous subset of the input, set
+** pIter->base.pData/nData to point directly to it.
+**
+** This function is a no-op if *pRc is other than SQLITE_OK when it is
+** called. If an OOM error is encountered, *pRc is set to SQLITE_NOMEM
+** before returning.
 */
-static int fts5IndexExtractCol(
-  const u8 **pa,                  /* IN/OUT: Pointer to poslist */
-  int n,                          /* IN: Size of poslist in bytes */
-  int iCol                        /* Column to extract from poslist */
-){
-  int iCurrent = 0;               /* Anything before the first 0x01 is col 0 */
-  const u8 *p = *pa;
-  const u8 *pEnd = &p[n];         /* One byte past end of position list */
-
-  while( iCol>iCurrent ){
-    /* Advance pointer p until it points to pEnd or an 0x01 byte that is
-    ** not part of a varint. Note that it is not possible for a negative
-    ** or extremely large varint to occur within an uncorrupted position
-    ** list. So the last byte of each varint may be assumed to have a clear
-    ** 0x80 bit.  */
-    while( *p!=0x01 ){
-      while( *p++ & 0x80 );
-      if( p>=pEnd ) return 0;
-    }
-    *pa = p++;
-    iCurrent = *p++;
-    if( iCurrent & 0x80 ){
-      p--;
-      p += fts5GetVarint32(p, iCurrent);
-    }
-  }
-  if( iCol!=iCurrent ) return 0;
-
-  /* Advance pointer p until it points to pEnd or an 0x01 byte that is
-  ** not part of a varint */
-  while( p<pEnd && *p!=0x01 ){
-    while( *p++ & 0x80 );
-  }
-
-  return p - (*pa);
-}
-
 static void fts5IndexExtractColset(
   int *pRc,
   Fts5Colset *pColset,            /* Colset to filter on */
   const u8 *pPos, int nPos,       /* Position list */
-  Fts5Buffer *pBuf                /* Output buffer */
+  Fts5Iter *pIter
 ){
   if( *pRc==SQLITE_OK ){
-    int i;
-    fts5BufferZero(pBuf);
-    for(i=0; i<pColset->nCol; i++){
-      const u8 *pSub = pPos;
-      int nSub = fts5IndexExtractCol(&pSub, nPos, pColset->aiCol[i]);
-      if( nSub ){
-        fts5BufferAppendBlob(pRc, pBuf, nSub, pSub);
+    const u8 *p = pPos;
+    const u8 *aCopy = p;
+    const u8 *pEnd = &p[nPos];    /* One byte past end of position list */
+    int i = 0;
+    int iCurrent = 0;
+
+    if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
+      return;
+    }
+
+    while( 1 ){
+      while( pColset->aiCol[i]<iCurrent ){
+        i++;
+        if( i==pColset->nCol ){
+          pIter->base.pData = pIter->poslist.p;
+          pIter->base.nData = pIter->poslist.n;
+          return;
+        }
+      }
+
+      /* Advance pointer p until it points to pEnd or an 0x01 byte that is
+      ** not part of a varint */
+      while( p<pEnd && *p!=0x01 ){
+        while( *p++ & 0x80 );
+      }
+
+      if( pColset->aiCol[i]==iCurrent ){
+        if( pColset->nCol==1 ){
+          pIter->base.pData = aCopy;
+          pIter->base.nData = p-aCopy;
+          return;
+        }
+        fts5BufferSafeAppendBlob(&pIter->poslist, aCopy, p-aCopy);
+      }
+      if( p>=pEnd ){
+        pIter->base.pData = pIter->poslist.p;
+        pIter->base.nData = pIter->poslist.n;
+        return;
+      }
+      aCopy = p++;
+      iCurrent = *p++;
+      if( iCurrent & 0x80 ){
+        p--;
+        p += fts5GetVarint32(p, iCurrent);
       }
     }
   }
+
 }
 
 /*
@@ -220713,16 +226262,9 @@ static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
     /* All data is stored on the current page. Populate the output
     ** variables to point into the body of the page object. */
     const u8 *a = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-    if( pColset->nCol==1 ){
-      pIter->base.nData = fts5IndexExtractCol(&a, pSeg->nPos,pColset->aiCol[0]);
-      pIter->base.pData = a;
-    }else{
-      int *pRc = &pIter->pIndex->rc;
-      fts5BufferZero(&pIter->poslist);
-      fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, &pIter->poslist);
-      pIter->base.pData = pIter->poslist.p;
-      pIter->base.nData = pIter->poslist.n;
-    }
+    int *pRc = &pIter->pIndex->rc;
+    fts5BufferZero(&pIter->poslist);
+    fts5IndexExtractColset(pRc, pColset, a, pSeg->nPos, pIter);
   }else{
     /* The data is distributed over two or more pages. Copy it into the
     ** Fts5Iter.poslist buffer and then set the output pointer to point
@@ -220735,6 +226277,7 @@ static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
 }
 
 static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
+  assert( pIter!=0 || (*pRc)!=SQLITE_OK );
   if( *pRc==SQLITE_OK ){
     Fts5Config *pConfig = pIter->pIndex->pConfig;
     if( pConfig->eDetail==FTS5_DETAIL_NONE ){
@@ -220806,7 +226349,10 @@ static void fts5MultiIterNew(
     }
   }
   *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
-  if( pNew==0 ) return;
+  if( pNew==0 ){
+    assert( p->rc!=SQLITE_OK );
+    goto fts5MultiIterNew_post_check;
+  }
   pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
   pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
   pNew->pColset = pColset;
@@ -220870,6 +226416,10 @@ static void fts5MultiIterNew(
     fts5MultiIterFree(pNew);
     *ppOut = 0;
   }
+
+fts5MultiIterNew_post_check:
+  assert( (*ppOut)!=0 || p->rc!=SQLITE_OK );
+  return;
 }
 
 /*
@@ -220917,7 +226467,8 @@ static void fts5MultiIterNew2(
 ** False otherwise.
 */
 static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
-  assert( p->rc
+  assert( pIter!=0 || p->rc!=SQLITE_OK );
+  assert( p->rc!=SQLITE_OK
       || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof
   );
   return (p->rc || pIter->base.bEof);
@@ -221721,6 +227272,7 @@ static void fts5IndexMergeLevel(
   ** and last leaf page number at the same time.  */
   fts5WriteFinish(p, &writer, &pSeg->pgnoLast);
 
+  assert( pIter!=0 || p->rc!=SQLITE_OK );
   if( fts5MultiIterEof(p, pIter) ){
     int i;
 
@@ -221821,7 +227373,7 @@ static void fts5IndexAutomerge(
   Fts5Structure **ppStruct,       /* IN/OUT: Current structure of index */
   int nLeaf                       /* Number of output leaves just written */
 ){
-  if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 ){
+  if( p->rc==SQLITE_OK && p->pConfig->nAutomerge>0 && ALWAYS((*ppStruct)!=0) ){
     Fts5Structure *pStruct = *ppStruct;
     u64 nWrite;                   /* Initial value of write-counter */
     int nWork;                    /* Number of work-quanta to perform */
@@ -221944,14 +227496,14 @@ static void fts5FlushOneHash(Fts5Index *p){
         fts5BufferSafeAppendBlob(pBuf, pDoclist, nDoclist);
       }else{
         i64 iRowid = 0;
-        i64 iDelta = 0;
+        u64 iDelta = 0;
         int iOff = 0;
 
         /* The entire doclist will not fit on this leaf. The following
         ** loop iterates through the poslists that make up the current
         ** doclist.  */
         while( p->rc==SQLITE_OK && iOff<nDoclist ){
-          iOff += fts5GetVarint(&pDoclist[iOff], (u64*)&iDelta);
+          iOff += fts5GetVarint(&pDoclist[iOff], &iDelta);
           iRowid += iDelta;
 
           if( writer.bFirstRowidInPage ){
@@ -222205,7 +227757,7 @@ static void fts5AppendPoslist(
 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
   u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
 
-  assert( pIter->aPoslist );
+  assert( pIter->aPoslist || (p==0 && pIter->aPoslist==0) );
   if( p>=pIter->aEof ){
     pIter->aPoslist = 0;
   }else{
@@ -222225,6 +227777,9 @@ static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
     }
 
     pIter->aPoslist = p;
+    if( &pIter->aPoslist[pIter->nPoslist]>pIter->aEof ){
+      pIter->aPoslist = 0;
+    }
   }
 }
 
@@ -222233,9 +227788,11 @@ static void fts5DoclistIterInit(
   Fts5DoclistIter *pIter
 ){
   memset(pIter, 0, sizeof(*pIter));
-  pIter->aPoslist = pBuf->p;
-  pIter->aEof = &pBuf->p[pBuf->n];
-  fts5DoclistIterNext(pIter);
+  if( pBuf->n>0 ){
+    pIter->aPoslist = pBuf->p;
+    pIter->aEof = &pBuf->p[pBuf->n];
+    fts5DoclistIterNext(pIter);
+  }
 }
 
 #if 0
@@ -222289,16 +227846,20 @@ static void fts5NextRowid(Fts5Buffer *pBuf, int *piOff, i64 *piRowid){
 static void fts5MergeRowidLists(
   Fts5Index *p,                   /* FTS5 backend object */
   Fts5Buffer *p1,                 /* First list to merge */
-  Fts5Buffer *p2                  /* Second list to merge */
+  int nBuf,                       /* Number of entries in apBuf[] */
+  Fts5Buffer *aBuf                /* Array of other lists to merge into p1 */
 ){
   int i1 = 0;
   int i2 = 0;
   i64 iRowid1 = 0;
   i64 iRowid2 = 0;
   i64 iOut = 0;
-
+  Fts5Buffer *p2 = &aBuf[0];
   Fts5Buffer out;
+
+  (void)nBuf;
   memset(&out, 0, sizeof(out));
+  assert( nBuf==1 );
   sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
   if( p->rc ) return;
 
@@ -222325,180 +227886,214 @@ static void fts5MergeRowidLists(
   fts5BufferFree(&out);
 }
 
+typedef struct PrefixMerger PrefixMerger;
+struct PrefixMerger {
+  Fts5DoclistIter iter;           /* Doclist iterator */
+  i64 iPos;                       /* For iterating through a position list */
+  int iOff;
+  u8 *aPos;
+  PrefixMerger *pNext;            /* Next in docid/poslist order */
+};
+
+static void fts5PrefixMergerInsertByRowid(
+  PrefixMerger **ppHead,
+  PrefixMerger *p
+){
+  if( p->iter.aPoslist ){
+    PrefixMerger **pp = ppHead;
+    while( *pp && p->iter.iRowid>(*pp)->iter.iRowid ){
+      pp = &(*pp)->pNext;
+    }
+    p->pNext = *pp;
+    *pp = p;
+  }
+}
+
+static void fts5PrefixMergerInsertByPosition(
+  PrefixMerger **ppHead,
+  PrefixMerger *p
+){
+  if( p->iPos>=0 ){
+    PrefixMerger **pp = ppHead;
+    while( *pp && p->iPos>(*pp)->iPos ){
+      pp = &(*pp)->pNext;
+    }
+    p->pNext = *pp;
+    *pp = p;
+  }
+}
+
+
 /*
-** Buffers p1 and p2 contain doclists. This function merges the content
-** of the two doclists together and sets buffer p1 to the result before
-** returning.
-**
-** If an error occurs, an error code is left in p->rc. If an error has
-** already occurred, this function is a no-op.
+** Array aBuf[] contains nBuf doclists. These are all merged in with the
+** doclist in buffer p1.
 */
 static void fts5MergePrefixLists(
   Fts5Index *p,                   /* FTS5 backend object */
   Fts5Buffer *p1,                 /* First list to merge */
-  Fts5Buffer *p2                  /* Second list to merge */
-){
-  if( p2->n ){
-    i64 iLastRowid = 0;
-    Fts5DoclistIter i1;
-    Fts5DoclistIter i2;
-    Fts5Buffer out = {0, 0, 0};
-    Fts5Buffer tmp = {0, 0, 0};
-
-    /* The maximum size of the output is equal to the sum of the two
-    ** input sizes + 1 varint (9 bytes). The extra varint is because if the
-    ** first rowid in one input is a large negative number, and the first in
-    ** the other a non-negative number, the delta for the non-negative
-    ** number will be larger on disk than the literal integer value
-    ** was.
-    **
-    ** Or, if the input position-lists are corrupt, then the output might
-    ** include up to 2 extra 10-byte positions created by interpreting -1
-    ** (the value PoslistNext64() uses for EOF) as a position and appending
-    ** it to the output. This can happen at most once for each input
-    ** position-list, hence two 10 byte paddings.  */
-    if( sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n + 9+10+10) ) return;
-    fts5DoclistIterInit(p1, &i1);
-    fts5DoclistIterInit(p2, &i2);
+  int nBuf,                       /* Number of buffers in array aBuf[] */
+  Fts5Buffer *aBuf                /* Other lists to merge in */
+){
+#define fts5PrefixMergerNextPosition(p) \
+  sqlite3Fts5PoslistNext64((p)->aPos,(p)->iter.nPoslist,&(p)->iOff,&(p)->iPos)
+#define FTS5_MERGE_NLIST 16
+  PrefixMerger aMerger[FTS5_MERGE_NLIST];
+  PrefixMerger *pHead = 0;
+  int i;
+  int nOut = 0;
+  Fts5Buffer out = {0, 0, 0};
+  Fts5Buffer tmp = {0, 0, 0};
+  i64 iLastRowid = 0;
+
+  /* Initialize a doclist-iterator for each input buffer. Arrange them in
+  ** a linked-list starting at pHead in ascending order of rowid. Avoid
+  ** linking any iterators already at EOF into the linked list at all. */
+  assert( nBuf+1<=sizeof(aMerger)/sizeof(aMerger[0]) );
+  memset(aMerger, 0, sizeof(PrefixMerger)*(nBuf+1));
+  pHead = &aMerger[nBuf];
+  fts5DoclistIterInit(p1, &pHead->iter);
+  for(i=0; i<nBuf; i++){
+    fts5DoclistIterInit(&aBuf[i], &aMerger[i].iter);
+    fts5PrefixMergerInsertByRowid(&pHead, &aMerger[i]);
+    nOut += aBuf[i].n;
+  }
+  if( nOut==0 ) return;
+  nOut += p1->n + 9 + 10*nBuf;
+
+  /* The maximum size of the output is equal to the sum of the
+  ** input sizes + 1 varint (9 bytes). The extra varint is because if the
+  ** first rowid in one input is a large negative number, and the first in
+  ** the other a non-negative number, the delta for the non-negative
+  ** number will be larger on disk than the literal integer value
+  ** was.
+  **
+  ** Or, if the input position-lists are corrupt, then the output might
+  ** include up to (nBuf+1) extra 10-byte positions created by interpreting -1
+  ** (the value PoslistNext64() uses for EOF) as a position and appending
+  ** it to the output. This can happen at most once for each input
+  ** position-list, hence (nBuf+1) 10 byte paddings.  */
+  if( sqlite3Fts5BufferSize(&p->rc, &out, nOut) ) return;
+
+  while( pHead ){
+    fts5MergeAppendDocid(&out, iLastRowid, pHead->iter.iRowid);
+
+    if( pHead->pNext && iLastRowid==pHead->pNext->iter.iRowid ){
+      /* Merge data from two or more poslists */
+      i64 iPrev = 0;
+      int nTmp = FTS5_DATA_ZERO_PADDING;
+      int nMerge = 0;
+      PrefixMerger *pSave = pHead;
+      PrefixMerger *pThis = 0;
+      int nTail = 0;
+
+      pHead = 0;
+      while( pSave && pSave->iter.iRowid==iLastRowid ){
+        PrefixMerger *pNext = pSave->pNext;
+        pSave->iOff = 0;
+        pSave->iPos = 0;
+        pSave->aPos = &pSave->iter.aPoslist[pSave->iter.nSize];
+        fts5PrefixMergerNextPosition(pSave);
+        nTmp += pSave->iter.nPoslist + 10;
+        nMerge++;
+        fts5PrefixMergerInsertByPosition(&pHead, pSave);
+        pSave = pNext;
+      }
+
+      if( pHead==0 || pHead->pNext==0 ){
+        p->rc = FTS5_CORRUPT;
+        break;
+      }
 
-    while( 1 ){
-      if( i1.iRowid<i2.iRowid ){
-        /* Copy entry from i1 */
-        fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
-        fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.nPoslist+i1.nSize);
-        fts5DoclistIterNext(&i1);
-        if( i1.aPoslist==0 ) break;
-        assert( out.n<=((i1.aPoslist-p1->p) + (i2.aPoslist-p2->p)+9+10+10) );
-      }
-      else if( i2.iRowid!=i1.iRowid ){
-        /* Copy entry from i2 */
-        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
-        fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize);
-        fts5DoclistIterNext(&i2);
-        if( i2.aPoslist==0 ) break;
-        assert( out.n<=((i1.aPoslist-p1->p) + (i2.aPoslist-p2->p)+9+10+10) );
+      /* See the earlier comment in this function for an explanation of why
+      ** corrupt input position lists might cause the output to consume
+      ** at most nMerge*10 bytes of unexpected space. */
+      if( sqlite3Fts5BufferSize(&p->rc, &tmp, nTmp+nMerge*10) ){
+        break;
       }
-      else{
-        /* Merge the two position lists. */
-        i64 iPos1 = 0;
-        i64 iPos2 = 0;
-        int iOff1 = 0;
-        int iOff2 = 0;
-        u8 *a1 = &i1.aPoslist[i1.nSize];
-        u8 *a2 = &i2.aPoslist[i2.nSize];
-        int nCopy;
-        u8 *aCopy;
-
-        i64 iPrev = 0;
-        Fts5PoslistWriter writer;
-        memset(&writer, 0, sizeof(writer));
-
-        /* See the earlier comment in this function for an explanation of why
-        ** corrupt input position lists might cause the output to consume
-        ** at most 20 bytes of unexpected space. */
-        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
-        fts5BufferZero(&tmp);
-        sqlite3Fts5BufferSize(&p->rc, &tmp,
-            i1.nPoslist + i2.nPoslist + 10 + 10 + FTS5_DATA_ZERO_PADDING
-        );
-        if( p->rc ) break;
+      fts5BufferZero(&tmp);
 
-        sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
-        sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
-        assert_nc( iPos1>=0 && iPos2>=0 );
+      pThis = pHead;
+      pHead = pThis->pNext;
+      sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos);
+      fts5PrefixMergerNextPosition(pThis);
+      fts5PrefixMergerInsertByPosition(&pHead, pThis);
 
-        if( iPos1<iPos2 ){
-          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
-          sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
-        }else{
-          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
-          sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
-        }
-        if( iPos1>=0 && iPos2>=0 ){
-          while( 1 ){
-            if( iPos1<iPos2 ){
-              if( iPos1!=iPrev ){
-                sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
-              }
-              sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
-              if( iPos1<0 ) break;
-            }else{
-              assert_nc( iPos2!=iPrev );
-              sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
-              sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
-              if( iPos2<0 ) break;
-            }
-          }
+      while( pHead->pNext ){
+        pThis = pHead;
+        if( pThis->iPos!=iPrev ){
+          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pThis->iPos);
         }
+        fts5PrefixMergerNextPosition(pThis);
+        pHead = pThis->pNext;
+        fts5PrefixMergerInsertByPosition(&pHead, pThis);
+      }
 
-        if( iPos1>=0 ){
-          if( iPos1!=iPrev ){
-            sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
-          }
-          aCopy = &a1[iOff1];
-          nCopy = i1.nPoslist - iOff1;
-        }else{
-          assert_nc( iPos2>=0 && iPos2!=iPrev );
-          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
-          aCopy = &a2[iOff2];
-          nCopy = i2.nPoslist - iOff2;
-        }
-        if( nCopy>0 ){
-          fts5BufferSafeAppendBlob(&tmp, aCopy, nCopy);
-        }
+      if( pHead->iPos!=iPrev ){
+        sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, pHead->iPos);
+      }
+      nTail = pHead->iter.nPoslist - pHead->iOff;
 
-        /* WRITEPOSLISTSIZE */
-        assert_nc( tmp.n<=i1.nPoslist+i2.nPoslist );
-        assert( tmp.n<=i1.nPoslist+i2.nPoslist+10+10 );
-        if( tmp.n>i1.nPoslist+i2.nPoslist ){
-          if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
-          break;
+      /* WRITEPOSLISTSIZE */
+      assert_nc( tmp.n+nTail<=nTmp );
+      assert( tmp.n+nTail<=nTmp+nMerge*10 );
+      if( tmp.n+nTail>nTmp-FTS5_DATA_ZERO_PADDING ){
+        if( p->rc==SQLITE_OK ) p->rc = FTS5_CORRUPT;
+        break;
+      }
+      fts5BufferSafeAppendVarint(&out, (tmp.n+nTail) * 2);
+      fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
+      if( nTail>0 ){
+        fts5BufferSafeAppendBlob(&out, &pHead->aPos[pHead->iOff], nTail);
+      }
+
+      pHead = pSave;
+      for(i=0; i<nBuf+1; i++){
+        PrefixMerger *pX = &aMerger[i];
+        if( pX->iter.aPoslist && pX->iter.iRowid==iLastRowid ){
+          fts5DoclistIterNext(&pX->iter);
+          fts5PrefixMergerInsertByRowid(&pHead, pX);
         }
-        fts5BufferSafeAppendVarint(&out, tmp.n * 2);
-        fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
-        fts5DoclistIterNext(&i1);
-        fts5DoclistIterNext(&i2);
-        assert_nc( out.n<=(p1->n+p2->n+9) );
-        if( i1.aPoslist==0 || i2.aPoslist==0 ) break;
-        assert( out.n<=((i1.aPoslist-p1->p) + (i2.aPoslist-p2->p)+9+10+10) );
       }
-    }
 
-    if( i1.aPoslist ){
-      fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
-      fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.aEof - i1.aPoslist);
-    }
-    else if( i2.aPoslist ){
-      fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
-      fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.aEof - i2.aPoslist);
+    }else{
+      /* Copy poslist from pHead to output */
+      PrefixMerger *pThis = pHead;
+      Fts5DoclistIter *pI = &pThis->iter;
+      fts5BufferSafeAppendBlob(&out, pI->aPoslist, pI->nPoslist+pI->nSize);
+      fts5DoclistIterNext(pI);
+      pHead = pThis->pNext;
+      fts5PrefixMergerInsertByRowid(&pHead, pThis);
     }
-    assert_nc( out.n<=(p1->n+p2->n+9) );
-
-    fts5BufferFree(p1);
-    fts5BufferFree(&tmp);
-    memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING);
-    *p1 = out;
   }
+
+  fts5BufferFree(p1);
+  fts5BufferFree(&tmp);
+  memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING);
+  *p1 = out;
 }
 
 static void fts5SetupPrefixIter(
   Fts5Index *p,                   /* Index to read from */
   int bDesc,                      /* True for "ORDER BY rowid DESC" */
-  const u8 *pToken,               /* Buffer containing prefix to match */
+  int iIdx,                       /* Index to scan for data */
+  u8 *pToken,                     /* Buffer containing prefix to match */
   int nToken,                     /* Size of buffer pToken in bytes */
   Fts5Colset *pColset,            /* Restrict matches to these columns */
   Fts5Iter **ppIter          /* OUT: New iterator */
 ){
   Fts5Structure *pStruct;
   Fts5Buffer *aBuf;
-  const int nBuf = 32;
+  int nBuf = 32;
+  int nMerge = 1;
 
-  void (*xMerge)(Fts5Index*, Fts5Buffer*, Fts5Buffer*);
+  void (*xMerge)(Fts5Index*, Fts5Buffer*, int, Fts5Buffer*);
   void (*xAppend)(Fts5Index*, i64, Fts5Iter*, Fts5Buffer*);
   if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
     xMerge = fts5MergeRowidLists;
     xAppend = fts5AppendRowid;
   }else{
+    nMerge = FTS5_MERGE_NLIST-1;
+    nBuf = nMerge*8;   /* Sufficient to merge (16^8)==(2^32) lists */
     xMerge = fts5MergePrefixLists;
     xAppend = fts5AppendPoslist;
   }
@@ -222518,6 +228113,27 @@ static void fts5SetupPrefixIter(
     int bNewTerm = 1;
 
     memset(&doclist, 0, sizeof(doclist));
+    if( iIdx!=0 ){
+      int dummy = 0;
+      const int f2 = FTS5INDEX_QUERY_SKIPEMPTY|FTS5INDEX_QUERY_NOOUTPUT;
+      pToken[0] = FTS5_MAIN_PREFIX;
+      fts5MultiIterNew(p, pStruct, f2, pColset, pToken, nToken, -1, 0, &p1);
+      fts5IterSetOutputCb(&p->rc, p1);
+      for(;
+        fts5MultiIterEof(p, p1)==0;
+        fts5MultiIterNext2(p, p1, &dummy)
+      ){
+        Fts5SegIter *pSeg = &p1->aSeg[ p1->aFirst[1].iFirst ];
+        p1->xSetOutputs(p1, pSeg);
+        if( p1->base.nData ){
+          xAppend(p, p1->base.iRowid-iLastRowid, p1, &doclist);
+          iLastRowid = p1->base.iRowid;
+        }
+      }
+      fts5MultiIterFree(p1);
+    }
+
+    pToken[0] = FTS5_MAIN_PREFIX + iIdx;
     fts5MultiIterNew(p, pStruct, flags, pColset, pToken, nToken, -1, 0, &p1);
     fts5IterSetOutputCb(&p->rc, p1);
     for( /* no-op */ ;
@@ -222538,13 +228154,21 @@ static void fts5SetupPrefixIter(
 
       if( p1->base.iRowid<=iLastRowid && doclist.n>0 ){
         for(i=0; p->rc==SQLITE_OK && doclist.n; i++){
-          assert( i<nBuf );
-          if( aBuf[i].n==0 ){
-            fts5BufferSwap(&doclist, &aBuf[i]);
-            fts5BufferZero(&doclist);
-          }else{
-            xMerge(p, &doclist, &aBuf[i]);
-            fts5BufferZero(&aBuf[i]);
+          int i1 = i*nMerge;
+          int iStore;
+          assert( i1+nMerge<=nBuf );
+          for(iStore=i1; iStore<i1+nMerge; iStore++){
+            if( aBuf[iStore].n==0 ){
+              fts5BufferSwap(&doclist, &aBuf[iStore]);
+              fts5BufferZero(&doclist);
+              break;
+            }
+          }
+          if( iStore==i1+nMerge ){
+            xMerge(p, &doclist, nMerge, &aBuf[i1]);
+            for(iStore=i1; iStore<i1+nMerge; iStore++){
+              fts5BufferZero(&aBuf[iStore]);
+            }
           }
         }
         iLastRowid = 0;
@@ -222554,11 +228178,15 @@ static void fts5SetupPrefixIter(
       iLastRowid = p1->base.iRowid;
     }
 
-    for(i=0; i<nBuf; i++){
+    assert( (nBuf%nMerge)==0 );
+    for(i=0; i<nBuf; i+=nMerge){
+      int iFree;
       if( p->rc==SQLITE_OK ){
-        xMerge(p, &doclist, &aBuf[i]);
+        xMerge(p, &doclist, nMerge, &aBuf[i]);
+      }
+      for(iFree=i; iFree<i+nMerge; iFree++){
+        fts5BufferFree(&aBuf[iFree]);
       }
-      fts5BufferFree(&aBuf[i]);
     }
     fts5MultiIterFree(p1);
 
@@ -222813,6 +228441,7 @@ static int sqlite3Fts5IndexQuery(
 
   if( sqlite3Fts5BufferSize(&p->rc, &buf, nToken+1)==0 ){
     int iIdx = 0;                 /* Index to search */
+    int iPrefixIdx = 0;           /* +1 prefix index */
     if( nToken ) memcpy(&buf.p[1], pToken, nToken);
 
     /* Figure out which index to search and set iIdx accordingly. If this
@@ -222834,7 +228463,9 @@ static int sqlite3Fts5IndexQuery(
     if( flags & FTS5INDEX_QUERY_PREFIX ){
       int nChar = fts5IndexCharlen(pToken, nToken);
       for(iIdx=1; iIdx<=pConfig->nPrefix; iIdx++){
-        if( pConfig->aPrefix[iIdx-1]==nChar ) break;
+        int nIdxChar = pConfig->aPrefix[iIdx-1];
+        if( nIdxChar==nChar ) break;
+        if( nIdxChar==nChar+1 ) iPrefixIdx = iIdx;
       }
     }
 
@@ -222851,13 +228482,16 @@ static int sqlite3Fts5IndexQuery(
     }else{
       /* Scan multiple terms in the main index */
       int bDesc = (flags & FTS5INDEX_QUERY_DESC)!=0;
-      buf.p[0] = FTS5_MAIN_PREFIX;
-      fts5SetupPrefixIter(p, bDesc, buf.p, nToken+1, pColset, &pRet);
-      assert( p->rc!=SQLITE_OK || pRet->pColset==0 );
-      fts5IterSetOutputCb(&p->rc, pRet);
-      if( p->rc==SQLITE_OK ){
-        Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst];
-        if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg);
+      fts5SetupPrefixIter(p, bDesc, iPrefixIdx, buf.p, nToken+1, pColset,&pRet);
+      if( pRet==0 ){
+        assert( p->rc!=SQLITE_OK );
+      }else{
+        assert( pRet->pColset==0 );
+        fts5IterSetOutputCb(&p->rc, pRet);
+        if( p->rc==SQLITE_OK ){
+          Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst];
+          if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg);
+        }
       }
     }
 
@@ -222925,8 +228559,9 @@ static int sqlite3Fts5IterNextFrom(Fts5IndexIter *pIndexIter, i64 iMatch){
 static const char *sqlite3Fts5IterTerm(Fts5IndexIter *pIndexIter, int *pn){
   int n;
   const char *z = (const char*)fts5MultiIterTerm((Fts5Iter*)pIndexIter, &n);
+  assert_nc( z || n<=1 );
   *pn = n-1;
-  return &z[1];
+  return (z ? &z[1] : 0);
 }
 
 /*
@@ -223104,7 +228739,7 @@ static int fts5QueryCksum(
   Fts5IndexIter *pIter = 0;
   int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
 
-  while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIter) ){
+  while( rc==SQLITE_OK && ALWAYS(pIter!=0) && 0==sqlite3Fts5IterEof(pIter) ){
     i64 rowid = pIter->iRowid;
 
     if( eDetail==FTS5_DETAIL_NONE ){
@@ -223469,6 +229104,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum
   Fts5Buffer poslist = {0,0,0};   /* Buffer used to hold a poslist */
   Fts5Iter *pIter;                /* Used to iterate through entire index */
   Fts5Structure *pStruct;         /* Index structure */
+  int iLvl, iSeg;
 
 #ifdef SQLITE_DEBUG
   /* Used by extra internal tests only run if NDEBUG is not defined */
@@ -223479,15 +229115,16 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum
 
   /* Load the FTS index structure */
   pStruct = fts5StructureRead(p);
+  if( pStruct==0 ){
+    assert( p->rc!=SQLITE_OK );
+    return fts5IndexReturn(p);
+  }
 
   /* Check that the internal nodes of each segment match the leaves */
-  if( pStruct ){
-    int iLvl, iSeg;
-    for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
-      for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-        Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg];
-        fts5IndexIntegrityCheckSegment(p, pSeg);
-      }
+  for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
+    for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
+      Fts5StructureSegment *pSeg = &pStruct->aLevel[iLvl].aSeg[iSeg];
+      fts5IndexIntegrityCheckSegment(p, pSeg);
     }
   }
 
@@ -223551,6 +229188,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum, int bUseCksum
 ** function only.
 */
 
+#ifdef SQLITE_TEST
 /*
 ** Decode a segment-data rowid from the %_data table. This function is
 ** the opposite of macro FTS5_SEGMENT_ROWID().
@@ -223573,7 +229211,9 @@ static void fts5DecodeRowid(
 
   *piSegid = (int)(iRowid & (((i64)1 << FTS5_DATA_ID_B) - 1));
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){
   int iSegid, iHeight, iPgno, bDlidx;       /* Rowid compenents */
   fts5DecodeRowid(iKey, &iSegid, &bDlidx, &iHeight, &iPgno);
@@ -223591,7 +229231,9 @@ static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){
     );
   }
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 static void fts5DebugStructure(
   int *pRc,                       /* IN/OUT: error code */
   Fts5Buffer *pBuf,
@@ -223613,7 +229255,9 @@ static void fts5DebugStructure(
     sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "}");
   }
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** This is part of the fts5_decode() debugging aid.
 **
@@ -223638,7 +229282,9 @@ static void fts5DecodeStructure(
   fts5DebugStructure(pRc, pBuf, p);
   fts5StructureRelease(p);
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** This is part of the fts5_decode() debugging aid.
 **
@@ -223661,7 +229307,9 @@ static void fts5DecodeAverages(
     zSpace = " ";
   }
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** Buffer (a/n) is assumed to contain a list of serialized varints. Read
 ** each varint and append its string representation to buffer pBuf. Return
@@ -223678,7 +229326,9 @@ static int fts5DecodePoslist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
   }
   return iOff;
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** The start of buffer (a/n) contains the start of a doclist. The doclist
 ** may or may not finish within the buffer. This function appends a text
@@ -223711,7 +229361,9 @@ static int fts5DecodeDoclist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
 
   return iOff;
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** This function is part of the fts5_decode() debugging function. It is
 ** only ever used with detail=none tables.
@@ -223752,7 +229404,9 @@ static void fts5DecodeRowidList(
     sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %lld%s", iRowid, zApp);
   }
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** The implementation of user-defined scalar function fts5_decode().
 */
@@ -223961,7 +229615,9 @@ static void fts5DecodeFunction(
   }
   fts5BufferFree(&s);
 }
+#endif /* SQLITE_TEST */
 
+#ifdef SQLITE_TEST
 /*
 ** The implementation of user-defined scalar function fts5_rowid().
 */
@@ -223995,6 +229651,7 @@ static void fts5RowidFunction(
     }
   }
 }
+#endif /* SQLITE_TEST */
 
 /*
 ** This is called as part of registering the FTS5 module with database
@@ -224005,6 +229662,7 @@ static void fts5RowidFunction(
 ** SQLite error code is returned instead.
 */
 static int sqlite3Fts5IndexInit(sqlite3 *db){
+#ifdef SQLITE_TEST
   int rc = sqlite3_create_function(
       db, "fts5_decode", 2, SQLITE_UTF8, 0, fts5DecodeFunction, 0, 0
   );
@@ -224022,6 +229680,10 @@ static int sqlite3Fts5IndexInit(sqlite3 *db){
     );
   }
   return rc;
+#else
+  return SQLITE_OK;
+  UNUSED_PARAM(db);
+#endif
 }
 
 
@@ -224057,7 +229719,9 @@ static int sqlite3Fts5IndexReset(Fts5Index *p){
 ** assert() conditions in the fts5 code are activated - conditions that are
 ** only true if it is guaranteed that the fts5 database is not corrupt.
 */
+#ifdef SQLITE_DEBUG
 SQLITE_API int sqlite3_fts5_may_be_corrupt = 1;
+#endif
 
 
 typedef struct Fts5Auxdata Fts5Auxdata;
@@ -225407,7 +231071,8 @@ static int fts5FilterMethod(
         pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
     );
     if( rc==SQLITE_OK ){
-      if( pCsr->ePlan==FTS5_PLAN_ROWID ){
+      if( pRowidEq!=0 ){
+        assert( pCsr->ePlan==FTS5_PLAN_ROWID );
         sqlite3_bind_value(pCsr->pStmt, 1, pRowidEq);
       }else{
         sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iFirstRowid);
@@ -225982,13 +231647,15 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
 
         nInst++;
         if( nInst>=pCsr->nInstAlloc ){
-          pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
+          int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
           aInst = (int*)sqlite3_realloc64(
-              pCsr->aInst, pCsr->nInstAlloc*sizeof(int)*3
+              pCsr->aInst, nNewSize*sizeof(int)*3
               );
           if( aInst ){
             pCsr->aInst = aInst;
+            pCsr->nInstAlloc = nNewSize;
           }else{
+            nInst--;
             rc = SQLITE_NOMEM;
             break;
           }
@@ -226212,7 +231879,8 @@ static int fts5ApiPhraseFirst(
   int n;
   int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
   if( rc==SQLITE_OK ){
-    pIter->b = &pIter->a[n];
+    assert( pIter->a || n==0 );
+    pIter->b = (pIter->a ? &pIter->a[n] : 0);
     *piCol = 0;
     *piOff = 0;
     fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
@@ -226271,7 +231939,8 @@ static int fts5ApiPhraseFirstColumn(
       rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
     }
     if( rc==SQLITE_OK ){
-      pIter->b = &pIter->a[n];
+      assert( pIter->a || n==0 );
+      pIter->b = (pIter->a ? &pIter->a[n] : 0);
       *piCol = 0;
       fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
     }
@@ -226279,7 +231948,8 @@ static int fts5ApiPhraseFirstColumn(
     int n;
     rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
     if( rc==SQLITE_OK ){
-      pIter->b = &pIter->a[n];
+      assert( pIter->a || n==0 );
+      pIter->b = (pIter->a ? &pIter->a[n] : 0);
       if( n<=0 ){
         *piCol = -1;
       }else if( pIter->a[0]==0x01 ){
@@ -226757,7 +232427,7 @@ static int sqlite3Fts5GetTokenizer(
     *pzErr = sqlite3_mprintf("no such tokenizer: %s", azArg[0]);
   }else{
     rc = pMod->x.xCreate(
-        pMod->pUserData, &azArg[1], (nArg?nArg-1:0), &pConfig->pTok
+        pMod->pUserData, (azArg?&azArg[1]:0), (nArg?nArg-1:0), &pConfig->pTok
     );
     pConfig->pTokApi = &pMod->x;
     if( rc!=SQLITE_OK ){
@@ -226820,7 +232490,7 @@ static void fts5SourceIdFunc(
 ){
   assert( nArg==0 );
   UNUSED_PARAM2(nArg, apUnused);
-  sqlite3_result_text(pCtx, "fts5: 2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b", -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(pCtx, "fts5: 2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a", -1, SQLITE_TRANSIENT);
 }
 
 /*
@@ -227371,12 +233041,16 @@ static int fts5StorageDeleteFromIndex(
     if( pConfig->abUnindexed[iCol-1]==0 ){
       const char *zText;
       int nText;
+      assert( pSeek==0 || apVal==0 );
+      assert( pSeek!=0 || apVal!=0 );
       if( pSeek ){
         zText = (const char*)sqlite3_column_text(pSeek, iCol);
         nText = sqlite3_column_bytes(pSeek, iCol);
-      }else{
+      }else if( ALWAYS(apVal) ){
         zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
         nText = sqlite3_value_bytes(apVal[iCol-1]);
+      }else{
+        continue;
       }
       ctx.szCol = 0;
       rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT,
@@ -228012,8 +233686,9 @@ static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol){
 
   assert( p->pConfig->bColumnsize );
   rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP_DOCSIZE, &pLookup, 0);
-  if( rc==SQLITE_OK ){
+  if( pLookup ){
     int bCorrupt = 1;
+    assert( rc==SQLITE_OK );
     sqlite3_bind_int64(pLookup, 1, iRowid);
     if( SQLITE_ROW==sqlite3_step(pLookup) ){
       const u8 *aBlob = sqlite3_column_blob(pLookup, 0);
@@ -228026,6 +233701,8 @@ static int sqlite3Fts5StorageDocsize(Fts5Storage *p, i64 iRowid, int *aCol){
     if( bCorrupt && rc==SQLITE_OK ){
       rc = FTS5_CORRUPT;
     }
+  }else{
+    assert( rc!=SQLITE_OK );
   }
 
   return rc;
@@ -230716,6 +236393,7 @@ struct Fts5VocabCursor {
 
   int bEof;                       /* True if this cursor is at EOF */
   Fts5IndexIter *pIter;           /* Term/rowid iterator object */
+  void *pStruct;                  /* From sqlite3Fts5StructureRef() */
 
   int nLeTerm;                    /* Size of zLeTerm in bytes */
   char *zLeTerm;                  /* (term <= $zLeTerm) paramater, or NULL */
@@ -231029,7 +236707,7 @@ static int fts5VocabOpenMethod(
   }
 
   if( rc==SQLITE_OK ){
-    int nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
+    i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
     pCsr = (Fts5VocabCursor*)sqlite3Fts5MallocZero(&rc, nByte);
   }
 
@@ -231049,6 +236727,8 @@ static int fts5VocabOpenMethod(
 static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
   pCsr->rowid = 0;
   sqlite3Fts5IterClose(pCsr->pIter);
+  sqlite3Fts5StructureRelease(pCsr->pStruct);
+  pCsr->pStruct = 0;
   pCsr->pIter = 0;
   sqlite3_free(pCsr->zLeTerm);
   pCsr->nLeTerm = -1;
@@ -231126,9 +236806,11 @@ static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
 static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
   Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
   Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
-  int rc = SQLITE_OK;
   int nCol = pCsr->pFts5->pConfig->nCol;
+  int rc;
 
+  rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct);
+  if( rc!=SQLITE_OK ) return rc;
   pCsr->rowid++;
 
   if( pTab->eType==FTS5_VOCAB_INSTANCE ){
@@ -231302,6 +236984,9 @@ static int fts5VocabFilterMethod(
   if( rc==SQLITE_OK ){
     Fts5Index *pIndex = pCsr->pFts5->pIndex;
     rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
+    if( rc==SQLITE_OK ){
+      pCsr->pStruct = sqlite3Fts5StructureRef(pIndex);
+    }
   }
   if( rc==SQLITE_OK && eType==FTS5_VOCAB_INSTANCE ){
     rc = fts5VocabInstanceNewTerm(pCsr);
@@ -231746,10 +237431,6 @@ SQLITE_API int sqlite3_stmt_init(
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
 
 /************** End of stmt.c ************************************************/
-#if __LINE__!=231748
-#undef SQLITE_SOURCE_ID
-#define SQLITE_SOURCE_ID      "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089falt2"
-#endif
 /* Return the source-id for this library */
 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
 /************************** End of sqlite3.c ******************************/
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h
index cc3b023bfa..6bf2c58aed 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3-binding.h
@@ -44,7 +44,30 @@ extern "C" {
 
 
 /*
-** Provide the ability to override linkage features of the interface.
+** Facilitate override of interface linkage and calling conventions.
+** Be aware that these macros may not be used within this particular
+** translation of the amalgamation and its associated header file.
+**
+** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the
+** compiler that the target identifier should have external linkage.
+**
+** The SQLITE_CDECL macro is used to set the calling convention for
+** public functions that accept a variable number of arguments.
+**
+** The SQLITE_APICALL macro is used to set the calling convention for
+** public functions that accept a fixed number of arguments.
+**
+** The SQLITE_STDCALL macro is no longer used and is now deprecated.
+**
+** The SQLITE_CALLBACK macro is used to set the calling convention for
+** function pointers.
+**
+** The SQLITE_SYSAPI macro is used to set the calling convention for
+** functions provided by the operating system.
+**
+** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and
+** SQLITE_SYSAPI macros are used only when building for environments
+** that require non-default calling conventions.
 */
 #ifndef SQLITE_EXTERN
 # define SQLITE_EXTERN extern
@@ -124,9 +147,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.34.0"
-#define SQLITE_VERSION_NUMBER 3034000
-#define SQLITE_SOURCE_ID      "2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b"
+#define SQLITE_VERSION        "3.37.0"
+#define SQLITE_VERSION_NUMBER 3037000
+#define SQLITE_SOURCE_ID      "2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -538,6 +561,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
 #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
 #define SQLITE_CONSTRAINT_PINNED       (SQLITE_CONSTRAINT |(11<<8))
+#define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))
 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
@@ -551,6 +575,19 @@ SQLITE_API int sqlite3_exec(
 ** These bit values are intended for use in the
 ** 3rd parameter to the [sqlite3_open_v2()] interface and
 ** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
+**
+** Only those flags marked as "Ok for sqlite3_open_v2()" may be
+** used as the third argument to the [sqlite3_open_v2()] interface.
+** The other flags have historically been ignored by sqlite3_open_v2(),
+** though future versions of SQLite might change so that an error is
+** raised if any of the disallowed bits are passed into sqlite3_open_v2().
+** Applications should not depend on the historical behavior.
+**
+** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into
+** [sqlite3_open_v2()] does *not* cause the underlying database file
+** to be opened using O_EXCL.  Passing SQLITE_OPEN_EXCLUSIVE into
+** [sqlite3_open_v2()] has historically be a no-op and might become an
+** error in future versions of SQLite.
 */
 #define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
@@ -573,6 +610,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
 #define SQLITE_OPEN_NOFOLLOW         0x01000000  /* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_EXRESCODE        0x02000000  /* Extended result codes */
 
 /* Reserved:                         0x00F00000 */
 /* Legacy compatibility: */
@@ -1129,6 +1167,23 @@ struct sqlite3_io_methods {
 ** file to the database file, but before the *-shm file is updated to
 ** record the fact that the pages have been checkpointed.
 ** </ul>
+**
+** <li>[[SQLITE_FCNTL_EXTERNAL_READER]]
+** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect
+** whether or not there is a database client in another process with a wal-mode
+** transaction open on the database or not. It is only available on unix.The
+** (void*) argument passed with this file-control should be a pointer to a
+** value of type (int). The integer value is set to 1 if the database is a wal
+** mode database and there exists at least one client in another process that
+** currently has an SQL transaction open on the database. It is set to 0 if
+** the database is not a wal-mode db, or if there is no such connection in any
+** other process. This opcode cannot be used to detect transactions opened
+** by clients within the current process, only within other processes.
+** </ul>
+**
+** <li>[[SQLITE_FCNTL_CKSM_FILE]]
+** Used by the cksmvfs VFS module only.
+** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
@@ -1168,6 +1223,8 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_CKPT_DONE              37
 #define SQLITE_FCNTL_RESERVE_BYTES          38
 #define SQLITE_FCNTL_CKPT_START             39
+#define SQLITE_FCNTL_EXTERNAL_READER        40
+#define SQLITE_FCNTL_CKSM_FILE              41
 
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -2116,7 +2173,13 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether triggers are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the trigger setting is not reported back. </dd>
+** which case the trigger setting is not reported back.
+**
+** <p>Originally this option disabled all triggers.  ^(However, since
+** SQLite version 3.35.0, TEMP triggers are still allowed even if
+** this option is off.  So, in other words, this option now only disables
+** triggers in the main database schema or in the schemas of ATTACH-ed
+** databases.)^ </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_VIEW]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_VIEW</dt>
@@ -2127,7 +2190,13 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether views are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the view setting is not reported back. </dd>
+** which case the view setting is not reported back.
+**
+** <p>Originally this option disabled all views.  ^(However, since
+** SQLite version 3.35.0, TEMP views are still allowed even if
+** this option is off.  So, in other words, this option now only disables
+** views in the main database schema or in the schemas of ATTACH-ed
+** databases.)^ </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
@@ -2434,11 +2503,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** CAPI3REF: Count The Number Of Rows Modified
 ** METHOD: sqlite3
 **
-** ^This function returns the number of rows modified, inserted or
+** ^These functions return the number of rows modified, inserted or
 ** deleted by the most recently completed INSERT, UPDATE or DELETE
 ** statement on the database connection specified by the only parameter.
-** ^Executing any other type of SQL statement does not modify the value
-** returned by this function.
+** The two functions are identical except for the type of the return value
+** and that if the number of rows modified by the most recent INSERT, UPDATE
+** or DELETE is greater than the maximum value supported by type "int", then
+** the return value of sqlite3_changes() is undefined. ^Executing any other
+** type of SQL statement does not modify the value returned by these functions.
 **
 ** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are
 ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
@@ -2487,16 +2559,21 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** </ul>
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
+SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
 
 /*
 ** CAPI3REF: Total Number Of Rows Modified
 ** METHOD: sqlite3
 **
-** ^This function returns the total number of rows inserted, modified or
+** ^These functions return the total number of rows inserted, modified or
 ** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
 ** since the database connection was opened, including those executed as
-** part of trigger programs. ^Executing any other type of SQL statement
-** does not affect the value returned by sqlite3_total_changes().
+** part of trigger programs. The two functions are identical except for the
+** type of the return value and that if the number of rows modified by the
+** connection exceeds the maximum value supported by type "int", then
+** the return value of sqlite3_total_changes() is undefined. ^Executing
+** any other type of SQL statement does not affect the value returned by
+** sqlite3_total_changes().
 **
 ** ^Changes made as part of [foreign key actions] are included in the
 ** count, but those made as part of REPLACE constraint resolution are
@@ -2524,6 +2601,7 @@ SQLITE_API int sqlite3_changes(sqlite3*);
 ** </ul>
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
+SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
 
 /*
 ** CAPI3REF: Interrupt A Long-Running Query
@@ -3353,6 +3431,14 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** the default shared cache setting provided by
 ** [sqlite3_enable_shared_cache()].)^
 **
+** [[OPEN_EXRESCODE]] ^(<dt>[SQLITE_OPEN_EXRESCODE]</dt>
+** <dd>The database connection comes up in "extended result code mode".
+** In other words, the database behaves has if
+** [sqlite3_extended_result_codes(db,1)] where called on the database
+** connection as soon as the connection is created. In addition to setting
+** the extended result code mode, this flag also causes [sqlite3_open_v2()]
+** to return an extended result code.</dd>
+**
 ** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
 ** <dd>The database filename is not allowed to be a symbolic link</dd>
 ** </dl>)^
@@ -3360,7 +3446,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
 ** required combinations shown above optionally combined with other
 ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
-** then the behavior is undefined.
+** then the behavior is undefined.  Historic versions of SQLite
+** have silently ignored surplus bits in the flags parameter to
+** sqlite3_open_v2(), however that behavior might not be carried through
+** into future versions of SQLite and so applications should not rely
+** upon it.  Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op
+** for sqlite3_open_v2().  The SQLITE_OPEN_EXCLUSIVE does *not* cause
+** the open to fail if the database already exists.  The SQLITE_OPEN_EXCLUSIVE
+** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not
+** by sqlite3_open_v2().
 **
 ** ^The fourth parameter to sqlite3_open_v2() is the name of the
 ** [sqlite3_vfs] object that defines the operating system interface that
@@ -3500,6 +3594,7 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **          that uses dot-files in place of posix advisory locking.
 ** <tr><td> file:data.db?mode=readonly <td>
 **          An error. "readonly" is not a valid option for the "mode" parameter.
+**          Use "ro" instead:  "file:data.db?mode=ro".
 ** </table>
 **
 ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
@@ -3698,7 +3793,7 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*);
 ** If the Y parameter to sqlite3_free_filename(Y) is anything other
 ** than a NULL pointer or a pointer previously acquired from
 ** sqlite3_create_filename(), then bad things such as heap
-** corruption or segfaults may occur. The value Y should be
+** corruption or segfaults may occur. The value Y should not be
 ** used again after sqlite3_free_filename(Y) has been called.  This means
 ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y,
 ** then the corresponding [sqlite3_module.xClose() method should also be
@@ -4127,12 +4222,17 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** are managed by SQLite and are automatically freed when the prepared
 ** statement is finalized.
 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
-** is obtained from [sqlite3_malloc()] and must be free by the application
+** is obtained from [sqlite3_malloc()] and must be freed by the application
 ** by passing it to [sqlite3_free()].
+**
+** ^The sqlite3_normalized_sql() interface is only available if
+** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined.
 */
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
+#ifdef SQLITE_ENABLE_NORMALIZE
 SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
+#endif
 
 /*
 ** CAPI3REF: Determine If An SQL Statement Writes The Database
@@ -4167,6 +4267,15 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and
 ** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so
 ** sqlite3_stmt_readonly() returns false for those commands.
+**
+** ^This routine returns false if there is any possibility that the
+** statement might change the database file.  ^A false return does
+** not guarantee that the statement will change the database file.
+** ^For example, an UPDATE statement might have a WHERE clause that
+** makes it a no-op, but the sqlite3_stmt_readonly() result would still
+** be false.  ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a
+** read-only no-op if the table already exists, but
+** sqlite3_stmt_readonly() still returns false for such a statement.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 
@@ -4336,18 +4445,22 @@ typedef struct sqlite3_context sqlite3_context;
 ** contain embedded NULs.  The result of expressions involving strings
 ** with embedded NULs is undefined.
 **
-** ^The fifth argument to the BLOB and string binding interfaces
-** is a destructor used to dispose of the BLOB or
-** string after SQLite has finished with it.  ^The destructor is called
-** to dispose of the BLOB or string even if the call to the bind API fails,
-** except the destructor is not called if the third parameter is a NULL
-** pointer or the fourth parameter is negative.
-** ^If the fifth argument is
-** the special value [SQLITE_STATIC], then SQLite assumes that the
-** information is in static, unmanaged space and does not need to be freed.
-** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
-** SQLite makes its own private copy of the data immediately, before
-** the sqlite3_bind_*() routine returns.
+** ^The fifth argument to the BLOB and string binding interfaces controls
+** or indicates the lifetime of the object referenced by the third parameter.
+** These three options exist:
+** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
+** with it may be passed. ^It is called to dispose of the BLOB or string even
+** if the call to the bind API fails, except the destructor is not called if
+** the third parameter is a NULL pointer or the fourth parameter is negative.
+** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
+** the application remains responsible for disposing of the object. ^In this
+** case, the object and the provided pointer to it must remain valid until
+** either the prepared statement is finalized or the same SQL parameter is
+** bound to something else, whichever occurs sooner.
+** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
+** object is to be copied prior to the return from sqlite3_bind_*(). ^The
+** object and pointer to it must remain valid until then. ^SQLite will then
+** manage the lifetime of its private copy.
 **
 ** ^The sixth argument to sqlite3_bind_text64() must be one of
 ** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
@@ -5089,7 +5202,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions,
 ** index expressions, or the WHERE clause of partial indexes.
 **
-** <span style="background-color:#ffff90;">
 ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for
 ** all application-defined SQL functions that do not need to be
 ** used inside of triggers, view, CHECK constraints, or other elements of
@@ -5099,7 +5211,6 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** a database file to include invocations of the function with parameters
 ** chosen by the attacker, which the application will then execute when
 ** the database file is opened and read.
-** </span>
 **
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^
@@ -6305,6 +6416,72 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 
+/*
+** CAPI3REF: Autovacuum Compaction Amount Callback
+** METHOD: sqlite3
+**
+** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback
+** function C that is invoked prior to each autovacuum of the database
+** file.  ^The callback is passed a copy of the generic data pointer (P),
+** the schema-name of the attached database that is being autovacuumed,
+** the the size of the database file in pages, the number of free pages,
+** and the number of bytes per page, respectively.  The callback should
+** return the number of free pages that should be removed by the
+** autovacuum.  ^If the callback returns zero, then no autovacuum happens.
+** ^If the value returned is greater than or equal to the number of
+** free pages, then a complete autovacuum happens.
+**
+** <p>^If there are multiple ATTACH-ed database files that are being
+** modified as part of a transaction commit, then the autovacuum pages
+** callback is invoked separately for each file.
+**
+** <p><b>The callback is not reentrant.</b> The callback function should
+** not attempt to invoke any other SQLite interface.  If it does, bad
+** things may happen, including segmentation faults and corrupt database
+** files.  The callback function should be a simple function that
+** does some arithmetic on its input parameters and returns a result.
+**
+** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional
+** destructor for the P parameter.  ^If X is not NULL, then X(P) is
+** invoked whenever the database connection closes or when the callback
+** is overwritten by another invocation of sqlite3_autovacuum_pages().
+**
+** <p>^There is only one autovacuum pages callback per database connection.
+** ^Each call to the sqlite3_autovacuum_pages() interface overrides all
+** previous invocations for that database connection.  ^If the callback
+** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer,
+** then the autovacuum steps callback is cancelled.  The return value
+** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might
+** be some other error code if something goes wrong.  The current
+** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other
+** return codes might be added in future releases.
+**
+** <p>If no autovacuum pages callback is specified (the usual case) or
+** a NULL pointer is provided for the callback,
+** then the default behavior is to vacuum all free pages.  So, in other
+** words, the default behavior is the same as if the callback function
+** were something like this:
+**
+** <blockquote><pre>
+** &nbsp;   unsigned int demonstration_autovac_pages_callback(
+** &nbsp;     void *pClientData,
+** &nbsp;     const char *zSchema,
+** &nbsp;     unsigned int nDbPage,
+** &nbsp;     unsigned int nFreePage,
+** &nbsp;     unsigned int nBytePerPage
+** &nbsp;   ){
+** &nbsp;     return nFreePage;
+** &nbsp;   }
+** </pre></blockquote>
+*/
+SQLITE_API int sqlite3_autovacuum_pages(
+  sqlite3 *db,
+  unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+  void*,
+  void(*)(void*)
+);
+
+
 /*
 ** CAPI3REF: Data Change Notification Callbacks
 ** METHOD: sqlite3
@@ -7766,7 +7943,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_PRNG_SEED               28
 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
 #define SQLITE_TESTCTRL_SEEK_COUNT              30
-#define SQLITE_TESTCTRL_LAST                    30  /* Largest TESTCTRL */
+#define SQLITE_TESTCTRL_TRACEFLAGS              31
+#define SQLITE_TESTCTRL_TUNE                    32
+#define SQLITE_TESTCTRL_LAST                    32  /* Largest TESTCTRL */
 
 /*
 ** CAPI3REF: SQL Keyword Checking
@@ -8966,8 +9145,9 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
 **
 ** A single database handle may have at most a single write-ahead log callback
 ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
-** previously registered write-ahead log callback. ^Note that the
-** [sqlite3_wal_autocheckpoint()] interface and the
+** previously registered write-ahead log callback. ^The return value is
+** a copy of the third parameter from the previous call, if any, or 0.
+** ^Note that the [sqlite3_wal_autocheckpoint()] interface and the
 ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
 ** overwrite any prior [sqlite3_wal_hook()] settings.
 */
@@ -9518,6 +9698,15 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** triggers; or 2 for changes resulting from triggers called by top-level
 ** triggers; and so forth.
 **
+** When the [sqlite3_blob_write()] API is used to update a blob column,
+** the pre-update hook is invoked with SQLITE_DELETE. This is because the
+** in this case the new values are not available. In this case, when a
+** callback made with op==SQLITE_DELETE is actuall a write using the
+** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns
+** the index of the column being written. In other cases, where the
+** pre-update hook is being invoked for some other reason, including a
+** regular DELETE, sqlite3_preupdate_blobwrite() returns -1.
+**
 ** See also:  [sqlite3_update_hook()]
 */
 #if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
@@ -9538,6 +9727,7 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);
 SQLITE_API int sqlite3_preupdate_count(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_depth(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);
+SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *);
 #endif
 
 /*
@@ -9776,8 +9966,8 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const c
 ** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory
 ** allocation error occurs.
 **
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_DESERIALIZE] option.
+** This interface is omitted if SQLite is compiled with the
+** [SQLITE_OMIT_DESERIALIZE] option.
 */
 SQLITE_API unsigned char *sqlite3_serialize(
   sqlite3 *db,           /* The database connection */
@@ -9824,12 +10014,16 @@ SQLITE_API unsigned char *sqlite3_serialize(
 ** database is currently in a read transaction or is involved in a backup
 ** operation.
 **
+** It is not possible to deserialized into the TEMP database.  If the
+** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the
+** function returns SQLITE_ERROR.
+**
 ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the
 ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
 ** [sqlite3_free()] is invoked on argument P prior to returning.
 **
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_DESERIALIZE] option.
+** This interface is omitted if SQLite is compiled with the
+** [SQLITE_OMIT_DESERIALIZE] option.
 */
 SQLITE_API int sqlite3_deserialize(
   sqlite3 *db,            /* The database connection */
@@ -10078,6 +10272,38 @@ SQLITE_API int sqlite3session_create(
 */
 SQLITE_API void sqlite3session_delete(sqlite3_session *pSession);
 
+/*
+** CAPIREF: Conigure a Session Object
+** METHOD: sqlite3_session
+**
+** This method is used to configure a session object after it has been
+** created. At present the only valid value for the second parameter is
+** [SQLITE_SESSION_OBJCONFIG_SIZE].
+**
+** Arguments for sqlite3session_object_config()
+**
+** The following values may passed as the the 4th parameter to
+** sqlite3session_object_config().
+**
+** <dt>SQLITE_SESSION_OBJCONFIG_SIZE <dd>
+**   This option is used to set, clear or query the flag that enables
+**   the [sqlite3session_changeset_size()] API. Because it imposes some
+**   computational overhead, this API is disabled by default. Argument
+**   pArg must point to a value of type (int). If the value is initially
+**   0, then the sqlite3session_changeset_size() API is disabled. If it
+**   is greater than 0, then the same API is enabled. Or, if the initial
+**   value is less than zero, no change is made. In all cases the (int)
+**   variable is set to 1 if the sqlite3session_changeset_size() API is
+**   enabled following the current call, or 0 otherwise.
+**
+**   It is an error (SQLITE_MISUSE) to attempt to modify this setting after
+**   the first table has been attached to the session object.
+*/
+SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg);
+
+/*
+*/
+#define SQLITE_SESSION_OBJCONFIG_SIZE 1
 
 /*
 ** CAPI3REF: Enable Or Disable A Session Object
@@ -10322,6 +10548,22 @@ SQLITE_API int sqlite3session_changeset(
   void **ppChangeset              /* OUT: Buffer containing changeset */
 );
 
+/*
+** CAPI3REF: Return An Upper-limit For The Size Of The Changeset
+** METHOD: sqlite3_session
+**
+** By default, this function always returns 0. For it to return
+** a useful result, the sqlite3_session object must have been configured
+** to enable this API using sqlite3session_object_config() with the
+** SQLITE_SESSION_OBJCONFIG_SIZE verb.
+**
+** When enabled, this function returns an upper limit, in bytes, for the size
+** of the changeset that might be produced if sqlite3session_changeset() were
+** called. The final changeset size might be equal to or smaller than the
+** size in bytes returned by this function.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession);
+
 /*
 ** CAPI3REF: Load The Difference Between Tables Into A Session
 ** METHOD: sqlite3_session
@@ -10439,6 +10681,14 @@ SQLITE_API int sqlite3session_patchset(
 */
 SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession);
 
+/*
+** CAPI3REF: Query for the amount of heap memory used by a session object.
+**
+** This API returns the total amount of heap memory in bytes currently
+** used by the session object passed as the only argument.
+*/
+SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
+
 /*
 ** CAPI3REF: Create An Iterator To Traverse A Changeset
 ** CONSTRUCTOR: sqlite3_changeset_iter
@@ -10541,18 +10791,23 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
 ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this
 ** is not the case, this function returns [SQLITE_MISUSE].
 **
-** If argument pzTab is not NULL, then *pzTab is set to point to a
-** nul-terminated utf-8 encoded string containing the name of the table
-** affected by the current change. The buffer remains valid until either
-** sqlite3changeset_next() is called on the iterator or until the
-** conflict-handler function returns. If pnCol is not NULL, then *pnCol is
-** set to the number of columns in the table affected by the change. If
-** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
+** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three
+** outputs are set through these pointers:
+**
+** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
+** depending on the type of change that the iterator currently points to;
+**
+** *pnCol is set to the number of columns in the table affected by the change; and
+**
+** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
+** the name of the table affected by the current change. The buffer remains
+** valid until either sqlite3changeset_next() is called on the iterator
+** or until the conflict-handler function returns.
+**
+** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
 ** is an indirect change, or false (0) otherwise. See the documentation for
 ** [sqlite3session_indirect()] for a description of direct and indirect
-** changes. Finally, if pOp is not NULL, then *pOp is set to one of
-** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the
-** type of change that the iterator currently points to.
+** changes.
 **
 ** If no error occurs, SQLITE_OK is returned. If an error does occur, an
 ** SQLite error code is returned. The values of the output variables may not
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3.go b/vendor/github.com/mattn/go-sqlite3/sqlite3.go
index d1ff406375..6ade8c9712 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3.go
@@ -21,8 +21,10 @@ package sqlite3
 #cgo CFLAGS: -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT
 #cgo CFLAGS: -Wno-deprecated-declarations
 #cgo linux,!android CFLAGS: -DHAVE_PREAD64=1 -DHAVE_PWRITE64=1
+#cgo openbsd CFLAGS: -I/usr/local/include
+#cgo openbsd LDFLAGS: -L/usr/local/lib
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
@@ -828,6 +830,10 @@ func (c *SQLiteConn) exec(ctx context.Context, query string, args []namedValue)
 		tail := s.(*SQLiteStmt).t
 		s.Close()
 		if tail == "" {
+			if res == nil {
+				// https://github.com/mattn/go-sqlite3/issues/963
+				res = &SQLiteResult{0, 0}
+			}
 			return res, nil
 		}
 		query = tail
@@ -1409,12 +1415,6 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 		return nil, errors.New("sqlite succeeded without returning a database")
 	}
 
-	rv = C.sqlite3_busy_timeout(db, C.int(busyTimeout))
-	if rv != C.SQLITE_OK {
-		C.sqlite3_close_v2(db)
-		return nil, Error{Code: ErrNo(rv)}
-	}
-
 	exec := func(s string) error {
 		cs := C.CString(s)
 		rv := C.sqlite3_exec(db, cs, nil, nil, nil)
@@ -1425,6 +1425,12 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 		return nil
 	}
 
+	// Busy timeout
+	if err := exec(fmt.Sprintf("PRAGMA busy_timeout = %d;", busyTimeout)); err != nil {
+		C.sqlite3_close_v2(db)
+		return nil, err
+	}
+
 	// USER AUTHENTICATION
 	//
 	// User Authentication is always performed even when
@@ -1676,7 +1682,7 @@ func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
 	//
 	// Because default is NORMAL this statement is always executed
 	if err := exec(fmt.Sprintf("PRAGMA synchronous = %s;", synchronousMode)); err != nil {
-		C.sqlite3_close_v2(db)
+		conn.Close()
 		return nil, err
 	}
 
@@ -2007,6 +2013,13 @@ func (s *SQLiteStmt) execSync(args []namedValue) (driver.Result, error) {
 	return &SQLiteResult{id: int64(rowid), changes: int64(changes)}, nil
 }
 
+// Readonly reports if this statement is considered readonly by SQLite.
+//
+// See: https://sqlite.org/c3ref/stmt_readonly.html
+func (s *SQLiteStmt) Readonly() bool {
+	return C.sqlite3_stmt_readonly(s.s) == 1
+}
+
 // Close the rows.
 func (rc *SQLiteRows) Close() error {
 	rc.s.mu.Lock()
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go
index 90800feeb3..7c7431dcce 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_context.go
@@ -8,7 +8,7 @@ package sqlite3
 /*
 
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go
index f2418196f6..9433fea82c 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension.go
@@ -9,7 +9,7 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go
new file mode 100644
index 0000000000..c67fa82b10
--- /dev/null
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_column_metadata.go
@@ -0,0 +1,21 @@
+// +build sqlite_column_metadata
+
+package sqlite3
+
+/*
+#ifndef USE_LIBSQLITE3
+#cgo CFLAGS: -DSQLITE_ENABLE_COLUMN_METADATA
+#include <sqlite3-binding.h>
+#else
+#include <sqlite3.h>
+#endif
+*/
+import "C"
+
+// ColumnTableName returns the table that is the origin of a particular result
+// column in a SELECT statement.
+//
+// See https://www.sqlite.org/c3ref/column_database_name.html
+func (s *SQLiteStmt) ColumnTableName(n int) string {
+	return C.GoString(C.sqlite3_column_table_name(s.s, C.int(n)))
+}
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go
index db7a666219..b2e18bbcbb 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate_hook.go
@@ -13,7 +13,7 @@ package sqlite3
 #cgo LDFLAGS: -lm
 
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c
index 1af1726b44..fc37b336c3 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.c
@@ -5,7 +5,7 @@
 
 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
 #include <stdio.h>
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 
 extern int unlock_notify_wait(sqlite3 *db);
 
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go
index 43f53e807c..adfa26c545 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go
@@ -12,7 +12,7 @@ package sqlite3
 #cgo CFLAGS: -DSQLITE_ENABLE_UNLOCK_NOTIFY
 
 #include <stdlib.h>
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 
 extern void unlock_notify_callback(void *arg, int argc);
 */
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go
index 94203b397d..b62b60840a 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go
@@ -11,7 +11,7 @@ package sqlite3
 #cgo CFLAGS: -DSQLITE_USER_AUTHENTICATION
 #cgo LDFLAGS: -lm
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go
index 8fd6cdffe7..4a93c46528 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go
@@ -19,7 +19,7 @@ package sqlite3
 #cgo CFLAGS: -Wno-deprecated-declarations
 
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
@@ -472,10 +472,21 @@ func goVBestIndex(pVTab unsafe.Pointer, icp unsafe.Pointer) *C.char {
 	}
 
 	info.idxNum = C.int(res.IdxNum)
-	idxStr := C.CString(res.IdxStr)
-	defer C.free(unsafe.Pointer(idxStr))
-	info.idxStr = idxStr
-	info.needToFreeIdxStr = C.int(0)
+	info.idxStr = (*C.char)(C.sqlite3_malloc(C.int(len(res.IdxStr) + 1)))
+	if info.idxStr == nil {
+		// C.malloc and C.CString ordinarily do this for you. See https://golang.org/cmd/cgo/
+		panic("out of memory")
+	}
+	info.needToFreeIdxStr = C.int(1)
+
+	idxStr := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
+		Data: uintptr(unsafe.Pointer(info.idxStr)),
+		Len:  len(res.IdxStr) + 1,
+		Cap:  len(res.IdxStr) + 1,
+	}))
+	copy(idxStr, res.IdxStr)
+	idxStr[len(idxStr)-1] = 0 // null-terminated string
+
 	if res.AlreadyOrdered {
 		info.orderByConsumed = C.int(1)
 	}
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go
index 4c8d9928a8..56bb91490d 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_trace.go
@@ -9,7 +9,7 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go b/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go
index b4128db4b3..0fd8210bb6 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3_type.go
@@ -1,5 +1,4 @@
 // Copyright (C) 2019 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
-//
 // Use of this source code is governed by an MIT-style
 // license that can be found in the LICENSE file.
 
@@ -7,15 +6,16 @@ package sqlite3
 
 /*
 #ifndef USE_LIBSQLITE3
-#include <sqlite3-binding.h>
+#include "sqlite3-binding.h"
 #else
 #include <sqlite3.h>
 #endif
 */
 import "C"
 import (
+	"database/sql"
 	"reflect"
-	"time"
+	"strings"
 )
 
 // ColumnTypeDatabaseTypeName implement RowsColumnTypeDatabaseTypeName.
@@ -31,32 +31,78 @@ func (rc *SQLiteRows) ColumnTypeLength(index int) (length int64, ok bool) {
 func (rc *SQLiteRows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) {
 	return 0, 0, false
 }
+*/
 
 // ColumnTypeNullable implement RowsColumnTypeNullable.
 func (rc *SQLiteRows) ColumnTypeNullable(i int) (nullable, ok bool) {
-	return false, false
+	return true, true
 }
-*/
 
 // ColumnTypeScanType implement RowsColumnTypeScanType.
 func (rc *SQLiteRows) ColumnTypeScanType(i int) reflect.Type {
-	switch C.sqlite3_column_type(rc.s.s, C.int(i)) {
-	case C.SQLITE_INTEGER:
-		switch C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))) {
-		case "timestamp", "datetime", "date":
-			return reflect.TypeOf(time.Time{})
-		case "boolean":
-			return reflect.TypeOf(false)
-		}
-		return reflect.TypeOf(int64(0))
-	case C.SQLITE_FLOAT:
-		return reflect.TypeOf(float64(0))
-	case C.SQLITE_BLOB:
-		return reflect.SliceOf(reflect.TypeOf(byte(0)))
-	case C.SQLITE_NULL:
-		return reflect.TypeOf(nil)
-	case C.SQLITE_TEXT:
-		return reflect.TypeOf("")
-	}
-	return reflect.SliceOf(reflect.TypeOf(byte(0)))
+	//ct := C.sqlite3_column_type(rc.s.s, C.int(i))  // Always returns 5
+	return scanType(C.GoString(C.sqlite3_column_decltype(rc.s.s, C.int(i))))
+}
+
+const (
+	SQLITE_INTEGER = iota
+	SQLITE_TEXT
+	SQLITE_BLOB
+	SQLITE_REAL
+	SQLITE_NUMERIC
+	SQLITE_TIME
+	SQLITE_BOOL
+	SQLITE_NULL
+)
+
+func scanType(cdt string) reflect.Type {
+	t := strings.ToUpper(cdt)
+	i := databaseTypeConvSqlite(t)
+	switch i {
+	case SQLITE_INTEGER:
+		return reflect.TypeOf(sql.NullInt64{})
+	case SQLITE_TEXT:
+		return reflect.TypeOf(sql.NullString{})
+	case SQLITE_BLOB:
+		return reflect.TypeOf(sql.RawBytes{})
+	case SQLITE_REAL:
+		return reflect.TypeOf(sql.NullFloat64{})
+	case SQLITE_NUMERIC:
+		return reflect.TypeOf(sql.NullFloat64{})
+	case SQLITE_BOOL:
+		return reflect.TypeOf(sql.NullBool{})
+	case SQLITE_TIME:
+		return reflect.TypeOf(sql.NullTime{})
+	}
+	return reflect.TypeOf(new(interface{}))
+}
+
+func databaseTypeConvSqlite(t string) int {
+	if strings.Contains(t, "INT") {
+		return SQLITE_INTEGER
+	}
+	if t == "CLOB" || t == "TEXT" ||
+		strings.Contains(t, "CHAR") {
+		return SQLITE_TEXT
+	}
+	if t == "BLOB" {
+		return SQLITE_BLOB
+	}
+	if t == "REAL" || t == "FLOAT" ||
+		strings.Contains(t, "DOUBLE") {
+		return SQLITE_REAL
+	}
+	if t == "DATE" || t == "DATETIME" ||
+		t == "TIMESTAMP" {
+		return SQLITE_TIME
+	}
+	if t == "NUMERIC" ||
+		strings.Contains(t, "DECIMAL") {
+		return SQLITE_NUMERIC
+	}
+	if t == "BOOLEAN" {
+		return SQLITE_BOOL
+	}
+
+	return SQLITE_NULL
 }
diff --git a/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h b/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h
index b2b6e0c8dd..fd6e2d4e86 100644
--- a/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h
+++ b/vendor/github.com/mattn/go-sqlite3/sqlite3ext.h
@@ -19,6 +19,10 @@
 #ifndef SQLITE3EXT_H
 #define SQLITE3EXT_H
 #include "sqlite3-binding.h"
+#ifdef __clang__
+#define assert(condition) ((void)0)
+#endif
+
 
 /*
 ** The following structure holds pointers to all of the SQLite API
@@ -338,6 +342,13 @@ struct sqlite3_api_routines {
   sqlite3_file *(*database_file_object)(const char*);
   /* Version 3.34.0 and later */
   int (*txn_state)(sqlite3*,const char*);
+  /* Version 3.36.1 and later */
+  sqlite3_int64 (*changes64)(sqlite3*);
+  sqlite3_int64 (*total_changes64)(sqlite3*);
+  /* Version 3.37.0 and later */
+  int (*autovacuum_pages)(sqlite3*,
+     unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
+     void*, void(*)(void*));
 };
 
 /*
@@ -644,6 +655,11 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_database_file_object   sqlite3_api->database_file_object
 /* Version 3.34.0 and later */
 #define sqlite3_txn_state              sqlite3_api->txn_state
+/* Version 3.36.1 and later */
+#define sqlite3_changes64              sqlite3_api->changes64
+#define sqlite3_total_changes64        sqlite3_api->total_changes64
+/* Version 3.37.0 and later */
+#define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go
index 78f0acc70c..04e87771d4 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/catalog/main.go
@@ -69,7 +69,7 @@ var (
 	tlsCertPath = flag.String(
 		"tls-cert", "", "Path to use for certificate key (requires tls-key)")
 
-	profiling = flag.Bool("profiling", false, "deprecated")
+	_ = flag.Bool("profiling", false, "deprecated")
 
 	clientCAPath = flag.String("client-ca", "", "path to watch for client ca bundle")
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go
index dd67a27a79..c3b73728f0 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/main.go
@@ -63,7 +63,7 @@ var (
 	tlsCertPath = pflag.String(
 		"tls-cert", "", "Path to use for certificate key (requires tls-key)")
 
-	profiling = pflag.Bool("profiling", false, "deprecated")
+	_ = pflag.Bool("profiling", false, "deprecated")
 
 	clientCAPath = pflag.String("client-ca", "", "path to watch for client ca bundle")
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go
index 5e8e33ab73..36b0d6b8f9 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/cmd/olm/manager.go
@@ -118,7 +118,6 @@ func Manager(ctx context.Context, debug bool) (ctrl.Manager, error) {
 		if err = adoptionReconciler.SetupWithManager(mgr); err != nil {
 			return nil, err
 		}
-
 	}
 	setupLog.Info("manager configured")
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
index f30f610c61..55665aada6 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/bundle/bundle_unpacker.go
@@ -384,7 +384,6 @@ const (
 )
 
 func (c *ConfigMapUnpacker) UnpackBundle(lookup *operatorsv1alpha1.BundleLookup, timeout time.Duration) (result *BundleUnpackResult, err error) {
-
 	result = newBundleUnpackResult(lookup)
 
 	// if bundle lookup failed condition already present, then there is nothing more to do
@@ -523,8 +522,8 @@ func (c *ConfigMapUnpacker) pendingContainerStatusMessages(job *batchv1.Job) (st
 	podLabel := map[string]string{BundleUnpackPodLabel: job.GetName()}
 	pods, listErr := c.podLister.Pods(job.GetNamespace()).List(k8slabels.SelectorFromValidatedSet(podLabel))
 	if listErr != nil {
-		c.logger.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr)
-		return "", fmt.Errorf("Failed to list pods for job(%s): %v", job.GetName(), listErr)
+		c.logger.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr)
+		return "", fmt.Errorf("failed to list pods for job(%s): %v", job.GetName(), listErr)
 	}
 
 	// Ideally there should be just 1 pod running but inspect all pods in the pending phase
@@ -570,14 +569,14 @@ func (c *ConfigMapUnpacker) ensureConfigmap(csRef *corev1.ObjectReference, name
 		if err != nil && apierrors.IsAlreadyExists(err) {
 			cm, err = c.client.CoreV1().ConfigMaps(fresh.GetNamespace()).Get(context.TODO(), fresh.GetName(), metav1.GetOptions{})
 			if err != nil {
-				return nil, fmt.Errorf("Failed to retrieve configmap %s: %v", fresh.GetName(), err)
+				return nil, fmt.Errorf("failed to retrieve configmap %s: %v", fresh.GetName(), err)
 			}
 			cm.SetLabels(map[string]string{
 				install.OLMManagedLabelKey: install.OLMManagedLabelValue,
 			})
 			cm, err = c.client.CoreV1().ConfigMaps(cm.GetNamespace()).Update(context.TODO(), cm, metav1.UpdateOptions{})
 			if err != nil {
-				return nil, fmt.Errorf("Failed to update configmap %s: %v", cm.GetName(), err)
+				return nil, fmt.Errorf("failed to update configmap %s: %v", cm.GetName(), err)
 			}
 		}
 	}
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go
index c54a1f8ed6..1f1061c43b 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/apiservice.go
@@ -44,7 +44,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateAPIService(caPEM []byte, des
 		apiService = apiService.DeepCopy()
 		csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 		if !ok {
-			return fmt.Errorf("APIServices require a CSV Owner.")
+			return fmt.Errorf("failed to typecast the APIService owner: APIServices require a CSV owner")
 		}
 
 		adoptable, err := IsAPIServiceAdoptable(i.strategyClient.GetOpLister(), csv, apiService)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go
index 49fd37f97f..9f368809c2 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/certresources.go
@@ -315,7 +315,6 @@ func (i *StrategyDeploymentInstaller) installCertRequirementsForDeployment(deplo
 			logger.Warnf("could not update secret %s", secret.GetName())
 			return nil, nil, err
 		}
-
 	} else if k8serrors.IsNotFound(err) {
 		// Create the secret
 		ownerutil.AddNonBlockingOwner(secret, i.owner)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go
index d458bf3469..61adbb623b 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/deployment.go
@@ -179,23 +179,6 @@ func (i *StrategyDeploymentInstaller) deploymentForSpec(name string, spec appsv1
 	return
 }
 
-func (i *StrategyDeploymentInstaller) cleanupPrevious(current *v1alpha1.StrategyDetailsDeployment, previous *v1alpha1.StrategyDetailsDeployment) error {
-	previousDeploymentsMap := map[string]struct{}{}
-	for _, d := range previous.DeploymentSpecs {
-		previousDeploymentsMap[d.Name] = struct{}{}
-	}
-	for _, d := range current.DeploymentSpecs {
-		delete(previousDeploymentsMap, d.Name)
-	}
-	log.Debugf("preparing to cleanup: %s", previousDeploymentsMap)
-	// delete deployments in old strategy but not new
-	var err error = nil
-	for name := range previousDeploymentsMap {
-		err = i.strategyClient.DeleteDeployment(name)
-	}
-	return err
-}
-
 func (i *StrategyDeploymentInstaller) Install(s Strategy) error {
 	strategy, ok := s.(*v1alpha1.StrategyDetailsDeployment)
 	if !ok {
@@ -235,11 +218,6 @@ func (i *StrategyDeploymentInstaller) CheckInstalled(s Strategy) (installed bool
 }
 
 func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1alpha1.StrategyDeploymentSpec) error {
-	var depNames []string
-	for _, dep := range deploymentSpecs {
-		depNames = append(depNames, dep.Name)
-	}
-
 	// Check the owner is a CSV
 	csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 	if !ok {
@@ -273,7 +251,7 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al
 
 		// check annotations
 		if len(i.templateAnnotations) > 0 && dep.Spec.Template.Annotations == nil {
-			return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: fmt.Sprintf("no annotations found on deployment")}
+			return StrategyError{Reason: StrategyErrReasonAnnotationsMissing, Message: "no annotations found on deployment"}
 		}
 		for key, value := range i.templateAnnotations {
 			if actualValue, ok := dep.Spec.Template.Annotations[key]; !ok {
@@ -286,11 +264,11 @@ func (i *StrategyDeploymentInstaller) checkForDeployments(deploymentSpecs []v1al
 		// check that the deployment spec hasn't changed since it was created
 		labels := dep.GetLabels()
 		if len(labels) == 0 {
-			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")}
+			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)}
 		}
 		existingDeploymentSpecHash, ok := labels[DeploymentSpecHashLabelKey]
 		if !ok {
-			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment doesn't have a spec hash, update it")}
+			return StrategyError{Reason: StrategyErrDeploymentUpdated, Message: fmt.Sprintf("deployment %s doesn't have a spec hash, update it", dep.Name)}
 		}
 
 		_, calculatedDeploymentHash, err := i.deploymentForSpec(spec.Name, spec.Spec, labels)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
index b1550776d5..88dd64037f 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/rule_checker.go
@@ -67,7 +67,6 @@ func (c *CSVRuleChecker) RuleSatisfied(sa *corev1.ServiceAccount, namespace stri
 		if decision == authorizer.DecisionDeny || decision == authorizer.DecisionNoOpinion {
 			return false, nil
 		}
-
 	}
 
 	return true, nil
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go
index c1dd4a1252..74c1987516 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/install/webhook.go
@@ -24,18 +24,18 @@ func ValidWebhookRules(rules []admissionregistrationv1.RuleWithOperations) error
 
 		// protect OLM resources
 		if contains(apiGroupMap, "*") {
-			return fmt.Errorf("Webhook rules cannot include all groups")
+			return fmt.Errorf("webhook rules cannot include all groups")
 		}
 
 		if contains(apiGroupMap, "operators.coreos.com") {
-			return fmt.Errorf("Webhook rules cannot include the OLM group")
+			return fmt.Errorf("webhook rules cannot include the OLM group")
 		}
 
 		// protect Admission Webhook resources
 		if contains(apiGroupMap, "admissionregistration.k8s.io") {
 			resourceGroupMap := listToMap(rule.Resources)
 			if contains(resourceGroupMap, "*") || contains(resourceGroupMap, "MutatingWebhookConfiguration") || contains(resourceGroupMap, "ValidatingWebhookConfiguration") {
-				return fmt.Errorf("Webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")
+				return fmt.Errorf("webhook rules cannot include MutatingWebhookConfiguration or ValidatingWebhookConfiguration resources")
 			}
 		}
 	}
@@ -58,7 +58,7 @@ func contains(m map[string]struct{}, tar string) bool {
 func (i *StrategyDeploymentInstaller) createOrUpdateWebhook(caPEM []byte, desc v1alpha1.WebhookDescription) error {
 	operatorGroups, err := i.strategyClient.GetOpLister().OperatorsV1().OperatorGroupLister().OperatorGroups(i.owner.GetNamespace()).List(labels.Everything())
 	if err != nil || len(operatorGroups) != 1 {
-		return fmt.Errorf("Error retrieving OperatorGroup info")
+		return fmt.Errorf("error retrieving OperatorGroup info")
 	}
 	ogNamespacelabelSelector, err := operatorGroups[0].NamespaceLabelSelector()
 	if err != nil {
@@ -190,15 +190,14 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 	// get a list of owned CRDs
 	csv, ok := i.owner.(*v1alpha1.ClusterServiceVersion)
 	if !ok {
-		return fmt.Errorf("ConversionWebhook owner must be a ClusterServiceVersion")
+		return fmt.Errorf("unable to manage conversion webhook: conversion webhook owner must be a ClusterServiceVersion")
 	}
-
 	if !isSingletonOperator(*csv) {
-		return fmt.Errorf("CSVs with conversion webhooks must support only AllNamespaces")
+		return fmt.Errorf("unable to manage conversion webhook: CSVs with conversion webhooks must support only AllNamespaces")
 	}
 
 	if len(desc.ConversionCRDs) == 0 {
-		return fmt.Errorf("Conversion Webhook must have at least one CRD specified")
+		return fmt.Errorf("unable to manager conversion webhook: conversion webhook must have at least one CRD specified")
 	}
 
 	// iterate over all the ConversionCRDs
@@ -207,7 +206,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 			// Get existing CRD on cluster
 			crd, err := i.strategyClient.GetOpClient().ApiextensionsInterface().ApiextensionsV1().CustomResourceDefinitions().Get(context.TODO(), conversionCRD, metav1.GetOptions{})
 			if err != nil {
-				return fmt.Errorf("Unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err)
+				return fmt.Errorf("unable to get CRD %s specified in Conversion Webhook: %v", conversionCRD, err)
 			}
 
 			// check if this CRD is an owned CRD
@@ -219,7 +218,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 				}
 			}
 			if !foundCRD {
-				return fmt.Errorf("CSV %s does not own CRD %s", csv.GetName(), conversionCRD)
+				return fmt.Errorf("csv %s does not own CRD %s", csv.GetName(), conversionCRD)
 			}
 
 			// crd.Spec.Conversion.Strategy specifies how custom resources are converted between versions.
@@ -232,7 +231,7 @@ func (i *StrategyDeploymentInstaller) createOrUpdateConversionWebhook(caPEM []by
 			// By default the strategy is none
 			// Reference:
 			// 	- https://v1-15.docs.kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definition-versioning/#specify-multiple-versions
-			if crd.Spec.PreserveUnknownFields != false {
+			if crd.Spec.PreserveUnknownFields {
 				return fmt.Errorf("crd.Spec.PreserveUnknownFields must be false to let API Server call webhook to do the conversion")
 			}
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
index 8fb18ed92f..f0cd672893 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/adoption_controller.go
@@ -37,7 +37,6 @@ type AdoptionReconciler struct {
 	client.Client
 
 	log     logr.Logger
-	mu      sync.RWMutex
 	factory decorators.OperatorFactory
 }
 
@@ -268,7 +267,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 
 	if err := r.Get(ctx, types.NamespacedName{Namespace: m.GetNamespace(), Name: m.GetName()}, cObj); err != nil {
@@ -290,7 +289,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 		// Only update if freshly adopted
 		pCObj, ok := candidate.(client.Object)
 		if !ok {
-			return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+			return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 		}
 		return r.Patch(ctx, pCObj, client.MergeFrom(cObj))
 	}
@@ -301,7 +300,7 @@ func (r *AdoptionReconciler) adopt(ctx context.Context, operator *decorators.Ope
 func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Operator, component runtime.Object) error {
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	candidate := component.DeepCopyObject()
 	disowned, err := operator.DisownComponent(candidate)
@@ -318,7 +317,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op
 	r.log.V(1).Info("component disowned", "component", candidate)
 	uCObj, ok := candidate.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	return r.Patch(ctx, uCObj, client.MergeFrom(cObj))
 }
@@ -326,7 +325,7 @@ func (r *AdoptionReconciler) disown(ctx context.Context, operator *decorators.Op
 func (r *AdoptionReconciler) disownFromAll(ctx context.Context, component runtime.Object) error {
 	cObj, ok := component.(client.Object)
 	if !ok {
-		return fmt.Errorf("Unable to typecast runtime.Object to client.Object")
+		return fmt.Errorf("unable to typecast runtime.Object to client.Object")
 	}
 	var operators []decorators.Operator
 	for _, name := range decorators.OperatorNames(cObj.GetLabels()) {
@@ -362,7 +361,7 @@ func (r *AdoptionReconciler) adoptees(ctx context.Context, operator decorators.O
 	for _, list := range componentLists {
 		cList, ok := list.(client.ObjectList)
 		if !ok {
-			return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList")
+			return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList")
 		}
 		if err := r.List(ctx, cList, opt); err != nil {
 			return nil, err
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
index a749a9c114..a4ca7f8ff6 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/operator.go
@@ -552,8 +552,6 @@ func (o *Operator) handleDeletion(obj interface{}) {
 	}).Debug("handling object deletion")
 
 	o.requeueOwners(metaObj)
-
-	return
 }
 
 func (o *Operator) handleCatSrcDeletion(obj interface{}) {
@@ -562,13 +560,13 @@ func (o *Operator) handleCatSrcDeletion(obj interface{}) {
 		if !ok {
 			tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
 			if !ok {
-				utilruntime.HandleError(fmt.Errorf("Couldn't get object from tombstone %#v", obj))
+				utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
 				return
 			}
 
 			catsrc, ok = tombstone.Obj.(metav1.Object)
 			if !ok {
-				utilruntime.HandleError(fmt.Errorf("Tombstone contained object that is not a Namespace %#v", obj))
+				utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
 				return
 			}
 		}
@@ -716,11 +714,10 @@ func (o *Operator) syncRegistryServer(logger *logrus.Entry, in *v1alpha1.Catalog
 			logger.Debug("requeueing registry server for catalog update check: update pod not yet ready")
 			o.catsrcQueueSet.RequeueAfter(out.GetNamespace(), out.GetName(), reconciler.CatalogPollingRequeuePeriod)
 			return
-		} else {
-			syncError = fmt.Errorf("couldn't ensure registry server - %v", err)
-			out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError)
-			return
 		}
+		syncError = fmt.Errorf("couldn't ensure registry server - %v", err)
+		out.SetError(v1alpha1.CatalogSourceRegistryServerError, syncError)
+		return
 	}
 
 	logger.Debug("ensured registry server")
@@ -785,8 +782,6 @@ func (o *Operator) syncConnection(logger *logrus.Entry, in *v1alpha1.CatalogSour
 		return
 	}
 
-	logger = logger.WithField("address", address).WithField("currentSource", sourceKey)
-
 	if source.Address != address {
 		source, syncError = connectFunc()
 		if syncError != nil {
@@ -1531,22 +1526,21 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		}
 		syncError = ipFailError
 		return
-	} else {
-		// reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps
-		// (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after
-		// the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would
-		// be confusing to the user
-
-		// NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is
-		// true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as
-		// InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere
-		// is not being unset here unintentionally.
-		if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed {
-			plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger)
-			if err != nil {
-				syncError = err
-				return
-			}
+	}
+	// reset condition/message if it had been set in previous sync. This condition is being reset since any delay in the next steps
+	// (bundle unpacking/plan step errors being retried for a duration) could lead to this condition sticking around, even after
+	// the serviceAccountQuerier returns no error since the error has been resolved (by creating the required resources), which would
+	// be confusing to the user
+
+	// NOTE: this makes the assumption that the InstallPlanInstalledCheckFailed reason is only set in the previous if clause, which is
+	// true in the current iteration of the catalog operator. Any future implementation change that aims at setting the reason as
+	// InstallPlanInstalledCheckFailed must make sure that either this assumption is not breached, or the condition being set elsewhere
+	// is not being unset here unintentionally.
+	if cond := out.Status.GetCondition(v1alpha1.InstallPlanInstalled); cond.Reason == v1alpha1.InstallPlanReasonInstallCheckFailed {
+		plan, err = o.setInstallPlanInstalledCond(out, v1alpha1.InstallPlanConditionReason(corev1.ConditionUnknown), "", logger)
+		if err != nil {
+			syncError = err
+			return
 		}
 	}
 
@@ -1588,7 +1582,7 @@ func (o *Operator) syncInstallPlans(obj interface{}) (syncError error) {
 		// which means bundle lookup has failed and the InstallPlan should be failed as well
 		isFailed, cond := hasBundleLookupFailureCondition(plan)
 		if isFailed {
-			err := fmt.Errorf("Bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message)
+			err := fmt.Errorf("bundle unpacking failed. Reason: %v, and Message: %v", cond.Reason, cond.Message)
 			// Mark the InstallPlan as failed for a fatal bundle unpack error
 			logger.Infof("%v", err)
 
@@ -1672,7 +1666,7 @@ func (o *Operator) transitionInstallPlanToFailed(plan *v1alpha1.InstallPlan, log
 	logger.Errorf("error transitioning InstallPlan to failed")
 
 	// retry sync with error to update InstallPlan status
-	return fmt.Errorf("InstallPlan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr)
+	return fmt.Errorf("installplan failed: %s and error updating InstallPlan status as failed: %s", message, updateErr)
 }
 
 func (o *Operator) requeueSubscriptionForInstallPlan(plan *v1alpha1.InstallPlan, logger *logrus.Entry) {
@@ -1869,7 +1863,7 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error {
 	// Get the set of initial installplan csv names
 	initialCSVNames := getCSVNameSet(plan)
 	// Get pre-existing CRD owners to make decisions about applying resolved CSVs
-	existingCRDOwners, err := o.getExistingApiOwners(plan.GetNamespace())
+	existingCRDOwners, err := o.getExistingAPIOwners(plan.GetNamespace())
 	if err != nil {
 		return err
 	}
@@ -2330,8 +2324,8 @@ func (o *Operator) ExecutePlan(plan *v1alpha1.InstallPlan) error {
 	return nil
 }
 
-// getExistingApiOwners creates a map of CRD names to existing owner CSVs in the given namespace
-func (o *Operator) getExistingApiOwners(namespace string) (map[string][]string, error) {
+// getExistingAPIOwners creates a map of CRD names to existing owner CSVs in the given namespace
+func (o *Operator) getExistingAPIOwners(namespace string) (map[string][]string, error) {
 	// Get a list of CSVs in the namespace
 	csvList, err := o.client.OperatorsV1alpha1().ClusterServiceVersions(namespace).List(context.TODO(), metav1.ListOptions{})
 
@@ -2445,7 +2439,7 @@ func (o *Operator) apiresourceFromGVK(gvk schema.GroupVersionKind) (metav1.APIRe
 		}
 	}
 	logger.Info("couldn't find GVK in api discovery")
-	return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{gvk.Group, gvk.Version, gvk.Kind}
+	return metav1.APIResource{}, olmerrors.GroupVersionKindNotFoundError{Group: gvk.Group, Version: gvk.Version, Kind: gvk.Kind}
 }
 
 const (
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
index 1093c1ddd1..a6a80bfaff 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/step.go
@@ -102,9 +102,8 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter
 			if err != nil {
 				if k8serrors.IsNotFound(err) {
 					return v1alpha1.StepStatusNotPresent, nil
-				} else {
-					return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name)
 				}
+				return v1alpha1.StepStatusNotPresent, errors.Wrapf(err, "error finding the %s CRD", crd.Name)
 			}
 			established, namesAccepted := false, false
 			for _, cdt := range crd.Status.Conditions {
@@ -167,7 +166,7 @@ func (b *builder) NewCRDV1Step(client apiextensionsv1client.ApiextensionsV1Inter
 				// Unexpected error creating the CRD.
 				return v1alpha1.StepStatusUnknown, createError
 			}
-			// If no error occured, make sure to wait for the API to become available.
+			// If no error occurred, make sure to wait for the API to become available.
 			return v1alpha1.StepStatusWaitingForAPI, nil
 		}
 		return v1alpha1.StepStatusUnknown, nil
@@ -186,9 +185,8 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi
 			if err != nil {
 				if k8serrors.IsNotFound(err) {
 					return v1alpha1.StepStatusNotPresent, nil
-				} else {
-					return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err)
 				}
+				return v1alpha1.StepStatusNotPresent, fmt.Errorf("error finding the %q CRD: %w", crd.Name, err)
 			}
 			established, namesAccepted := false, false
 			for _, cdt := range crd.Status.Conditions {
@@ -252,7 +250,7 @@ func (b *builder) NewCRDV1Beta1Step(client apiextensionsv1beta1client.Apiextensi
 				// Unexpected error creating the CRD.
 				return v1alpha1.StepStatusUnknown, createError
 			}
-			// If no error occured, make sure to wait for the API to become available.
+			// If no error occurred, make sure to wait for the API to become available.
 			return v1alpha1.StepStatusWaitingForAPI, nil
 		}
 		return v1alpha1.StepStatusUnknown, nil
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
index 024cb3dd96..92cba65c58 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscription/state.go
@@ -243,7 +243,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha
 	var known CatalogHealthKnownState
 	switch {
 	case missingTargeted:
-		healthy = false
 		cond.Message = fmt.Sprintf("targeted catalogsource %s/%s missing", in.Spec.CatalogSourceNamespace, in.Spec.CatalogSource)
 		fallthrough
 	case !healthy:
@@ -273,7 +272,6 @@ func (c *catalogHealthState) UpdateHealth(now *metav1.Time, client clientv1alpha
 	case numNew < numOld:
 		cond.Reason = v1alpha1.CatalogSourcesDeleted
 	case numNew == 0 && numNew == numOld:
-		healthy = false
 		cond.Reason = v1alpha1.NoCatalogSourcesFound
 		cond.Message = "dependency resolution requires at least one catalogsource"
 	case numNew == numOld:
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go
deleted file mode 100644
index 298e0e3232..0000000000
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalog/subscriptions.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package catalog
-
-import (
-	"errors"
-
-	"github.com/operator-framework/api/pkg/operators/v1alpha1"
-)
-
-var (
-	ErrNilSubscription = errors.New("invalid Subscription object: <nil>")
-)
-
-const (
-	PackageLabel          = "olm.package"
-	CatalogLabel          = "olm.catalog"
-	CatalogNamespaceLabel = "olm.catalog.namespace"
-	ChannelLabel          = "olm.channel"
-)
-
-func labelsForSubscription(sub *v1alpha1.Subscription) map[string]string {
-	return map[string]string{
-		PackageLabel:          sub.Spec.Package,
-		CatalogLabel:          sub.Spec.CatalogSource,
-		CatalogNamespaceLabel: sub.Spec.CatalogSourceNamespace,
-		ChannelLabel:          sub.Spec.Channel,
-	}
-}
-
-// TODO remove this once UI no longer needs them
-func legacyLabelsForSubscription(sub *v1alpha1.Subscription) map[string]string {
-	return map[string]string{
-		"alm-package": sub.Spec.Package,
-		"alm-catalog": sub.Spec.CatalogSource,
-		"alm-channel": sub.Spec.Channel,
-	}
-}
-
-func ensureLabels(sub *v1alpha1.Subscription) *v1alpha1.Subscription {
-	labels := sub.GetLabels()
-	if labels == nil {
-		labels = map[string]string{}
-	}
-	for k, v := range labelsForSubscription(sub) {
-		labels[k] = v
-	}
-	for k, v := range legacyLabelsForSubscription(sub) {
-		labels[k] = v
-	}
-	sub.SetLabels(labels)
-	return sub
-}
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
index c91dc7c90e..ad50cc3018 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/catalogtemplate/operator.go
@@ -175,7 +175,6 @@ func (o *Operator) syncCatalogSources(obj interface{}) error {
 
 		// make sure that the processed image reference is actually different
 		if outputCatalogSource.Spec.Image != processedCatalogImageTemplate {
-
 			outputCatalogSource.Spec.Image = processedCatalogImageTemplate
 
 			if err := catalogsource.UpdateSpecAndStatusConditions(logger, o.client, outputCatalogSource, conditions...); err != nil {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
index 4046f7ee09..612a8a6244 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/decorators/operator.go
@@ -22,9 +22,9 @@ import (
 )
 
 const (
-	newOperatorError       = "Cannot create new Operator: %s"
-	newComponentError      = "Cannot create new Component: %s"
-	componentLabelKeyError = "Cannot generate component label key: %s"
+	newOperatorError       = "cannot create new Operator: %s"
+	newComponentError      = "cannot create new Component: %s"
+	componentLabelKeyError = "cannot generate component label key: %s"
 
 	// ComponentLabelKeyPrefix is the key prefix used for labels marking operator component resources.
 	ComponentLabelKeyPrefix = "operators.coreos.com/"
@@ -295,7 +295,7 @@ func (o *Operator) AddComponents(components ...runtime.Object) error {
 		if matches, err := component.Matches(selector); err != nil {
 			return err
 		} else if !matches {
-			return fmt.Errorf("Cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String())
+			return fmt.Errorf("cannot add component %s/%s/%s to Operator %s: component labels not selected by %s", component.GetKind(), component.GetNamespace(), component.GetName(), o.GetName(), selector.String())
 		}
 
 		ref, err := component.Reference()
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
index 88a93fd1b4..79e79179af 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/apiservices.go
@@ -88,7 +88,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		// Check if the APIService points to the correct service
 		if apiService.Spec.Service.Name != serviceName || apiService.Spec.Service.Namespace != csv.GetNamespace() {
 			logger.WithFields(log.Fields{"service": apiService.Spec.Service.Name, "serviceNamespace": apiService.Spec.Service.Namespace}).Warnf("APIService service reference mismatch")
-			errs = append(errs, fmt.Errorf("APIService service reference mismatch"))
+			errs = append(errs, fmt.Errorf("found APIService and service reference mismatch"))
 			continue
 		}
 
@@ -102,7 +102,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if !certs.Active(ca) {
 			logger.Warnf("CA cert not active")
-			errs = append(errs, fmt.Errorf("CA cert not active"))
+			errs = append(errs, fmt.Errorf("found the CA cert is not active"))
 			continue
 		}
 
@@ -122,7 +122,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if !certs.Active(cert) {
 			logger.Warnf("serving cert not active")
-			errs = append(errs, fmt.Errorf("serving cert not active"))
+			errs = append(errs, fmt.Errorf("found the serving cert not active"))
 			continue
 		}
 
@@ -155,7 +155,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 		}
 		if hash, ok := deployment.Spec.Template.GetAnnotations()[install.OLMCAHashAnnotationKey]; !ok || hash != caHash {
 			logger.WithField("deployment", desc.DeploymentName).Warnf("Deployment CA cert hash does not match expected")
-			errs = append(errs, fmt.Errorf("Deployment %s CA cert hash does not match expected", desc.DeploymentName))
+			errs = append(errs, fmt.Errorf("deployment %s CA cert hash does not match expected", desc.DeploymentName))
 			continue
 		}
 
@@ -214,7 +214,7 @@ func (a *Operator) checkAPIServiceResources(csv *v1alpha1.ClusterServiceVersion,
 				}
 				if !satisfied {
 					logger.WithField("rule", fmt.Sprintf("%+v", rule)).Warnf("Rule not satisfied")
-					errs = append(errs, fmt.Errorf("Rule %+v not satisfied", rule))
+					errs = append(errs, fmt.Errorf("rule %+v not satisfied", rule))
 					continue
 				}
 			}
@@ -260,7 +260,7 @@ func (a *Operator) getAPIServiceCABundle(csv *v1alpha1.ClusterServiceVersion, de
 		return apiService.Spec.CABundle, nil
 	}
 
-	return nil, fmt.Errorf("Unable to find ca")
+	return nil, fmt.Errorf("unable to find CA")
 }
 
 // getWebhookCABundle returns the CA associated with a webhook
@@ -303,13 +303,13 @@ func (a *Operator) getWebhookCABundle(csv *v1alpha1.ClusterServiceVersion, desc
 		}
 	}
 
-	return nil, fmt.Errorf("Unable to find ca")
+	return nil, fmt.Errorf("unable to find CA")
 }
 
-// updateDeploymentSpecsWithApiServiceData transforms an install strategy to include information about apiservices
+// updateDeploymentSpecsWithAPIServiceData transforms an install strategy to include information about apiservices
 // it is used in generating hashes for deployment specs to know when something in the spec has changed,
 // but duplicates a lot of installAPIServiceRequirements and should be refactored.
-func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) {
+func (a *Operator) updateDeploymentSpecsWithAPIServiceData(csv *v1alpha1.ClusterServiceVersion, strategy install.Strategy) (install.Strategy, error) {
 	// Assume the strategy is for a deployment
 	strategyDetailsDeployment, ok := strategy.(*v1alpha1.StrategyDetailsDeployment)
 	if !ok {
@@ -335,7 +335,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 
 		depSpec, ok := depSpecs[desc.DeploymentName]
 		if !ok {
-			return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group))
+			return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for owned APIServices %s", desc.DeploymentName, fmt.Sprintf("%s.%s", desc.Version, desc.Group))
 		}
 
 		if depSpec.Template.Spec.ServiceAccountName == "" {
@@ -345,7 +345,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 		// Update deployment with secret volume mount.
 		secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName)))
 		if err != nil {
-			return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
+			return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
 		}
 
 		install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName())
@@ -362,7 +362,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 
 		depSpec, ok := depSpecs[desc.DeploymentName]
 		if !ok {
-			return nil, fmt.Errorf("StrategyDetailsDeployment missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName)
+			return nil, fmt.Errorf("strategyDetailsDeployment is missing deployment %s for WebhookDescription %s", desc.DeploymentName, desc.GenerateName)
 		}
 
 		if depSpec.Template.Spec.ServiceAccountName == "" {
@@ -372,7 +372,7 @@ func (a *Operator) updateDeploymentSpecsWithApiServiceData(csv *v1alpha1.Cluster
 		// Update deployment with secret volume mount.
 		secret, err := a.lister.CoreV1().SecretLister().Secrets(csv.GetNamespace()).Get(install.SecretName(install.ServiceName(desc.DeploymentName)))
 		if err != nil {
-			return nil, fmt.Errorf("Unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
+			return nil, fmt.Errorf("unable to get secret %s", install.SecretName(install.ServiceName(desc.DeploymentName)))
 		}
 		install.AddDefaultCertVolumeAndVolumeMounts(&depSpec, secret.GetName())
 
@@ -406,7 +406,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e
 	for _, webhook := range validatingWebhookConfigurationList.Items {
 		webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey]
 		if !ok {
-			return fmt.Errorf("ValidatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
+			return fmt.Errorf("validatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
 		}
 		if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok {
 			err = a.opClient.KubernetesInterface().AdmissionregistrationV1().ValidatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{})
@@ -424,7 +424,7 @@ func (a *Operator) cleanUpRemovedWebhooks(csv *v1alpha1.ClusterServiceVersion) e
 	for _, webhook := range mutatingWebhookConfigurationList.Items {
 		webhookGenerateNameLabel, ok := webhook.GetLabels()[install.WebhookDescKey]
 		if !ok {
-			return fmt.Errorf("MutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
+			return fmt.Errorf("mutatingWebhookConfiguration %s does not have WebhookDesc key", webhook.Name)
 		}
 		if _, ok := csvWebhookGenerateNames[webhookGenerateNameLabel]; !ok {
 			err = a.opClient.KubernetesInterface().AdmissionregistrationV1().MutatingWebhookConfigurations().Delete(context.TODO(), webhook.Name, metav1.DeleteOptions{})
@@ -473,7 +473,7 @@ func (a *Operator) areWebhooksAvailable(csv *v1alpha1.ClusterServiceVersion) (bo
 				}
 
 				if crd.Spec.Conversion == nil || crd.Spec.Conversion.Strategy != "Webhook" || crd.Spec.Conversion.Webhook == nil || crd.Spec.Conversion.Webhook.ClientConfig == nil && crd.Spec.Conversion.Webhook.ClientConfig.CABundle == nil {
-					return false, fmt.Errorf("ConversionWebhook not ready")
+					return false, fmt.Errorf("conversionWebhook not ready")
 				}
 				webhookCount++
 			}
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
index ffc9c3b264..862a3dd98e 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operator.go
@@ -418,7 +418,6 @@ func newOperatorWithConfig(ctx context.Context, config *operatorConfig) (*Operat
 		if err := op.RegisterQueueInformer(objGCQueueInformer); err != nil {
 			return nil, err
 		}
-
 	}
 
 	// add queue for all namespaces as well
@@ -617,8 +616,6 @@ func (a *Operator) syncSubscriptionDeleted(obj interface{}) {
 	if !ok {
 		a.logger.Debugf("casting Subscription failed, wrong type: %#v\n", obj)
 	}
-
-	return
 }
 
 func (a *Operator) syncAPIService(obj interface{}) (syncError error) {
@@ -823,7 +820,6 @@ func (a *Operator) syncObject(obj interface{}) (syncError error) {
 				return
 			}
 		}
-
 	}
 
 	// Requeue all owner CSVs
@@ -891,7 +887,6 @@ func (a *Operator) namespaceAddedOrRemoved(obj interface{}) {
 			}
 		}
 	}
-	return
 }
 
 func (a *Operator) syncNamespace(obj interface{}) error {
@@ -1193,7 +1188,6 @@ func (a *Operator) syncClusterServiceVersion(obj interface{}) (syncError error)
 		outCSV.Status.Phase == clusterServiceVersion.Status.Phase &&
 		outCSV.Status.Reason == clusterServiceVersion.Status.Reason &&
 		outCSV.Status.Message == clusterServiceVersion.Status.Message) {
-
 		// Update CSV with status of transition. Log errors if we can't write them to the status.
 		_, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(outCSV.GetNamespace()).UpdateStatus(context.TODO(), outCSV, metav1.UpdateOptions{})
 		if err != nil {
@@ -1337,7 +1331,7 @@ func getCopiedCSVsCondition(isDisabled, csvIsRequeued bool) metav1.Condition {
 	}
 	if !isDisabled {
 		condition.Reason = "CopiedCSVsEnabled"
-		condition.Message = "Copied CSVs are enabled and present accross the cluster"
+		condition.Message = "Copied CSVs are enabled and present across the cluster"
 		if csvIsRequeued {
 			condition.Message = "Copied CSVs are enabled and at least one copied CSVs is missing"
 		}
@@ -1719,6 +1713,10 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 
 	// Check for intersecting provided APIs in intersecting OperatorGroups
 	allGroups, err := a.lister.OperatorsV1().OperatorGroupLister().List(labels.Everything())
+	if err != nil {
+		logger.WithError(err).Warn("failed to list operatorgroups")
+		return
+	}
 	otherGroups := make([]v1.OperatorGroup, 0, len(allGroups))
 	for _, g := range allGroups {
 		if g.GetName() != operatorGroup.GetName() || g.GetNamespace() != operatorGroup.GetNamespace() {
@@ -1835,7 +1833,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		for _, desc := range out.Spec.WebhookDefinitions {
 			_, present := webhookNames[desc.GenerateName]
 			if present {
-				logger.WithError(fmt.Errorf("Repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid")
+				logger.WithError(fmt.Errorf("repeated WebhookDescription name %s", desc.GenerateName)).Warn("CSV is invalid")
 				out.SetPhaseWithEventIfChanged(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInvalidWebhookDescription, "CSV contains repeated WebhookDescription name", now, a.recorder)
 				return
 			}
@@ -1911,7 +1909,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			return
 		}
 
-		strategy, err := a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err := a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -1927,7 +1925,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 			// Set phase to failed if it's been a long time since the last transition (5 minutes)
 			if out.Status.LastTransitionTime != nil && a.now().Sub(out.Status.LastTransitionTime.Time) >= 5*time.Minute {
 				logger.Warn("install timed out")
-				out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, fmt.Sprintf("install timeout"), now, a.recorder)
+				out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonInstallCheckFailed, "install timeout", now, a.recorder)
 				return
 			}
 		}
@@ -1968,12 +1966,12 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		} else if !met {
 			logger.Debug("CSV Requirements are no longer met")
 			out.SetRequirementStatus(statuses)
-			out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements no longer met"), now, a.recorder)
+			out.SetPhaseWithEvent(v1alpha1.CSVPhaseFailed, v1alpha1.CSVReasonRequirementsNotMet, "requirements no longer met", now, a.recorder)
 			return
 		}
 
 		// Check install status
-		strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -2039,7 +2037,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		} else if !met {
 			logger.Debug("CSV Requirements are not met")
 			out.SetRequirementStatus(statuses)
-			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, fmt.Sprintf("requirements not met"), now, a.recorder)
+			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonRequirementsNotMet, "requirements not met", now, a.recorder)
 			return
 		}
 
@@ -2061,7 +2059,7 @@ func (a *Operator) transitionCSVState(in v1alpha1.ClusterServiceVersion) (out *v
 		}
 
 		// Check install status
-		strategy, err = a.updateDeploymentSpecsWithApiServiceData(out, strategy)
+		strategy, err = a.updateDeploymentSpecsWithAPIServiceData(out, strategy)
 		if err != nil {
 			logger.WithError(err).Debug("Unable to calculate expected deployment")
 			out.SetPhaseWithEvent(v1alpha1.CSVPhasePending, v1alpha1.CSVReasonNeedsReinstall, "calculated deployment install is bad", now, a.recorder)
@@ -2168,17 +2166,18 @@ func (a *Operator) updateInstallStatus(csv *v1alpha1.ClusterServiceVersion, inst
 	}
 
 	if !apiServicesInstalled {
-		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf("APIServices not installed"), now, a.recorder)
+		msg := "apiServices not installed"
+		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder)
 		if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil {
 			a.logger.Warn(err.Error())
 		}
 
-		return fmt.Errorf("APIServices not installed")
+		return fmt.Errorf(msg)
 	}
 
 	if !webhooksInstalled || webhookErr != nil {
-		msg := "Webhooks not installed"
-		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, fmt.Sprintf(msg), now, a.recorder)
+		msg := "webhooks not installed"
+		csv.SetPhaseWithEventIfChanged(requeuePhase, requeueConditionReason, msg, now, a.recorder)
 		if err := a.csvQueueSet.Requeue(csv.GetNamespace(), csv.GetName()); err != nil {
 			a.logger.Warn(err.Error())
 		}
@@ -2240,10 +2239,14 @@ func (a *Operator) parseStrategiesAndUpdateStatus(csv *v1alpha1.ClusterServiceVe
 	querierFunc := a.serviceAccountQuerier.NamespaceQuerier(csv.GetNamespace())
 	attenuate, err := a.clientAttenuator.AttenuateToServiceAccount(querierFunc)
 	if err != nil {
-		a.logger.Errorf("failed to get a client for operator deployment- %v", err)
+		a.logger.Errorf("failed to get a client for operator deployment - %v", err)
 		return nil, nil
 	}
 	kubeclient, err := a.clientFactory.WithConfigTransformer(attenuate).NewOperatorClient()
+	if err != nil {
+		a.logger.Errorf("failed to get an operator client for operator deployment - %v", err)
+		return nil, nil
+	}
 
 	strName := strategy.GetStrategyName()
 	installer := a.resolver.InstallerForStrategy(strName, kubeclient, a.lister, csv, csv.GetAnnotations(), csv.GetAllAPIServiceDescriptions(), csv.Spec.WebhookDefinitions, previousStrategy)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
index 6dfb5fca35..04ba9a7ebe 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorconditions.go
@@ -37,17 +37,17 @@ func (a *Operator) isOperatorUpgradeable(csv *v1alpha1.ClusterServiceVersion) (b
 			return true, nil
 		}
 		logger.Infof("Upgradeable condition is overridden to false: %s", o.Message)
-		return false, fmt.Errorf("The operator is not upgradeable: %s", o.Message)
+		return false, fmt.Errorf("the operator is not upgradeable: %s", o.Message)
 	}
 
 	// Check for OperatorUpgradeable condition status
 	if c := meta.FindStatusCondition(cond.Status.Conditions, operatorsv2.Upgradeable); c != nil {
 		if c.ObservedGeneration != cond.ObjectMeta.Generation {
 			logger.Debugf("Upgradeable condition's generation doesn't match: %d/%d", c.ObservedGeneration, cond.ObjectMeta.Generation)
-			return false, fmt.Errorf("The operatorcondition status %q=%q is outdated", c.Type, c.Status)
+			return false, fmt.Errorf("the operatorcondition status %q=%q is outdated", c.Type, c.Status)
 		}
 		if c.Status == metav1.ConditionFalse {
-			return false, fmt.Errorf("The operator is not upgradeable: %s", c.Message)
+			return false, fmt.Errorf("the operator is not upgradeable: %s", c.Message)
 		}
 	}
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
index f308c6af9a..e7ca97a4ce 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/olm/operatorgroup.go
@@ -264,7 +264,7 @@ func (a *Operator) annotateCSVs(group *v1.OperatorGroup, targetNamespaces []stri
 		}
 		logger := logger.WithField("csv", csv.GetName())
 
-		originalNamespacesAnnotation, _ := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey]
+		originalNamespacesAnnotation := a.copyOperatorGroupAnnotations(&csv.ObjectMeta)[v1.OperatorGroupTargetsAnnotationKey]
 		originalNamespaceSet := NewNamespaceSetFromString(originalNamespacesAnnotation)
 
 		if a.operatorGroupAnnotationsDiffer(&csv.ObjectMeta, group) {
@@ -367,7 +367,6 @@ func (a *Operator) pruneProvidedAPIs(group *v1.OperatorGroup, groupProvidedAPIs
 			logger.WithError(err).Warn("could not update provided api annotations")
 		}
 	}
-	return
 }
 
 // ensureProvidedAPIClusterRole ensures that a clusterrole exists (admin, edit, or view) for a single provided API Type
@@ -391,7 +390,10 @@ func (a *Operator) ensureProvidedAPIClusterRole(namePrefix, suffix string, verbs
 	}
 
 	existingCR, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name)
-	if existingCR == nil {
+	if err != nil && !k8serrors.IsNotFound(err) {
+		return err
+	}
+	if k8serrors.IsNotFound(err) {
 		existingCR, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{})
 		if err == nil {
 			return nil
@@ -478,9 +480,7 @@ func (a *Operator) ensureRBACInTargetNamespace(csv *v1alpha1.ClusterServiceVersi
 		logger.Debug("opgroup is global")
 
 		// synthesize cluster permissions to verify rbac
-		for _, p := range strategyDetailsDeployment.Permissions {
-			strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, p)
-		}
+		strategyDetailsDeployment.ClusterPermissions = append(strategyDetailsDeployment.ClusterPermissions, strategyDetailsDeployment.Permissions...)
 		strategyDetailsDeployment.Permissions = nil
 		permMet, _, err := a.permissionStatus(strategyDetailsDeployment, ruleChecker, corev1.NamespaceAll, csv)
 		if err != nil {
@@ -799,7 +799,6 @@ func (a *Operator) copyToNamespace(prototype *v1alpha1.ClusterServiceVersion, ns
 
 	existing, err := a.copiedCSVLister.ClusterServiceVersions(nsTo).Get(prototype.GetName())
 	if k8serrors.IsNotFound(err) {
-
 		created, err := a.client.OperatorsV1alpha1().ClusterServiceVersions(nsTo).Create(context.TODO(), prototype, metav1.CreateOptions{})
 		if err != nil {
 			return nil, err
@@ -1007,7 +1006,10 @@ func (a *Operator) ensureOpGroupClusterRole(op *v1.OperatorGroup, suffix string,
 	}
 
 	existingRole, err := a.lister.RbacV1().ClusterRoleLister().Get(clusterRole.Name)
-	if existingRole == nil {
+	if err != nil && !k8serrors.IsNotFound(err) {
+		return err
+	}
+	if k8serrors.IsNotFound(err) {
 		existingRole, err = a.opClient.KubernetesInterface().RbacV1().ClusterRoles().Create(context.TODO(), clusterRole, metav1.CreateOptions{})
 		if err == nil {
 			return nil
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
index f75f001e4f..22ae894a32 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/helpers.go
@@ -27,12 +27,6 @@ func stripObject(obj client.Object) {
 	obj.SetUID("")
 }
 
-func watchNamespace(namespace *string) predicate.Funcs {
-	return predicate.NewPredicateFuncs(func(object client.Object) bool {
-		return object.GetNamespace() == *namespace
-	})
-}
-
 func watchName(name *string) predicate.Funcs {
 	return predicate.NewPredicateFuncs(func(object client.Object) bool {
 		return object.GetName() == *name
@@ -58,7 +52,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo
 
 	counts := map[configv1.OperandVersion]int{}
 	for _, av := range a {
-		counts[av] += 1
+		counts[av]++
 	}
 
 	for _, bv := range b {
@@ -72,7 +66,7 @@ func versionsMatch(a []configv1.OperandVersion, b []configv1.OperandVersion) boo
 			continue
 		}
 
-		counts[bv] -= 1
+		counts[bv]--
 	}
 
 	return len(counts) < 1
@@ -132,7 +126,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 
 	if desired == nil {
 		// Note: This shouldn't happen
-		return nil, fmt.Errorf("Failed to determine current OpenShift Y-stream release")
+		return nil, fmt.Errorf("failed to determine current OpenShift Y-stream release")
 	}
 
 	next, err := nextY(*desired)
@@ -142,7 +136,7 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 
 	csvList := &operatorsv1alpha1.ClusterServiceVersionList{}
 	if err := cli.List(ctx, csvList); err != nil {
-		return nil, &transientError{fmt.Errorf("Failed to list ClusterServiceVersions: %w", err)}
+		return nil, &transientError{fmt.Errorf("failed to list ClusterServiceVersions: %w", err)}
 	}
 
 	var incompatible skews
@@ -177,18 +171,18 @@ func incompatibleOperators(ctx context.Context, cli client.Client) (skews, error
 func desiredRelease(ctx context.Context, cli client.Client) (*semver.Version, error) {
 	cv := configv1.ClusterVersion{}
 	if err := cli.Get(ctx, client.ObjectKey{Name: "version"}, &cv); err != nil { // "version" is the name of OpenShift's ClusterVersion singleton
-		return nil, &transientError{fmt.Errorf("Failed to get ClusterVersion: %w", err)}
+		return nil, &transientError{fmt.Errorf("failed to get ClusterVersion: %w", err)}
 	}
 
 	v := cv.Status.Desired.Version
 	if v == "" {
 		// The release version hasn't been set yet
-		return nil, fmt.Errorf("Desired release version missing from ClusterVersion")
+		return nil, fmt.Errorf("desired release version missing from ClusterVersion")
 	}
 
 	desired, err := semver.ParseTolerant(v)
 	if err != nil {
-		return nil, fmt.Errorf("ClusterVersion has invalid desired release version: %w", err)
+		return nil, fmt.Errorf("cluster version has invalid desired release version: %w", err)
 	}
 
 	return &desired, nil
@@ -231,7 +225,7 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver.
 		}
 
 		if max != nil {
-			return nil, fmt.Errorf(`Defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty)
+			return nil, fmt.Errorf(`defining more than one "%s" property is not allowed`, MaxOpenShiftVersionProperty)
 		}
 
 		max = &property.Value
@@ -245,12 +239,12 @@ func maxOpenShiftVersion(csv *operatorsv1alpha1.ClusterServiceVersion) (*semver.
 	value := strings.Trim(*max, "\"")
 	if value == "" {
 		// Handle "" separately, so parse doesn't treat it as a zero
-		return nil, fmt.Errorf(`Value cannot be "" (an empty string)`)
+		return nil, fmt.Errorf(`value cannot be "" (an empty string)`)
 	}
 
 	version, err := semver.ParseTolerant(value)
 	if err != nil {
-		return nil, fmt.Errorf(`Failed to parse "%s" as semver: %w`, value, err)
+		return nil, fmt.Errorf(`failed to parse "%s" as semver: %w`, value, err)
 	}
 
 	truncatedVersion := semver.Version{Major: version.Major, Minor: version.Minor}
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
index e5b0a4b64a..552dee99c9 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/options.go
@@ -51,10 +51,10 @@ func (c *ReconcilerConfig) apply(opts []ReconcilerOption) {
 
 func (c *ReconcilerConfig) complete() error {
 	if c.Client == nil {
-		return fmt.Errorf("No client specified")
+		return fmt.Errorf("no client specified")
 	}
 	if c.Name == "" {
-		return fmt.Errorf("No ClusterOperator name specified")
+		return fmt.Errorf("no ClusterOperator name specified")
 	}
 	if c.Log == nil {
 		c.Log = ctrl.Log.WithName(c.Name)
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
index 0583945ec4..84d4a9591b 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/openshift/synctracker.go
@@ -38,7 +38,6 @@ func (s *SyncTracker) Start(ctx context.Context) error {
 	})
 
 	return err
-
 }
 
 func (s *SyncTracker) start(ctx context.Context) error {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
index 62aa4e2d06..31d5c92c34 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/operators/operator_controller.go
@@ -159,7 +159,6 @@ func (r *OperatorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	if err = r.updateComponents(ctx, operator); err != nil {
 		log.Error(err, "Could not update components")
 		return reconcile.Result{Requeue: true}, nil
-
 	}
 
 	if create {
@@ -205,7 +204,7 @@ func (r *OperatorReconciler) listComponents(ctx context.Context, selector labels
 	for _, list := range componentLists {
 		cList, ok := list.(client.ObjectList)
 		if !ok {
-			return nil, fmt.Errorf("Unable to typecast runtime.Object to client.ObjectList")
+			return nil, fmt.Errorf("unable to typecast runtime.Object to client.ObjectList")
 		}
 		if err := r.List(ctx, cList, opt); err != nil {
 			return nil, err
@@ -233,7 +232,7 @@ func (r *OperatorReconciler) hasExistingComponents(ctx context.Context, name str
 	for _, list := range components {
 		items, err := meta.ExtractList(list)
 		if err != nil {
-			return false, fmt.Errorf("Unable to extract list from runtime.Object")
+			return false, fmt.Errorf("unable to extract list from runtime.Object")
 		}
 		if len(items) > 0 {
 			return true, nil
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
index fe9e2b6a3a..57a974bc63 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/registry_client.go
@@ -88,7 +88,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki
 	}
 	entry := rc.filterChannelEntries(ctx, it, excludedPackages)
 	if entry == nil {
-		return nil, fmt.Errorf("Unable to find a channel entry that satisfies the requirements")
+		return nil, fmt.Errorf("unable to find a channel entry that satisfies the requirements")
 	}
 	bundle, err := rc.Client.Registry.GetBundle(ctx, &registryapi.GetBundleRequest{PkgName: entry.PackageName, ChannelName: entry.ChannelName, CsvName: entry.BundleName})
 	if err != nil {
@@ -101,7 +101,7 @@ func (rc *Client) FindBundleThatProvides(ctx context.Context, group, version, ki
 // API and come from the same package with original operator and returns the
 // first entry on the list from the default channel of that package
 func (rc *Client) filterChannelEntries(ctx context.Context, it *ChannelEntryIterator, excludedPackages map[string]struct{}) *opregistry.ChannelEntry {
-	defChannels := make(map[string]string, 0)
+	defChannels := make(map[string]string)
 
 	var entries []*opregistry.ChannelEntry
 	for e := it.Next(); e != nil; e = it.Next() {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
index e719265ff4..240f647dd8 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/cache.go
@@ -85,8 +85,6 @@ type Cache struct {
 	m            sync.RWMutex
 }
 
-type catalogSourcePriority int
-
 var _ OperatorCacheProvider = &Cache{}
 
 type Option func(*Cache)
@@ -402,13 +400,13 @@ func (s sortableSnapshots) Swap(i, j int) {
 	s.snapshots[i], s.snapshots[j] = s.snapshots[j], s.snapshots[i]
 }
 
-func (s *snapshotHeader) Find(p ...Predicate) []*Entry {
-	s.m.RLock()
-	defer s.m.RUnlock()
-	if s.snapshot == nil {
+func (hdr *snapshotHeader) Find(p ...Predicate) []*Entry {
+	hdr.m.RLock()
+	defer hdr.m.RUnlock()
+	if hdr.snapshot == nil {
 		return nil
 	}
-	return Filter(s.snapshot.Entries, p...)
+	return Filter(hdr.snapshot.Entries, p...)
 }
 
 type OperatorFinder interface {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
index 8e09d5dad4..681c074735 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/operators.go
@@ -106,9 +106,7 @@ func (s APISet) Intersection(sets ...APISet) APISet {
 func (s APISet) Difference(set APISet) APISet {
 	difference := make(APISet).Union(s)
 	for api := range set {
-		if _, ok := difference[api]; ok {
-			delete(difference, api)
-		}
+		delete(difference, api)
 	}
 
 	return difference
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
index 037af4207d..73866ebbf1 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache/predicates.go
@@ -235,7 +235,7 @@ func And(p ...Predicate) Predicate {
 
 func (p andPredicate) Test(o *Entry) bool {
 	for _, predicate := range p.predicates {
-		if predicate.Test(o) == false {
+		if !predicate.Test(o) {
 			return false
 		}
 	}
@@ -265,7 +265,7 @@ type orPredicate struct {
 
 func (p orPredicate) Test(o *Entry) bool {
 	for _, predicate := range p.predicates {
-		if predicate.Test(o) == true {
+		if predicate.Test(o) {
 			return true
 		}
 	}
@@ -295,7 +295,7 @@ type notPredicate struct {
 
 func (p notPredicate) Test(o *Entry) bool {
 	// !pred && !pred is equivalent to !(pred || pred).
-	return !orPredicate{p.predicates}.Test(o)
+	return !orPredicate(p).Test(o)
 }
 
 func (p notPredicate) String() string {
@@ -323,9 +323,9 @@ func (b booleanPredicate) Test(o *Entry) bool {
 
 func (b booleanPredicate) String() string {
 	if b.result {
-		return fmt.Sprintf("predicate is true")
+		return "predicate is true"
 	}
-	return fmt.Sprintf("predicate is false")
+	return "predicate is false"
 }
 
 func True() Predicate {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go
new file mode 100644
index 0000000000..aaa98e64c4
--- /dev/null
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/hooks.go
@@ -0,0 +1,9 @@
+package resolver
+
+// stepResolverInitHook provides a way for the downstream
+// to modify the step resolver at creation time.
+// This is a bit of a hack to enable system constraints downstream
+// without affecting the upstream. We may want to clean this up when
+// either we have a more pluggable architecture; or system constraints
+// come to the upstream
+type stepResolverInitHook func(*OperatorStepResolver) error
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
index 580e3c7a32..1abd16ed71 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/installabletypes.go
@@ -40,7 +40,7 @@ func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey,
 	info := strings.Split(i.identifier.String(), "/")
 	// This should be enforced by Kube naming constraints
 	if len(info) != 4 {
-		return "", "", cache.SourceKey{}, fmt.Errorf("Unable to parse identifier %s for source info", i.identifier)
+		return "", "", cache.SourceKey{}, fmt.Errorf("unable to parse identifier %s for source info", i.identifier)
 	}
 	catalog := cache.SourceKey{
 		Name:      info[0],
@@ -51,7 +51,7 @@ func (i *BundleInstallable) BundleSourceInfo() (string, string, cache.SourceKey,
 	return csvName, channel, catalog, nil
 }
 
-func bundleId(bundle, channel string, catalog cache.SourceKey) solver.Identifier {
+func bundleID(bundle, channel string, catalog cache.SourceKey) solver.Identifier {
 	return solver.IdentifierFromString(fmt.Sprintf("%s/%s/%s", catalog.String(), channel, bundle))
 }
 
@@ -59,7 +59,7 @@ func NewBundleInstallableFromOperator(o *cache.Entry) (BundleInstallable, error)
 	if o.SourceInfo == nil {
 		return BundleInstallable{}, fmt.Errorf("unable to resolve the source of bundle %s", o.Name)
 	}
-	id := bundleId(o.Name, o.Channel(), o.SourceInfo.Catalog)
+	id := bundleID(o.Name, o.Channel(), o.SourceInfo.Catalog)
 	var constraints []solver.Constraint
 	if o.SourceInfo.Catalog.Virtual() && o.SourceInfo.Subscription == nil {
 		// CSVs already associated with a Subscription
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
index 453ae4a0b8..abbb938597 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/instrumented_resolver.go
@@ -27,9 +27,9 @@ func (ir *InstrumentedResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step
 	start := time.Now()
 	steps, lookups, subs, err := ir.resolver.ResolveSteps(namespace)
 	if err != nil {
-		ir.failureMetricsEmitter(time.Now().Sub(start))
+		ir.failureMetricsEmitter(time.Since(start))
 	} else {
-		ir.successMetricsEmitter(time.Now().Sub(start))
+		ir.successMetricsEmitter(time.Since(start))
 	}
 	return steps, lookups, subs, err
 }
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
index 4905aa3765..4b2f868d61 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/resolver.go
@@ -26,9 +26,10 @@ type OperatorResolver interface {
 }
 
 type SatResolver struct {
-	cache cache.OperatorCacheProvider
-	log   logrus.FieldLogger
-	pc    *predicateConverter
+	cache                     cache.OperatorCacheProvider
+	log                       logrus.FieldLogger
+	pc                        *predicateConverter
+	systemConstraintsProvider solver.ConstraintProvider
 }
 
 func NewDefaultSatResolver(rcp cache.SourceProvider, catsrcLister v1alpha1listers.CatalogSourceLister, logger logrus.FieldLogger) *SatResolver {
@@ -54,8 +55,8 @@ func (w *debugWriter) Write(b []byte) (int, error) {
 func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.ClusterServiceVersion, subs []*v1alpha1.Subscription) (cache.OperatorSet, error) {
 	var errs []error
 
-	installables := make(map[solver.Identifier]solver.Installable, 0)
-	visited := make(map[*cache.Entry]*BundleInstallable, 0)
+	installables := make(map[solver.Identifier]solver.Installable)
+	visited := make(map[*cache.Entry]*BundleInstallable)
 
 	// TODO: better abstraction
 	startingCSVs := make(map[string]struct{})
@@ -145,7 +146,7 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 		}
 	}
 
-	operators := make(map[string]*cache.Entry, 0)
+	operators := make(map[string]*cache.Entry)
 	for _, installableOperator := range operatorInstallables {
 		csvName, channel, catalog, err := installableOperator.BundleSourceInfo()
 		if err != nil {
@@ -177,9 +178,28 @@ func (r *SatResolver) SolveOperators(namespaces []string, csvs []*v1alpha1.Clust
 	return operators, nil
 }
 
+// newBundleInstallableFromEntry converts an entry into a bundle installable with
+// system constraints applied, if they are defined for the entry
+func (r *SatResolver) newBundleInstallableFromEntry(entry *cache.Entry) (*BundleInstallable, error) {
+	bundleInstalleble, err := NewBundleInstallableFromOperator(entry)
+	if err != nil {
+		return nil, err
+	}
+
+	// apply system constraints if necessary
+	if r.systemConstraintsProvider != nil && !(entry.SourceInfo.Catalog.Virtual()) {
+		systemConstraints, err := r.systemConstraintsProvider.Constraints(entry)
+		if err != nil {
+			return nil, err
+		}
+		bundleInstalleble.constraints = append(bundleInstalleble.constraints, systemConstraints...)
+	}
+	return &bundleInstalleble, nil
+}
+
 func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, current *cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]solver.Installable, error) {
 	var cachePredicates, channelPredicates []cache.Predicate
-	installables := make(map[solver.Identifier]solver.Installable, 0)
+	installables := make(map[solver.Identifier]solver.Installable)
 
 	catalog := cache.SourceKey{
 		Name:      sub.Spec.CatalogSource,
@@ -296,12 +316,12 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 			// safe to remove this conflict if properties
 			// annotations are made mandatory for
 			// resolution.
-			c.AddConflict(bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
+			c.AddConflict(bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
 		}
 		depIds = append(depIds, c.Identifier())
 	}
 	if current != nil {
-		depIds = append(depIds, bundleId(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
+		depIds = append(depIds, bundleID(current.Name, current.Channel(), cache.NewVirtualSourceKey(sub.GetNamespace())))
 	}
 
 	// all candidates added as options for this constraint
@@ -313,7 +333,7 @@ func (r *SatResolver) getSubscriptionInstallables(sub *v1alpha1.Subscription, cu
 
 func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleStack []*cache.Entry, namespacedCache cache.MultiCatalogOperatorFinder, visited map[*cache.Entry]*BundleInstallable) (map[solver.Identifier]struct{}, map[solver.Identifier]*BundleInstallable, error) {
 	errs := make([]error, 0)
-	installables := make(map[solver.Identifier]*BundleInstallable, 0) // all installables, including dependencies
+	installables := make(map[solver.Identifier]*BundleInstallable) // all installables, including dependencies
 
 	// track the first layer of installable ids
 	var initial = make(map[*cache.Entry]struct{})
@@ -334,13 +354,13 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			continue
 		}
 
-		bundleInstallable, err := NewBundleInstallableFromOperator(bundle)
+		bundleInstallable, err := r.newBundleInstallableFromEntry(bundle)
 		if err != nil {
 			errs = append(errs, err)
 			continue
 		}
 
-		visited[bundle] = &bundleInstallable
+		visited[bundle] = bundleInstallable
 
 		dependencyPredicates, err := r.pc.convertDependencyProperties(bundle.Properties)
 		if err != nil {
@@ -389,12 +409,12 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			// (after sorting) to remove all bundles that
 			// don't satisfy the dependency.
 			for _, b := range cache.Filter(sortedBundles, d) {
-				i, err := NewBundleInstallableFromOperator(b)
+				i, err := r.newBundleInstallableFromEntry(b)
 				if err != nil {
 					errs = append(errs, err)
 					continue
 				}
-				installables[i.Identifier()] = &i
+				installables[i.Identifier()] = i
 				bundleDependencies = append(bundleDependencies, i.Identifier())
 				bundleStack = append(bundleStack, b)
 			}
@@ -404,14 +424,14 @@ func (r *SatResolver) getBundleInstallables(preferredNamespace string, bundleSta
 			))
 		}
 
-		installables[bundleInstallable.Identifier()] = &bundleInstallable
+		installables[bundleInstallable.Identifier()] = bundleInstallable
 	}
 
 	if len(errs) > 0 {
 		return nil, nil, utilerrors.NewAggregate(errs)
 	}
 
-	ids := make(map[solver.Identifier]struct{}, 0) // immediate installables found via predicates
+	ids := make(map[solver.Identifier]struct{}) // immediate installables found via predicates
 	for o := range initial {
 		ids[visited[o].Identifier()] = struct{}{}
 	}
@@ -449,17 +469,17 @@ func (r *SatResolver) inferProperties(csv *v1alpha1.ClusterServiceVersion, subs
 	if !csv.Spec.Version.Version.Equals(semver.Version{}) {
 		version = csv.Spec.Version.String()
 	}
-	if pp, err := json.Marshal(opregistry.PackageProperty{
+	pp, err := json.Marshal(opregistry.PackageProperty{
 		PackageName: pkg,
 		Version:     version,
-	}); err != nil {
+	})
+	if err != nil {
 		return nil, fmt.Errorf("failed to marshal inferred package property: %w", err)
-	} else {
-		properties = append(properties, &api.Property{
-			Type:  opregistry.PackageType,
-			Value: string(pp),
-		})
 	}
+	properties = append(properties, &api.Property{
+		Type:  opregistry.PackageType,
+		Value: string(pp),
+	})
 
 	return properties, nil
 }
@@ -795,10 +815,8 @@ func (pc *predicateConverter) predicateForConstraintProperty(value string) (cach
 // convertConstraints creates predicates from each element of constraints, recursing on compound constraints.
 // New constraint types added to the constraints package must be handled here.
 func (pc *predicateConverter) convertConstraints(constraints ...constraints.Constraint) ([]cache.Predicate, error) {
-
 	preds := make([]cache.Predicate, len(constraints))
 	for i, constraint := range constraints {
-
 		var err error
 		switch {
 		case constraint.GVK != nil:
@@ -828,7 +846,6 @@ func (pc *predicateConverter) convertConstraints(constraints ...constraints.Cons
 		if err != nil {
 			return nil, err
 		}
-
 	}
 
 	return preds, nil
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go
new file mode 100644
index 0000000000..ce119abed4
--- /dev/null
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/constraint_provider.go
@@ -0,0 +1,19 @@
+package solver
+
+import "github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/cache"
+
+// ConstraintProvider knows how to provide solver constraints for a given cache entry.
+// For instance, it could be used to surface additional constraints against an entry given some
+// properties it may expose. E.g. olm.maxOpenShiftVersion could be checked against the cluster version
+// and prohibit any entry that doesn't meet the requirement
+type ConstraintProvider interface {
+	// Constraints returns a set of solver constraints for a cache entry.
+	Constraints(e *cache.Entry) ([]Constraint, error)
+}
+
+// ConstraintProviderFunc is a simple implementation of ConstraintProvider
+type ConstraintProviderFunc func(e *cache.Entry) ([]Constraint, error)
+
+func (c ConstraintProviderFunc) Constraints(e *cache.Entry) ([]Constraint, error) {
+	return c(e)
+}
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
index dedb5fb8da..ff15346832 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/lit_mapping.go
@@ -31,7 +31,6 @@ type litMapping struct {
 	constraints  map[z.Lit]AppliedConstraint
 	c            *logic.C
 	errs         inconsistentLitMapping
-	buf          []z.Lit
 }
 
 // newLitMapping returns a new litMapping with its state initialized based on
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
index ed84ea9309..363595eca0 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/search.go
@@ -26,8 +26,6 @@ type search struct {
 	assumptions            map[z.Lit]struct{} // set of assumed lits - duplicates guess stack - for fast lookup
 	guesses                []guess            // stack of assumed guesses
 	headChoice, tailChoice *choice            // deque of unmade choices
-	heap                   []choice
-	position               int
 	tracer                 Tracer
 	result                 int
 	buffer                 []z.Lit
@@ -119,8 +117,8 @@ func (h *search) PopChoiceFront() choice {
 	}
 	h.headChoice = c.next
 	return *c
-
 }
+
 func (h *search) PushChoiceBack(c choice) {
 	if h.tailChoice == nil {
 		h.headChoice = &c
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
index 5d81f459a2..873f17697f 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/solver/solve.go
@@ -11,7 +11,7 @@ import (
 	"github.com/go-air/gini/z"
 )
 
-var Incomplete = errors.New("cancelled before a solution could be found")
+var ErrIncomplete = errors.New("cancelled before a solution could be found")
 
 // NotSatisfiable is an error composed of a minimal set of applied
 // constraints that is sufficient to make a solution impossible.
@@ -114,7 +114,7 @@ func (s *solver) Solve(ctx context.Context) (result []Installable, err error) {
 		return nil, NotSatisfiable(s.litMap.Conflicts(s.g))
 	}
 
-	return nil, Incomplete
+	return nil, ErrIncomplete
 }
 
 func New(options ...Option) (Solver, error) {
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
index 079b928065..35b3a906be 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/step_resolver.go
@@ -4,7 +4,6 @@ package resolver
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"github.com/sirupsen/logrus"
 	corev1 "k8s.io/api/core/v1"
@@ -26,7 +25,8 @@ const (
 	BundleLookupConditionPacked v1alpha1.BundleLookupConditionType = "BundleLookupNotPersisted"
 )
 
-var timeNow = func() metav1.Time { return metav1.NewTime(time.Now().UTC()) }
+// init hooks provides the downstream a way to modify the upstream behavior
+var initHooks []stepResolverInitHook
 
 type StepResolver interface {
 	ResolveSteps(namespace string) ([]*v1alpha1.Step, []v1alpha1.BundleLookup, []*v1alpha1.Subscription, error)
@@ -48,7 +48,7 @@ var _ StepResolver = &OperatorStepResolver{}
 
 func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versioned.Interface, kubeclient kubernetes.Interface,
 	globalCatalogNamespace string, provider RegistryClientProvider, log logrus.FieldLogger) *OperatorStepResolver {
-	return &OperatorStepResolver{
+	stepResolver := &OperatorStepResolver{
 		subLister:              lister.OperatorsV1alpha1().SubscriptionLister(),
 		csvLister:              lister.OperatorsV1alpha1().ClusterServiceVersionLister(),
 		ipLister:               lister.OperatorsV1alpha1().InstallPlanLister(),
@@ -58,6 +58,15 @@ func NewOperatorStepResolver(lister operatorlister.OperatorLister, client versio
 		satResolver:            NewDefaultSatResolver(SourceProviderFromRegistryClientProvider(provider, log), lister.OperatorsV1alpha1().CatalogSourceLister(), log),
 		log:                    log,
 	}
+
+	// init hooks can be added to the downstream to
+	// modify resolver behaviour
+	for _, initHook := range initHooks {
+		if err := initHook(stepResolver); err != nil {
+			panic(err)
+		}
+	}
+	return stepResolver
 }
 
 func (r *OperatorStepResolver) Expire(key cache.SourceKey) {
@@ -166,11 +175,11 @@ func (r *OperatorStepResolver) ResolveSteps(namespace string) ([]*v1alpha1.Step,
 					},
 				},
 			}
-			if anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties); err != nil {
+			anno, err := projection.PropertiesAnnotationFromPropertyList(op.Properties)
+			if err != nil {
 				return nil, nil, nil, fmt.Errorf("failed to serialize operator properties for %q: %w", op.Name, err)
-			} else {
-				lookup.Properties = anno
 			}
+			lookup.Properties = anno
 			bundleLookups = append(bundleLookups, lookup)
 		}
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
index 7f2270881b..7860c7108a 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/resolver/steps.go
@@ -120,17 +120,18 @@ func NewStepResourceFromBundle(bundle *api.Bundle, namespace, replaces, catalogS
 
 	csv.SetNamespace(namespace)
 	csv.Spec.Replaces = replaces
-	if anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties); err != nil {
+	anno, err := projection.PropertiesAnnotationFromPropertyList(bundle.Properties)
+	if err != nil {
 		return nil, fmt.Errorf("failed to construct properties annotation for %q: %w", csv.GetName(), err)
-	} else {
-		annos := csv.GetAnnotations()
-		if annos == nil {
-			annos = make(map[string]string)
-		}
-		annos[projection.PropertiesAnnotationKey] = anno
-		csv.SetAnnotations(annos)
 	}
 
+	annos := csv.GetAnnotations()
+	if annos == nil {
+		annos = make(map[string]string)
+	}
+	annos[projection.PropertiesAnnotationKey] = anno
+	csv.SetAnnotations(annos)
+
 	step, err := NewStepResourceFromObject(csv, catalogSourceName, catalogSourceNamespace)
 	if err != nil {
 		return nil, err
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go
index ec1a188846..bbb17b00b0 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/metrics/metrics.go
@@ -13,20 +13,20 @@ import (
 )
 
 const (
-	NAME_LABEL      = "name"
-	INSTALLED_LABEL = "installed"
-	NAMESPACE_LABEL = "namespace"
-	CHANNEL_LABEL   = "channel"
-	VERSION_LABEL   = "version"
-	PHASE_LABEL     = "phase"
-	REASON_LABEL    = "reason"
-	PACKAGE_LABEL   = "package"
-	Outcome         = "outcome"
-	Succeeded       = "succeeded"
-	Failed          = "failed"
-	APPROVAL_LABEL  = "approval"
-	WARNING_LABEL   = "warning"
-	GVK_LABEL       = "gvk"
+	NameLabel      = "name"
+	InstalledLabel = "installed"
+	NamespaceLabel = "namespace"
+	ChannelLabel   = "channel"
+	VersionLabel   = "version"
+	PhaseLabel     = "phase"
+	ReasonLabel    = "reason"
+	PackageLabel   = "package"
+	Outcome        = "outcome"
+	Succeeded      = "succeeded"
+	Failed         = "failed"
+	ApprovalLabel  = "approval"
+	WarningLabel   = "warning"
+	GVKLabel       = "gvk"
 )
 
 type MetricsProvider interface {
@@ -90,7 +90,6 @@ type metricsCatalogSource struct {
 
 func NewMetricsCatalogSource(lister v1alpha1.CatalogSourceLister) MetricsProvider {
 	return &metricsCatalogSource{lister}
-
 }
 
 func (m *metricsCatalogSource) HandleMetrics() error {
@@ -149,7 +148,7 @@ var (
 			Name: "catalogsource_ready",
 			Help: "State of a CatalogSource. 1 indicates that the CatalogSource is in a READY state. 0 indicates CatalogSource is in a Non READY state.",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL},
+		[]string{NamespaceLabel, NameLabel},
 	)
 
 	// exported since it's not handled by HandleMetrics
@@ -165,7 +164,7 @@ var (
 			Name: "subscription_sync_total",
 			Help: "Monotonic count of subscription syncs",
 		},
-		[]string{NAME_LABEL, INSTALLED_LABEL, CHANNEL_LABEL, PACKAGE_LABEL, APPROVAL_LABEL},
+		[]string{NameLabel, InstalledLabel, ChannelLabel, PackageLabel, ApprovalLabel},
 	)
 
 	csvSucceeded = prometheus.NewGaugeVec(
@@ -173,7 +172,7 @@ var (
 			Name: "csv_succeeded",
 			Help: "Successful CSV install",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL},
+		[]string{NamespaceLabel, NameLabel, VersionLabel},
 	)
 
 	csvAbnormal = prometheus.NewGaugeVec(
@@ -181,7 +180,7 @@ var (
 			Name: "csv_abnormal",
 			Help: "CSV is not installed",
 		},
-		[]string{NAMESPACE_LABEL, NAME_LABEL, VERSION_LABEL, PHASE_LABEL, REASON_LABEL},
+		[]string{NamespaceLabel, NameLabel, VersionLabel, PhaseLabel, ReasonLabel},
 	)
 
 	dependencyResolutionSummary = prometheus.NewSummaryVec(
@@ -200,7 +199,7 @@ var (
 		},
 	)
 
-	// subscriptionSyncCounters keeps a record of the promethues counters emitted by
+	// subscriptionSyncCounters keeps a record of the Prometheus counters emitted by
 	// Subscription objects. The key of a record is the Subscription name, while the value
 	//  is struct containing label values used in the counter
 	subscriptionSyncCounters = make(map[string]subscriptionSyncLabelValues)
@@ -310,7 +309,6 @@ func UpdateSubsSyncCounterStorage(sub *olmv1alpha1.Subscription) {
 		sub.Spec.Package != counterValues.pkg ||
 		sub.Status.InstalledCSV != counterValues.installedCSV ||
 		approvalStrategy != counterValues.approvalStrategy {
-
 		// Delete metric will label values of old Subscription first
 		SubscriptionSyncCount.DeleteLabelValues(sub.GetName(), counterValues.installedCSV, counterValues.channel, counterValues.pkg, counterValues.approvalStrategy)
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go
index a761eeb180..0a959b8c09 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/provider/registry.go
@@ -61,7 +61,7 @@ func catalogIndexFunc(obj interface{}) ([]string, error) {
 
 func PackageManifestKeyFunc(obj interface{}) (string, error) {
 	if key, ok := obj.(string); ok {
-		return string(key), nil
+		return key, nil
 	}
 
 	pkg, ok := obj.(*operators.PackageManifest)
@@ -351,7 +351,7 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s
 				continue
 			}
 		}
-		if err := p.cache.Delete(string(storedPkgKey)); err != nil {
+		if err := p.cache.Delete(storedPkgKey); err != nil {
 			logger.WithField("pkg", name).WithError(err).Warn("failed to delete cache entry")
 			errs = append(errs, err)
 		}
@@ -363,18 +363,16 @@ func (p *RegistryProvider) gcPackages(key registry.CatalogKey, keep map[string]s
 func (p *RegistryProvider) catalogSourceDeleted(obj interface{}) {
 	catsrc, ok := obj.(metav1.Object)
 	if !ok {
+		tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
 		if !ok {
-			tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
-				return
-			}
+			utilruntime.HandleError(fmt.Errorf("couldn't get object from tombstone %#v", obj))
+			return
+		}
 
-			catsrc, ok = tombstone.Obj.(metav1.Object)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
-				return
-			}
+		catsrc, ok = tombstone.Obj.(metav1.Object)
+		if !ok {
+			utilruntime.HandleError(fmt.Errorf("tombstone contained object that is not a Namespace %#v", obj))
+			return
 		}
 	}
 
diff --git a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go
index dece00662e..a0eb2f8af8 100644
--- a/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go
+++ b/vendor/github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/storage/printer.go
@@ -30,7 +30,6 @@ func addTableHandlers(h printers.PrintHandler) {
 	}
 	h.TableHandler(podColumnDefinitions, printPackage)
 	h.TableHandler(podColumnDefinitions, printPackageList)
-
 }
 
 func printPackage(manifest *operators.PackageManifest, options printers.GenerateOptions) ([]metav1beta1.TableRow, error) {
diff --git a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go
index d07273b3c4..3952a52b8c 100644
--- a/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go
+++ b/vendor/github.com/operator-framework/operator-registry/cmd/opm/alpha/bundle/extract.go
@@ -12,7 +12,7 @@ import (
 var extractCmd = &cobra.Command{
 	Use:   "extract",
 	Short: "Extracts the data in a bundle directory via ConfigMap",
-	Long:  "Extract takes as input a directory containing manifests and writes the per file contents to a ConfipMap",
+	Long:  "Extract takes as input a directory containing manifests and writes the per file contents to a ConfigMap",
 
 	PreRunE: func(cmd *cobra.Command, _ []string) error {
 		if debug, _ := cmd.Flags().GetBool("debug"); debug {
diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go
index d7a96d11ca..fb8ca0368d 100644
--- a/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go
+++ b/vendor/github.com/operator-framework/operator-registry/pkg/lib/bundle/validate.go
@@ -237,6 +237,8 @@ func validateDependencies(dependenciesFile *registry.DependenciesFile) []error {
 				errs = dp.Validate()
 			case registry.LabelDependency:
 				errs = dp.Validate()
+			case registry.CelConstraint:
+				errs = dp.Validate()
 			default:
 				errs = append(errs, fmt.Errorf("unsupported dependency type %s", d.GetType()))
 			}
diff --git a/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go b/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go
index d7d2585520..42908e5087 100644
--- a/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go
+++ b/vendor/github.com/operator-framework/operator-registry/pkg/registry/types.go
@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/blang/semver/v4"
+	"github.com/operator-framework/api/pkg/constraints"
 )
 
 var (
@@ -55,6 +56,7 @@ const (
 	DeprecatedType = "olm.deprecated"
 	LabelType      = "olm.label"
 	PropertyKey    = "olm.properties"
+	ConstraintType = "olm.constraint"
 )
 
 // APIKey stores GroupVersionKind for use as map keys
@@ -220,6 +222,16 @@ type LabelDependency struct {
 	Label string `json:"label" yaml:"label"`
 }
 
+type CelConstraint struct {
+	// Constraint message that surfaces in resolution
+	// This field is optional
+	Message string `json:"message" yaml:"message"`
+
+	// The cel struct that contraints CEL expression
+	// This field is required
+	Cel *constraints.Cel `json:"cel" yaml:"cel"`
+}
+
 type GVKProperty struct {
 	// The group of GVK based property
 	Group string `json:"group" yaml:"group"`
@@ -289,6 +301,25 @@ func (pd *PackageDependency) Validate() []error {
 	return errs
 }
 
+// Validate will validate constraint type and return error(s)
+func (cc *CelConstraint) Validate() []error {
+	errs := []error{}
+	if cc.Cel == nil {
+		errs = append(errs, fmt.Errorf("The CEL field is missing"))
+	} else {
+		if cc.Cel.Rule == "" {
+			errs = append(errs, fmt.Errorf("The CEL expression is missing"))
+			return errs
+		}
+		validator := constraints.NewCelEnvironment()
+		_, err := validator.Validate(cc.Cel.Rule)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Invalid CEL expression: %s", err.Error()))
+		}
+	}
+	return errs
+}
+
 // GetDependencies returns the list of dependency
 func (d *DependenciesFile) GetDependencies() []*Dependency {
 	var dependencies []*Dependency
@@ -329,6 +360,13 @@ func (e *Dependency) GetTypeValue() interface{} {
 			return nil
 		}
 		return dep
+	case ConstraintType:
+		dep := CelConstraint{}
+		err := json.Unmarshal([]byte(e.GetValue()), &dep)
+		if err != nil {
+			return nil
+		}
+		return dep
 	}
 	return nil
 }
diff --git a/vendor/google.golang.org/grpc/MAINTAINERS.md b/vendor/google.golang.org/grpc/MAINTAINERS.md
index 093c82b3af..c6672c0a3e 100644
--- a/vendor/google.golang.org/grpc/MAINTAINERS.md
+++ b/vendor/google.golang.org/grpc/MAINTAINERS.md
@@ -8,17 +8,18 @@ See [CONTRIBUTING.md](https://github.com/grpc/grpc-community/blob/master/CONTRIB
 for general contribution guidelines.
 
 ## Maintainers (in alphabetical order)
-- [canguler](https://github.com/canguler), Google LLC
+
 - [cesarghali](https://github.com/cesarghali), Google LLC
 - [dfawley](https://github.com/dfawley), Google LLC
 - [easwars](https://github.com/easwars), Google LLC
-- [jadekler](https://github.com/jadekler), Google LLC
 - [menghanl](https://github.com/menghanl), Google LLC
 - [srini100](https://github.com/srini100), Google LLC
 
 ## Emeritus Maintainers (in alphabetical order)
 - [adelez](https://github.com/adelez), Google LLC
+- [canguler](https://github.com/canguler), Google LLC
 - [iamqizhao](https://github.com/iamqizhao), Google LLC
+- [jadekler](https://github.com/jadekler), Google LLC
 - [jtattermusch](https://github.com/jtattermusch), Google LLC
 - [lyuxuan](https://github.com/lyuxuan), Google LLC
 - [makmukhi](https://github.com/makmukhi), Google LLC
diff --git a/vendor/google.golang.org/grpc/Makefile b/vendor/google.golang.org/grpc/Makefile
index 1f0722f162..1f8960922b 100644
--- a/vendor/google.golang.org/grpc/Makefile
+++ b/vendor/google.golang.org/grpc/Makefile
@@ -41,8 +41,6 @@ vetdeps:
 	clean \
 	proto \
 	test \
-	testappengine \
-	testappenginedeps \
 	testrace \
 	vet \
 	vetdeps
diff --git a/vendor/google.golang.org/grpc/NOTICE.txt b/vendor/google.golang.org/grpc/NOTICE.txt
new file mode 100644
index 0000000000..530197749e
--- /dev/null
+++ b/vendor/google.golang.org/grpc/NOTICE.txt
@@ -0,0 +1,13 @@
+Copyright 2014 gRPC authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/google.golang.org/grpc/balancer/balancer.go b/vendor/google.golang.org/grpc/balancer/balancer.go
index ab531f4c0b..178de0898a 100644
--- a/vendor/google.golang.org/grpc/balancer/balancer.go
+++ b/vendor/google.golang.org/grpc/balancer/balancer.go
@@ -75,24 +75,26 @@ func Get(name string) Builder {
 	return nil
 }
 
-// SubConn represents a gRPC sub connection.
-// Each sub connection contains a list of addresses. gRPC will
-// try to connect to them (in sequence), and stop trying the
-// remainder once one connection is successful.
+// A SubConn represents a single connection to a gRPC backend service.
 //
-// The reconnect backoff will be applied on the list, not a single address.
-// For example, try_on_all_addresses -> backoff -> try_on_all_addresses.
+// Each SubConn contains a list of addresses.
 //
-// All SubConns start in IDLE, and will not try to connect. To trigger
-// the connecting, Balancers must call Connect.
-// When the connection encounters an error, it will reconnect immediately.
-// When the connection becomes IDLE, it will not reconnect unless Connect is
-// called.
+// All SubConns start in IDLE, and will not try to connect. To trigger the
+// connecting, Balancers must call Connect.  If a connection re-enters IDLE,
+// Balancers must call Connect again to trigger a new connection attempt.
 //
-// This interface is to be implemented by gRPC. Users should not need a
-// brand new implementation of this interface. For the situations like
-// testing, the new implementation should embed this interface. This allows
-// gRPC to add new methods to this interface.
+// gRPC will try to connect to the addresses in sequence, and stop trying the
+// remainder once the first connection is successful. If an attempt to connect
+// to all addresses encounters an error, the SubConn will enter
+// TRANSIENT_FAILURE for a backoff period, and then transition to IDLE.
+//
+// Once established, if a connection is lost, the SubConn will transition
+// directly to IDLE.
+//
+// This interface is to be implemented by gRPC. Users should not need their own
+// implementation of this interface. For situations like testing, any
+// implementations should embed this interface. This allows gRPC to add new
+// methods to this interface.
 type SubConn interface {
 	// UpdateAddresses updates the addresses used in this SubConn.
 	// gRPC checks if currently-connected address is still in the new list.
@@ -326,6 +328,20 @@ type Balancer interface {
 	Close()
 }
 
+// ExitIdler is an optional interface for balancers to implement.  If
+// implemented, ExitIdle will be called when ClientConn.Connect is called, if
+// the ClientConn is idle.  If unimplemented, ClientConn.Connect will cause
+// all SubConns to connect.
+//
+// Notice: it will be required for all balancers to implement this in a future
+// release.
+type ExitIdler interface {
+	// ExitIdle instructs the LB policy to reconnect to backends / exit the
+	// IDLE state, if appropriate and possible.  Note that SubConns that enter
+	// the IDLE state will not reconnect until SubConn.Connect is called.
+	ExitIdle()
+}
+
 // SubConnState describes the state of a SubConn.
 type SubConnState struct {
 	// ConnectivityState is the connectivity state of the SubConn.
@@ -353,8 +369,10 @@ var ErrBadResolverState = errors.New("bad resolver state")
 //
 // It's not thread safe.
 type ConnectivityStateEvaluator struct {
-	numReady      uint64 // Number of addrConns in ready state.
-	numConnecting uint64 // Number of addrConns in connecting state.
+	numReady            uint64 // Number of addrConns in ready state.
+	numConnecting       uint64 // Number of addrConns in connecting state.
+	numTransientFailure uint64 // Number of addrConns in transient failure state.
+	numIdle             uint64 // Number of addrConns in idle state.
 }
 
 // RecordTransition records state change happening in subConn and based on that
@@ -362,9 +380,11 @@ type ConnectivityStateEvaluator struct {
 //
 //  - If at least one SubConn in Ready, the aggregated state is Ready;
 //  - Else if at least one SubConn in Connecting, the aggregated state is Connecting;
-//  - Else the aggregated state is TransientFailure.
+//  - Else if at least one SubConn is TransientFailure, the aggregated state is Transient Failure;
+//  - Else if at least one SubConn is Idle, the aggregated state is Idle;
+//  - Else there are no subconns and the aggregated state is Transient Failure
 //
-// Idle and Shutdown are not considered.
+// Shutdown is not considered.
 func (cse *ConnectivityStateEvaluator) RecordTransition(oldState, newState connectivity.State) connectivity.State {
 	// Update counters.
 	for idx, state := range []connectivity.State{oldState, newState} {
@@ -374,6 +394,10 @@ func (cse *ConnectivityStateEvaluator) RecordTransition(oldState, newState conne
 			cse.numReady += updateVal
 		case connectivity.Connecting:
 			cse.numConnecting += updateVal
+		case connectivity.TransientFailure:
+			cse.numTransientFailure += updateVal
+		case connectivity.Idle:
+			cse.numIdle += updateVal
 		}
 	}
 
@@ -384,5 +408,11 @@ func (cse *ConnectivityStateEvaluator) RecordTransition(oldState, newState conne
 	if cse.numConnecting > 0 {
 		return connectivity.Connecting
 	}
+	if cse.numTransientFailure > 0 {
+		return connectivity.TransientFailure
+	}
+	if cse.numIdle > 0 {
+		return connectivity.Idle
+	}
 	return connectivity.TransientFailure
 }
diff --git a/vendor/google.golang.org/grpc/balancer/base/balancer.go b/vendor/google.golang.org/grpc/balancer/base/balancer.go
index c883efa0bb..8dd504299f 100644
--- a/vendor/google.golang.org/grpc/balancer/base/balancer.go
+++ b/vendor/google.golang.org/grpc/balancer/base/balancer.go
@@ -133,6 +133,7 @@ func (b *baseBalancer) UpdateClientConnState(s balancer.ClientConnState) error {
 			}
 			b.subConns[aNoAttrs] = subConnInfo{subConn: sc, attrs: a.Attributes}
 			b.scStates[sc] = connectivity.Idle
+			b.csEvltr.RecordTransition(connectivity.Shutdown, connectivity.Idle)
 			sc.Connect()
 		} else {
 			// Always update the subconn's address in case the attributes
@@ -213,10 +214,14 @@ func (b *baseBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.Su
 		}
 		return
 	}
-	if oldS == connectivity.TransientFailure && s == connectivity.Connecting {
-		// Once a subconn enters TRANSIENT_FAILURE, ignore subsequent
+	if oldS == connectivity.TransientFailure &&
+		(s == connectivity.Connecting || s == connectivity.Idle) {
+		// Once a subconn enters TRANSIENT_FAILURE, ignore subsequent IDLE or
 		// CONNECTING transitions to prevent the aggregated state from being
 		// always CONNECTING when many backends exist but are all down.
+		if s == connectivity.Idle {
+			sc.Connect()
+		}
 		return
 	}
 	b.scStates[sc] = s
@@ -242,7 +247,6 @@ func (b *baseBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.Su
 		b.state == connectivity.TransientFailure {
 		b.regeneratePicker()
 	}
-
 	b.cc.UpdateState(balancer.State{ConnectivityState: b.state, Picker: b.picker})
 }
 
@@ -251,6 +255,11 @@ func (b *baseBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.Su
 func (b *baseBalancer) Close() {
 }
 
+// ExitIdle is a nop because the base balancer attempts to stay connected to
+// all SubConns at all times.
+func (b *baseBalancer) ExitIdle() {
+}
+
 // NewErrPicker returns a Picker that always returns err on Pick().
 func NewErrPicker(err error) balancer.Picker {
 	return &errPicker{err: err}
diff --git a/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
index 43c2a15373..274eb2f858 100644
--- a/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
+++ b/vendor/google.golang.org/grpc/balancer/roundrobin/roundrobin.go
@@ -47,11 +47,11 @@ func init() {
 type rrPickerBuilder struct{}
 
 func (*rrPickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
-	logger.Infof("roundrobinPicker: newPicker called with info: %v", info)
+	logger.Infof("roundrobinPicker: Build called with info: %v", info)
 	if len(info.ReadySCs) == 0 {
 		return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
 	}
-	var scs []balancer.SubConn
+	scs := make([]balancer.SubConn, 0, len(info.ReadySCs))
 	for sc := range info.ReadySCs {
 		scs = append(scs, sc)
 	}
diff --git a/vendor/google.golang.org/grpc/balancer_conn_wrappers.go b/vendor/google.golang.org/grpc/balancer_conn_wrappers.go
index dd83979639..f4ea617468 100644
--- a/vendor/google.golang.org/grpc/balancer_conn_wrappers.go
+++ b/vendor/google.golang.org/grpc/balancer_conn_wrappers.go
@@ -37,15 +37,20 @@ type scStateUpdate struct {
 	err   error
 }
 
+// exitIdle contains no data and is just a signal sent on the updateCh in
+// ccBalancerWrapper to instruct the balancer to exit idle.
+type exitIdle struct{}
+
 // ccBalancerWrapper is a wrapper on top of cc for balancers.
 // It implements balancer.ClientConn interface.
 type ccBalancerWrapper struct {
-	cc         *ClientConn
-	balancerMu sync.Mutex // synchronizes calls to the balancer
-	balancer   balancer.Balancer
-	updateCh   *buffer.Unbounded
-	closed     *grpcsync.Event
-	done       *grpcsync.Event
+	cc          *ClientConn
+	balancerMu  sync.Mutex // synchronizes calls to the balancer
+	balancer    balancer.Balancer
+	hasExitIdle bool
+	updateCh    *buffer.Unbounded
+	closed      *grpcsync.Event
+	done        *grpcsync.Event
 
 	mu       sync.Mutex
 	subConns map[*acBalancerWrapper]struct{}
@@ -61,6 +66,7 @@ func newCCBalancerWrapper(cc *ClientConn, b balancer.Builder, bopts balancer.Bui
 	}
 	go ccb.watcher()
 	ccb.balancer = b.Build(ccb, bopts)
+	_, ccb.hasExitIdle = ccb.balancer.(balancer.ExitIdler)
 	return ccb
 }
 
@@ -86,6 +92,17 @@ func (ccb *ccBalancerWrapper) watcher() {
 					ccb.cc.removeAddrConn(u.getAddrConn(), errConnDrain)
 				}
 				ccb.mu.Unlock()
+			case exitIdle:
+				if ccb.cc.GetState() == connectivity.Idle {
+					if ei, ok := ccb.balancer.(balancer.ExitIdler); ok {
+						// We already checked that the balancer implements
+						// ExitIdle before pushing the event to updateCh, but
+						// check conditionally again as defensive programming.
+						ccb.balancerMu.Lock()
+						ei.ExitIdle()
+						ccb.balancerMu.Unlock()
+					}
+				}
 			default:
 				logger.Errorf("ccBalancerWrapper.watcher: unknown update %+v, type %T", t, t)
 			}
@@ -118,6 +135,14 @@ func (ccb *ccBalancerWrapper) close() {
 	<-ccb.done.Done()
 }
 
+func (ccb *ccBalancerWrapper) exitIdle() bool {
+	if !ccb.hasExitIdle {
+		return false
+	}
+	ccb.updateCh.Put(exitIdle{})
+	return true
+}
+
 func (ccb *ccBalancerWrapper) handleSubConnStateChange(sc balancer.SubConn, s connectivity.State, err error) {
 	// When updating addresses for a SubConn, if the address in use is not in
 	// the new addresses, the old ac will be tearDown() and a new ac will be
@@ -144,8 +169,8 @@ func (ccb *ccBalancerWrapper) updateClientConnState(ccs *balancer.ClientConnStat
 
 func (ccb *ccBalancerWrapper) resolverError(err error) {
 	ccb.balancerMu.Lock()
+	defer ccb.balancerMu.Unlock()
 	ccb.balancer.ResolverError(err)
-	ccb.balancerMu.Unlock()
 }
 
 func (ccb *ccBalancerWrapper) NewSubConn(addrs []resolver.Address, opts balancer.NewSubConnOptions) (balancer.SubConn, error) {
@@ -239,17 +264,17 @@ func (acbw *acBalancerWrapper) UpdateAddresses(addrs []resolver.Address) {
 			return
 		}
 
-		ac, err := cc.newAddrConn(addrs, opts)
+		newAC, err := cc.newAddrConn(addrs, opts)
 		if err != nil {
 			channelz.Warningf(logger, acbw.ac.channelzID, "acBalancerWrapper: UpdateAddresses: failed to newAddrConn: %v", err)
 			return
 		}
-		acbw.ac = ac
-		ac.mu.Lock()
-		ac.acbw = acbw
-		ac.mu.Unlock()
+		acbw.ac = newAC
+		newAC.mu.Lock()
+		newAC.acbw = acbw
+		newAC.mu.Unlock()
 		if acState != connectivity.Idle {
-			ac.connect()
+			go newAC.connect()
 		}
 	}
 }
@@ -257,7 +282,7 @@ func (acbw *acBalancerWrapper) UpdateAddresses(addrs []resolver.Address) {
 func (acbw *acBalancerWrapper) Connect() {
 	acbw.mu.Lock()
 	defer acbw.mu.Unlock()
-	acbw.ac.connect()
+	go acbw.ac.connect()
 }
 
 func (acbw *acBalancerWrapper) getAddrConn() *addrConn {
diff --git a/vendor/google.golang.org/grpc/clientconn.go b/vendor/google.golang.org/grpc/clientconn.go
index b2bccfed13..34cc4c948d 100644
--- a/vendor/google.golang.org/grpc/clientconn.go
+++ b/vendor/google.golang.org/grpc/clientconn.go
@@ -322,6 +322,7 @@ func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *
 	// A blocking dial blocks until the clientConn is ready.
 	if cc.dopts.block {
 		for {
+			cc.Connect()
 			s := cc.GetState()
 			if s == connectivity.Ready {
 				break
@@ -539,12 +540,31 @@ func (cc *ClientConn) WaitForStateChange(ctx context.Context, sourceState connec
 //
 // Experimental
 //
-// Notice: This API is EXPERIMENTAL and may be changed or removed in a
-// later release.
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a later
+// release.
 func (cc *ClientConn) GetState() connectivity.State {
 	return cc.csMgr.getState()
 }
 
+// Connect causes all subchannels in the ClientConn to attempt to connect if
+// the channel is idle.  Does not wait for the connection attempts to begin
+// before returning.
+//
+// Experimental
+//
+// Notice: This API is EXPERIMENTAL and may be changed or removed in a later
+// release.
+func (cc *ClientConn) Connect() {
+	cc.mu.Lock()
+	defer cc.mu.Unlock()
+	if cc.balancerWrapper != nil && cc.balancerWrapper.exitIdle() {
+		return
+	}
+	for ac := range cc.conns {
+		go ac.connect()
+	}
+}
+
 func (cc *ClientConn) scWatcher() {
 	for {
 		select {
@@ -845,8 +865,7 @@ func (ac *addrConn) connect() error {
 	ac.updateConnectivityState(connectivity.Connecting, nil)
 	ac.mu.Unlock()
 
-	// Start a goroutine connecting to the server asynchronously.
-	go ac.resetTransport()
+	ac.resetTransport()
 	return nil
 }
 
@@ -883,6 +902,10 @@ func (ac *addrConn) tryUpdateAddrs(addrs []resolver.Address) bool {
 	// ac.state is Ready, try to find the connected address.
 	var curAddrFound bool
 	for _, a := range addrs {
+		// a.ServerName takes precedent over ClientConn authority, if present.
+		if a.ServerName == "" {
+			a.ServerName = ac.cc.authority
+		}
 		if reflect.DeepEqual(ac.curAddr, a) {
 			curAddrFound = true
 			break
@@ -1135,112 +1158,86 @@ func (ac *addrConn) adjustParams(r transport.GoAwayReason) {
 }
 
 func (ac *addrConn) resetTransport() {
-	for i := 0; ; i++ {
-		if i > 0 {
-			ac.cc.resolveNow(resolver.ResolveNowOptions{})
-		}
+	ac.mu.Lock()
+	if ac.state == connectivity.Shutdown {
+		ac.mu.Unlock()
+		return
+	}
+
+	addrs := ac.addrs
+	backoffFor := ac.dopts.bs.Backoff(ac.backoffIdx)
+	// This will be the duration that dial gets to finish.
+	dialDuration := minConnectTimeout
+	if ac.dopts.minConnectTimeout != nil {
+		dialDuration = ac.dopts.minConnectTimeout()
+	}
+
+	if dialDuration < backoffFor {
+		// Give dial more time as we keep failing to connect.
+		dialDuration = backoffFor
+	}
+	// We can potentially spend all the time trying the first address, and
+	// if the server accepts the connection and then hangs, the following
+	// addresses will never be tried.
+	//
+	// The spec doesn't mention what should be done for multiple addresses.
+	// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md#proposed-backoff-algorithm
+	connectDeadline := time.Now().Add(dialDuration)
+
+	ac.updateConnectivityState(connectivity.Connecting, nil)
+	ac.mu.Unlock()
 
+	if err := ac.tryAllAddrs(addrs, connectDeadline); err != nil {
+		ac.cc.resolveNow(resolver.ResolveNowOptions{})
+		// After exhausting all addresses, the addrConn enters
+		// TRANSIENT_FAILURE.
 		ac.mu.Lock()
 		if ac.state == connectivity.Shutdown {
 			ac.mu.Unlock()
 			return
 		}
+		ac.updateConnectivityState(connectivity.TransientFailure, err)
 
-		addrs := ac.addrs
-		backoffFor := ac.dopts.bs.Backoff(ac.backoffIdx)
-		// This will be the duration that dial gets to finish.
-		dialDuration := minConnectTimeout
-		if ac.dopts.minConnectTimeout != nil {
-			dialDuration = ac.dopts.minConnectTimeout()
-		}
-
-		if dialDuration < backoffFor {
-			// Give dial more time as we keep failing to connect.
-			dialDuration = backoffFor
-		}
-		// We can potentially spend all the time trying the first address, and
-		// if the server accepts the connection and then hangs, the following
-		// addresses will never be tried.
-		//
-		// The spec doesn't mention what should be done for multiple addresses.
-		// https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md#proposed-backoff-algorithm
-		connectDeadline := time.Now().Add(dialDuration)
-
-		ac.updateConnectivityState(connectivity.Connecting, nil)
-		ac.transport = nil
+		// Backoff.
+		b := ac.resetBackoff
 		ac.mu.Unlock()
 
-		newTr, addr, reconnect, err := ac.tryAllAddrs(addrs, connectDeadline)
-		if err != nil {
-			// After exhausting all addresses, the addrConn enters
-			// TRANSIENT_FAILURE.
+		timer := time.NewTimer(backoffFor)
+		select {
+		case <-timer.C:
 			ac.mu.Lock()
-			if ac.state == connectivity.Shutdown {
-				ac.mu.Unlock()
-				return
-			}
-			ac.updateConnectivityState(connectivity.TransientFailure, err)
-
-			// Backoff.
-			b := ac.resetBackoff
+			ac.backoffIdx++
 			ac.mu.Unlock()
-
-			timer := time.NewTimer(backoffFor)
-			select {
-			case <-timer.C:
-				ac.mu.Lock()
-				ac.backoffIdx++
-				ac.mu.Unlock()
-			case <-b:
-				timer.Stop()
-			case <-ac.ctx.Done():
-				timer.Stop()
-				return
-			}
-			continue
+		case <-b:
+			timer.Stop()
+		case <-ac.ctx.Done():
+			timer.Stop()
+			return
 		}
 
 		ac.mu.Lock()
-		if ac.state == connectivity.Shutdown {
-			ac.mu.Unlock()
-			newTr.Close(fmt.Errorf("reached connectivity state: SHUTDOWN"))
-			return
+		if ac.state != connectivity.Shutdown {
+			ac.updateConnectivityState(connectivity.Idle, err)
 		}
-		ac.curAddr = addr
-		ac.transport = newTr
-		ac.backoffIdx = 0
-
-		hctx, hcancel := context.WithCancel(ac.ctx)
-		ac.startHealthCheck(hctx)
 		ac.mu.Unlock()
-
-		// Block until the created transport is down. And when this happens,
-		// we restart from the top of the addr list.
-		<-reconnect.Done()
-		hcancel()
-		// restart connecting - the top of the loop will set state to
-		// CONNECTING.  This is against the current connectivity semantics doc,
-		// however it allows for graceful behavior for RPCs not yet dispatched
-		// - unfortunate timing would otherwise lead to the RPC failing even
-		// though the TRANSIENT_FAILURE state (called for by the doc) would be
-		// instantaneous.
-		//
-		// Ideally we should transition to Idle here and block until there is
-		// RPC activity that leads to the balancer requesting a reconnect of
-		// the associated SubConn.
+		return
 	}
+	// Success; reset backoff.
+	ac.mu.Lock()
+	ac.backoffIdx = 0
+	ac.mu.Unlock()
 }
 
-// tryAllAddrs tries to creates a connection to the addresses, and stop when at the
-// first successful one. It returns the transport, the address and a Event in
-// the successful case. The Event fires when the returned transport disconnects.
-func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.Time) (transport.ClientTransport, resolver.Address, *grpcsync.Event, error) {
+// tryAllAddrs tries to creates a connection to the addresses, and stop when at
+// the first successful one. It returns an error if no address was successfully
+// connected, or updates ac appropriately with the new transport.
+func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.Time) error {
 	var firstConnErr error
 	for _, addr := range addrs {
 		ac.mu.Lock()
 		if ac.state == connectivity.Shutdown {
 			ac.mu.Unlock()
-			return nil, resolver.Address{}, nil, errConnClosing
+			return errConnClosing
 		}
 
 		ac.cc.mu.RLock()
@@ -1255,9 +1252,9 @@ func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.T
 
 		channelz.Infof(logger, ac.channelzID, "Subchannel picks a new address %q to connect", addr.Addr)
 
-		newTr, reconnect, err := ac.createTransport(addr, copts, connectDeadline)
+		err := ac.createTransport(addr, copts, connectDeadline)
 		if err == nil {
-			return newTr, addr, reconnect, nil
+			return nil
 		}
 		if firstConnErr == nil {
 			firstConnErr = err
@@ -1266,57 +1263,54 @@ func (ac *addrConn) tryAllAddrs(addrs []resolver.Address, connectDeadline time.T
 	}
 
 	// Couldn't connect to any address.
-	return nil, resolver.Address{}, nil, firstConnErr
+	return firstConnErr
 }
 
-// createTransport creates a connection to addr. It returns the transport and a
-// Event in the successful case. The Event fires when the returned transport
-// disconnects.
-func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) (transport.ClientTransport, *grpcsync.Event, error) {
-	prefaceReceived := make(chan struct{})
-	onCloseCalled := make(chan struct{})
-	reconnect := grpcsync.NewEvent()
+// createTransport creates a connection to addr. It returns an error if the
+// address was not successfully connected, or updates ac appropriately with the
+// new transport.
+func (ac *addrConn) createTransport(addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) error {
+	// TODO: Delete prefaceReceived and move the logic to wait for it into the
+	// transport.
+	prefaceReceived := grpcsync.NewEvent()
+	connClosed := grpcsync.NewEvent()
 
 	// addr.ServerName takes precedent over ClientConn authority, if present.
 	if addr.ServerName == "" {
 		addr.ServerName = ac.cc.authority
 	}
 
-	once := sync.Once{}
-	onGoAway := func(r transport.GoAwayReason) {
-		ac.mu.Lock()
-		ac.adjustParams(r)
-		once.Do(func() {
-			if ac.state == connectivity.Ready {
-				// Prevent this SubConn from being used for new RPCs by setting its
-				// state to Connecting.
-				//
-				// TODO: this should be Idle when grpc-go properly supports it.
-				ac.updateConnectivityState(connectivity.Connecting, nil)
-			}
-		})
-		ac.mu.Unlock()
-		reconnect.Fire()
-	}
+	hctx, hcancel := context.WithCancel(ac.ctx)
+	hcStarted := false // protected by ac.mu
 
 	onClose := func() {
 		ac.mu.Lock()
-		once.Do(func() {
-			if ac.state == connectivity.Ready {
-				// Prevent this SubConn from being used for new RPCs by setting its
-				// state to Connecting.
-				//
-				// TODO: this should be Idle when grpc-go properly supports it.
-				ac.updateConnectivityState(connectivity.Connecting, nil)
-			}
-		})
-		ac.mu.Unlock()
-		close(onCloseCalled)
-		reconnect.Fire()
+		defer ac.mu.Unlock()
+		defer connClosed.Fire()
+		if !hcStarted || hctx.Err() != nil {
+			// We didn't start the health check or set the state to READY, so
+			// no need to do anything else here.
+			//
+			// OR, we have already cancelled the health check context, meaning
+			// we have already called onClose once for this transport.  In this
+			// case it would be dangerous to clear the transport and update the
+			// state, since there may be a new transport in this addrConn.
+			return
+		}
+		hcancel()
+		ac.transport = nil
+		// Refresh the name resolver
+		ac.cc.resolveNow(resolver.ResolveNowOptions{})
+		if ac.state != connectivity.Shutdown {
+			ac.updateConnectivityState(connectivity.Idle, nil)
+		}
 	}
 
-	onPrefaceReceipt := func() {
-		close(prefaceReceived)
+	onGoAway := func(r transport.GoAwayReason) {
+		ac.mu.Lock()
+		ac.adjustParams(r)
+		ac.mu.Unlock()
+		onClose()
 	}
 
 	connectCtx, cancel := context.WithDeadline(ac.ctx, connectDeadline)
@@ -1325,27 +1319,67 @@ func (ac *addrConn) createTransport(addr resolver.Address, copts transport.Conne
 		copts.ChannelzParentID = ac.channelzID
 	}
 
-	newTr, err := transport.NewClientTransport(connectCtx, ac.cc.ctx, addr, copts, onPrefaceReceipt, onGoAway, onClose)
+	newTr, err := transport.NewClientTransport(connectCtx, ac.cc.ctx, addr, copts, func() { prefaceReceived.Fire() }, onGoAway, onClose)
 	if err != nil {
 		// newTr is either nil, or closed.
-		channelz.Warningf(logger, ac.channelzID, "grpc: addrConn.createTransport failed to connect to %v. Err: %v. Reconnecting...", addr, err)
-		return nil, nil, err
+		channelz.Warningf(logger, ac.channelzID, "grpc: addrConn.createTransport failed to connect to %v. Err: %v", addr, err)
+		return err
 	}
 
 	select {
-	case <-time.After(time.Until(connectDeadline)):
+	case <-connectCtx.Done():
 		// We didn't get the preface in time.
-		newTr.Close(fmt.Errorf("failed to receive server preface within timeout"))
-		channelz.Warningf(logger, ac.channelzID, "grpc: addrConn.createTransport failed to connect to %v: didn't receive server preface in time. Reconnecting...", addr)
-		return nil, nil, errors.New("timed out waiting for server handshake")
-	case <-prefaceReceived:
+		// The error we pass to Close() is immaterial since there are no open
+		// streams at this point, so no trailers with error details will be sent
+		// out. We just need to pass a non-nil error.
+		newTr.Close(transport.ErrConnClosing)
+		if connectCtx.Err() == context.DeadlineExceeded {
+			err := errors.New("failed to receive server preface within timeout")
+			channelz.Warningf(logger, ac.channelzID, "grpc: addrConn.createTransport failed to connect to %v: %v", addr, err)
+			return err
+		}
+		return nil
+	case <-prefaceReceived.Done():
 		// We got the preface - huzzah! things are good.
-	case <-onCloseCalled:
-		// The transport has already closed - noop.
-		return nil, nil, errors.New("connection closed")
-		// TODO(deklerk) this should bail on ac.ctx.Done(). Add a test and fix.
+		ac.mu.Lock()
+		defer ac.mu.Unlock()
+		if connClosed.HasFired() {
+			// onClose called first; go idle but do nothing else.
+			if ac.state != connectivity.Shutdown {
+				ac.updateConnectivityState(connectivity.Idle, nil)
+			}
+			return nil
+		}
+		if ac.state == connectivity.Shutdown {
+			// This can happen if the subConn was removed while in `Connecting`
+			// state. tearDown() would have set the state to `Shutdown`, but
+			// would not have closed the transport since ac.transport would not
+			// been set at that point.
+			//
+			// We run this in a goroutine because newTr.Close() calls onClose()
+			// inline, which requires locking ac.mu.
+			//
+			// The error we pass to Close() is immaterial since there are no open
+			// streams at this point, so no trailers with error details will be sent
+			// out. We just need to pass a non-nil error.
+			go newTr.Close(transport.ErrConnClosing)
+			return nil
+		}
+		ac.curAddr = addr
+		ac.transport = newTr
+		hcStarted = true
+		ac.startHealthCheck(hctx) // Will set state to READY if appropriate.
+		return nil
+	case <-connClosed.Done():
+		// The transport has already closed.  If we received the preface, too,
+		// this is not an error.
+		select {
+		case <-prefaceReceived.Done():
+			return nil
+		default:
+			return errors.New("connection closed before server preface received")
+		}
 	}
-	return newTr, reconnect, nil
 }
 
 // startHealthCheck starts the health checking stream (RPC) to watch the health
diff --git a/vendor/google.golang.org/grpc/connectivity/connectivity.go b/vendor/google.golang.org/grpc/connectivity/connectivity.go
index 0101562615..4a89926422 100644
--- a/vendor/google.golang.org/grpc/connectivity/connectivity.go
+++ b/vendor/google.golang.org/grpc/connectivity/connectivity.go
@@ -18,7 +18,6 @@
 
 // Package connectivity defines connectivity semantics.
 // For details, see https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md.
-// All APIs in this package are experimental.
 package connectivity
 
 import (
@@ -45,7 +44,7 @@ func (s State) String() string {
 		return "SHUTDOWN"
 	default:
 		logger.Errorf("unknown connectivity state: %d", s)
-		return "Invalid-State"
+		return "INVALID_STATE"
 	}
 }
 
@@ -61,3 +60,35 @@ const (
 	// Shutdown indicates the ClientConn has started shutting down.
 	Shutdown
 )
+
+// ServingMode indicates the current mode of operation of the server.
+//
+// Only xDS enabled gRPC servers currently report their serving mode.
+type ServingMode int
+
+const (
+	// ServingModeStarting indicates that the server is starting up.
+	ServingModeStarting ServingMode = iota
+	// ServingModeServing indicates that the server contains all required
+	// configuration and is serving RPCs.
+	ServingModeServing
+	// ServingModeNotServing indicates that the server is not accepting new
+	// connections. Existing connections will be closed gracefully, allowing
+	// in-progress RPCs to complete. A server enters this mode when it does not
+	// contain the required configuration to serve RPCs.
+	ServingModeNotServing
+)
+
+func (s ServingMode) String() string {
+	switch s {
+	case ServingModeStarting:
+		return "STARTING"
+	case ServingModeServing:
+		return "SERVING"
+	case ServingModeNotServing:
+		return "NOT_SERVING"
+	default:
+		logger.Errorf("unknown serving mode: %d", s)
+		return "INVALID_MODE"
+	}
+}
diff --git a/vendor/google.golang.org/grpc/credentials/go12.go b/vendor/google.golang.org/grpc/credentials/go12.go
deleted file mode 100644
index ccbf35b331..0000000000
--- a/vendor/google.golang.org/grpc/credentials/go12.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// +build go1.12
-
-/*
- *
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package credentials
-
-import "crypto/tls"
-
-// This init function adds cipher suite constants only defined in Go 1.12.
-func init() {
-	cipherSuiteLookup[tls.TLS_AES_128_GCM_SHA256] = "TLS_AES_128_GCM_SHA256"
-	cipherSuiteLookup[tls.TLS_AES_256_GCM_SHA384] = "TLS_AES_256_GCM_SHA384"
-	cipherSuiteLookup[tls.TLS_CHACHA20_POLY1305_SHA256] = "TLS_CHACHA20_POLY1305_SHA256"
-}
diff --git a/vendor/google.golang.org/grpc/credentials/tls.go b/vendor/google.golang.org/grpc/credentials/tls.go
index 8ee7124f22..784822d056 100644
--- a/vendor/google.golang.org/grpc/credentials/tls.go
+++ b/vendor/google.golang.org/grpc/credentials/tls.go
@@ -230,4 +230,7 @@ var cipherSuiteLookup = map[uint16]string{
 	tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:   "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
 	tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305:    "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
 	tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305:  "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
+	tls.TLS_AES_128_GCM_SHA256:                  "TLS_AES_128_GCM_SHA256",
+	tls.TLS_AES_256_GCM_SHA384:                  "TLS_AES_256_GCM_SHA384",
+	tls.TLS_CHACHA20_POLY1305_SHA256:            "TLS_CHACHA20_POLY1305_SHA256",
 }
diff --git a/vendor/google.golang.org/grpc/go.mod b/vendor/google.golang.org/grpc/go.mod
index 2f2cf1eb76..022cc9828f 100644
--- a/vendor/google.golang.org/grpc/go.mod
+++ b/vendor/google.golang.org/grpc/go.mod
@@ -1,11 +1,11 @@
 module google.golang.org/grpc
 
-go 1.11
+go 1.14
 
 require (
-	github.com/cespare/xxhash v1.1.0
+	github.com/cespare/xxhash/v2 v2.1.1
 	github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403
-	github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0
+	github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021
 	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b
 	github.com/golang/protobuf v1.4.3
 	github.com/google/go-cmp v0.5.0
diff --git a/vendor/google.golang.org/grpc/go.sum b/vendor/google.golang.org/grpc/go.sum
index 372b4ea3d2..6e7ae0db2b 100644
--- a/vendor/google.golang.org/grpc/go.sum
+++ b/vendor/google.golang.org/grpc/go.sum
@@ -2,27 +2,25 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403 h1:cqQfy1jclcSy/FwLjemeg3SR1yaINm74aQyupQ0Bl8M=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed h1:OZmjad4L3H8ncOIR8rnb5MREYqG8ixi5+WbeUsquF0c=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158 h1:CevA8fI91PAnP8vpnXuB8ZYAZ5wqY86nAbxfgK8tWO4=
+github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0 h1:dulLQAYQFYtG5MTplgNGHWuV2D+OBD+Z8lmDBmbLg+s=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021 h1:fP+fF0up6oPY49OrjPrhIJ8yQfdIM85NXMLkMg1EXVs=
+github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
 github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
@@ -54,11 +52,10 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -122,7 +119,8 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.3 h1:fvjTMHxHEw/mxHbtzPi3JCcKXQRAnQTBRo6YCJSVHKI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/vendor/google.golang.org/grpc/install_gae.sh b/vendor/google.golang.org/grpc/install_gae.sh
deleted file mode 100644
index 15ff9facdd..0000000000
--- a/vendor/google.golang.org/grpc/install_gae.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-
-TMP=$(mktemp -d /tmp/sdk.XXX) \
-&& curl -o $TMP.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.68.zip" \
-&& unzip -q $TMP.zip -d $TMP \
-&& export PATH="$PATH:$TMP/go_appengine"
\ No newline at end of file
diff --git a/vendor/google.golang.org/grpc/internal/channelz/funcs.go b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
index f731413930..6d5760d951 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/funcs.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/funcs.go
@@ -630,7 +630,7 @@ func (c *channelMap) GetServerSockets(id int64, startID int64, maxResults int64)
 	if count == 0 {
 		end = true
 	}
-	var s []*SocketMetric
+	s := make([]*SocketMetric, 0, len(sks))
 	for _, ns := range sks {
 		sm := &SocketMetric{}
 		sm.SocketData = ns.s.ChannelzMetric()
diff --git a/vendor/google.golang.org/grpc/internal/channelz/types_linux.go b/vendor/google.golang.org/grpc/internal/channelz/types_linux.go
index 692dd61817..1b1c4cce34 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/types_linux.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/types_linux.go
@@ -1,5 +1,3 @@
-// +build !appengine
-
 /*
  *
  * Copyright 2018 gRPC authors.
diff --git a/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go b/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go
index 19c2fc521d..8b06eed1ab 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/types_nonlinux.go
@@ -1,4 +1,5 @@
-// +build !linux appengine
+//go:build !linux
+// +build !linux
 
 /*
  *
@@ -37,6 +38,6 @@ type SocketOptionData struct {
 // Windows OS doesn't support Socket Option
 func (s *SocketOptionData) Getsockopt(fd uintptr) {
 	once.Do(func() {
-		logger.Warning("Channelz: socket options are not supported on non-linux os and appengine.")
+		logger.Warning("Channelz: socket options are not supported on non-linux environments")
 	})
 }
diff --git a/vendor/google.golang.org/grpc/internal/channelz/util_linux.go b/vendor/google.golang.org/grpc/internal/channelz/util_linux.go
index fdf409d55d..8d194e44e1 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/util_linux.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/util_linux.go
@@ -1,5 +1,3 @@
-// +build linux,!appengine
-
 /*
  *
  * Copyright 2018 gRPC authors.
diff --git a/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go b/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go
index 8864a08111..837ddc4024 100644
--- a/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go
+++ b/vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go
@@ -1,4 +1,5 @@
-// +build !linux appengine
+//go:build !linux
+// +build !linux
 
 /*
  *
diff --git a/vendor/google.golang.org/grpc/internal/credentials/spiffe.go b/vendor/google.golang.org/grpc/internal/credentials/spiffe.go
index be70b6cdfc..25ade62305 100644
--- a/vendor/google.golang.org/grpc/internal/credentials/spiffe.go
+++ b/vendor/google.golang.org/grpc/internal/credentials/spiffe.go
@@ -1,5 +1,3 @@
-// +build !appengine
-
 /*
  *
  * Copyright 2020 gRPC authors.
diff --git a/vendor/google.golang.org/grpc/internal/credentials/spiffe_appengine.go b/vendor/google.golang.org/grpc/internal/credentials/spiffe_appengine.go
deleted file mode 100644
index af6f577197..0000000000
--- a/vendor/google.golang.org/grpc/internal/credentials/spiffe_appengine.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// +build appengine
-
-/*
- *
- * Copyright 2020 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package credentials
-
-import (
-	"crypto/tls"
-	"net/url"
-)
-
-// SPIFFEIDFromState is a no-op for appengine builds.
-func SPIFFEIDFromState(state tls.ConnectionState) *url.URL {
-	return nil
-}
diff --git a/vendor/google.golang.org/grpc/internal/credentials/syscallconn.go b/vendor/google.golang.org/grpc/internal/credentials/syscallconn.go
index f499a614c2..2919632d65 100644
--- a/vendor/google.golang.org/grpc/internal/credentials/syscallconn.go
+++ b/vendor/google.golang.org/grpc/internal/credentials/syscallconn.go
@@ -1,5 +1,3 @@
-// +build !appengine
-
 /*
  *
  * Copyright 2018 gRPC authors.
diff --git a/vendor/google.golang.org/grpc/internal/credentials/syscallconn_appengine.go b/vendor/google.golang.org/grpc/internal/credentials/syscallconn_appengine.go
deleted file mode 100644
index a6144cd661..0000000000
--- a/vendor/google.golang.org/grpc/internal/credentials/syscallconn_appengine.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// +build appengine
-
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package credentials
-
-import (
-	"net"
-)
-
-// WrapSyscallConn returns newConn on appengine.
-func WrapSyscallConn(rawConn, newConn net.Conn) net.Conn {
-	return newConn
-}
diff --git a/vendor/google.golang.org/grpc/internal/credentials/util.go b/vendor/google.golang.org/grpc/internal/credentials/util.go
index 55664fa46b..f792fd22ca 100644
--- a/vendor/google.golang.org/grpc/internal/credentials/util.go
+++ b/vendor/google.golang.org/grpc/internal/credentials/util.go
@@ -18,7 +18,9 @@
 
 package credentials
 
-import "crypto/tls"
+import (
+	"crypto/tls"
+)
 
 const alpnProtoStrH2 = "h2"
 
diff --git a/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
index 73931a94bc..e766ac04af 100644
--- a/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
+++ b/vendor/google.golang.org/grpc/internal/envconfig/envconfig.go
@@ -22,6 +22,8 @@ package envconfig
 import (
 	"os"
 	"strings"
+
+	xdsenv "google.golang.org/grpc/internal/xds/env"
 )
 
 const (
@@ -31,8 +33,8 @@ const (
 )
 
 var (
-	// Retry is set if retry is explicitly enabled via "GRPC_GO_RETRY=on".
-	Retry = strings.EqualFold(os.Getenv(retryStr), "on")
+	// Retry is set if retry is explicitly enabled via "GRPC_GO_RETRY=on" or if XDS retry support is enabled.
+	Retry = strings.EqualFold(os.Getenv(retryStr), "on") || xdsenv.RetrySupport
 	// TXTErrIgnore is set if TXT errors should be ignored ("GRPC_GO_IGNORE_TXT_ERRORS" is not "false").
 	TXTErrIgnore = !strings.EqualFold(os.Getenv(txtErrIgnoreStr), "false")
 )
diff --git a/vendor/google.golang.org/grpc/internal/resolver/config_selector.go b/vendor/google.golang.org/grpc/internal/resolver/config_selector.go
index 5e7f36703d..be7e13d585 100644
--- a/vendor/google.golang.org/grpc/internal/resolver/config_selector.go
+++ b/vendor/google.golang.org/grpc/internal/resolver/config_selector.go
@@ -117,9 +117,12 @@ type ClientInterceptor interface {
 	NewStream(ctx context.Context, ri RPCInfo, done func(), newStream func(ctx context.Context, done func()) (ClientStream, error)) (ClientStream, error)
 }
 
-// ServerInterceptor is unimplementable; do not use.
+// ServerInterceptor is an interceptor for incoming RPC's on gRPC server side.
 type ServerInterceptor interface {
-	notDefined()
+	// AllowRPC checks if an incoming RPC is allowed to proceed based on
+	// information about connection RPC was received on, and HTTP Headers. This
+	// information will be piped into context.
+	AllowRPC(ctx context.Context) error // TODO: Make this a real interceptor for filters such as rate limiting.
 }
 
 type csKeyType string
diff --git a/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go b/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
index 03825bbe7b..75301c5149 100644
--- a/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
+++ b/vendor/google.golang.org/grpc/internal/resolver/dns/dns_resolver.go
@@ -277,18 +277,13 @@ func (d *dnsResolver) lookupSRV() ([]resolver.Address, error) {
 	return newAddrs, nil
 }
 
-var filterError = func(err error) error {
+func handleDNSError(err error, lookupType string) error {
 	if dnsErr, ok := err.(*net.DNSError); ok && !dnsErr.IsTimeout && !dnsErr.IsTemporary {
 		// Timeouts and temporary errors should be communicated to gRPC to
 		// attempt another DNS query (with backoff).  Other errors should be
 		// suppressed (they may represent the absence of a TXT record).
 		return nil
 	}
-	return err
-}
-
-func handleDNSError(err error, lookupType string) error {
-	err = filterError(err)
 	if err != nil {
 		err = fmt.Errorf("dns: %v record lookup error: %v", lookupType, err)
 		logger.Info(err)
@@ -323,12 +318,12 @@ func (d *dnsResolver) lookupTXT() *serviceconfig.ParseResult {
 }
 
 func (d *dnsResolver) lookupHost() ([]resolver.Address, error) {
-	var newAddrs []resolver.Address
 	addrs, err := d.resolver.LookupHost(d.ctx, d.host)
 	if err != nil {
 		err = handleDNSError(err, "A")
 		return nil, err
 	}
+	newAddrs := make([]resolver.Address, 0, len(addrs))
 	for _, a := range addrs {
 		ip, ok := formatIP(a)
 		if !ok {
diff --git a/vendor/google.golang.org/grpc/internal/resolver/dns/go113.go b/vendor/google.golang.org/grpc/internal/resolver/dns/go113.go
deleted file mode 100644
index 8783a8cf82..0000000000
--- a/vendor/google.golang.org/grpc/internal/resolver/dns/go113.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// +build go1.13
-
-/*
- *
- * Copyright 2019 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package dns
-
-import "net"
-
-func init() {
-	filterError = func(err error) error {
-		if dnsErr, ok := err.(*net.DNSError); ok && dnsErr.IsNotFound {
-			// The name does not exist; not an error.
-			return nil
-		}
-		return err
-	}
-}
diff --git a/vendor/google.golang.org/grpc/internal/serviceconfig/serviceconfig.go b/vendor/google.golang.org/grpc/internal/serviceconfig/serviceconfig.go
index c0634d152c..badbdbf597 100644
--- a/vendor/google.golang.org/grpc/internal/serviceconfig/serviceconfig.go
+++ b/vendor/google.golang.org/grpc/internal/serviceconfig/serviceconfig.go
@@ -78,6 +78,7 @@ func (bc *BalancerConfig) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
+	var names []string
 	for i, lbcfg := range ir {
 		if len(lbcfg) != 1 {
 			return fmt.Errorf("invalid loadBalancingConfig: entry %v does not contain exactly 1 policy/config pair: %q", i, lbcfg)
@@ -92,6 +93,7 @@ func (bc *BalancerConfig) UnmarshalJSON(b []byte) error {
 		for name, jsonCfg = range lbcfg {
 		}
 
+		names = append(names, name)
 		builder := balancer.Get(name)
 		if builder == nil {
 			// If the balancer is not registered, move on to the next config.
@@ -120,7 +122,7 @@ func (bc *BalancerConfig) UnmarshalJSON(b []byte) error {
 	// return. This means we had a loadBalancingConfig slice but did not
 	// encounter a registered policy. The config is considered invalid in this
 	// case.
-	return fmt.Errorf("invalid loadBalancingConfig: no supported policies found")
+	return fmt.Errorf("invalid loadBalancingConfig: no supported policies found in %v", names)
 }
 
 // MethodConfig defines the configuration recommended by the service providers for a
diff --git a/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go b/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go
index 4b2964f2a1..b3a72276de 100644
--- a/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go
+++ b/vendor/google.golang.org/grpc/internal/syscall/syscall_linux.go
@@ -1,5 +1,3 @@
-// +build !appengine
-
 /*
  *
  * Copyright 2018 gRPC authors.
diff --git a/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
index 7913ef1dbf..999f52cd75 100644
--- a/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
+++ b/vendor/google.golang.org/grpc/internal/syscall/syscall_nonlinux.go
@@ -1,4 +1,5 @@
-// +build !linux appengine
+//go:build !linux
+// +build !linux
 
 /*
  *
@@ -35,41 +36,41 @@ var logger = grpclog.Component("core")
 
 func log() {
 	once.Do(func() {
-		logger.Info("CPU time info is unavailable on non-linux or appengine environment.")
+		logger.Info("CPU time info is unavailable on non-linux environments.")
 	})
 }
 
-// GetCPUTime returns the how much CPU time has passed since the start of this process.
-// It always returns 0 under non-linux or appengine environment.
+// GetCPUTime returns the how much CPU time has passed since the start of this
+// process. It always returns 0 under non-linux environments.
 func GetCPUTime() int64 {
 	log()
 	return 0
 }
 
-// Rusage is an empty struct under non-linux or appengine environment.
+// Rusage is an empty struct under non-linux environments.
 type Rusage struct{}
 
-// GetRusage is a no-op function under non-linux or appengine environment.
+// GetRusage is a no-op function under non-linux environments.
 func GetRusage() *Rusage {
 	log()
 	return nil
 }
 
 // CPUTimeDiff returns the differences of user CPU time and system CPU time used
-// between two Rusage structs. It a no-op function for non-linux or appengine environment.
+// between two Rusage structs. It a no-op function for non-linux environments.
 func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
 	log()
 	return 0, 0
 }
 
-// SetTCPUserTimeout is a no-op function under non-linux or appengine environments
+// SetTCPUserTimeout is a no-op function under non-linux environments.
 func SetTCPUserTimeout(conn net.Conn, timeout time.Duration) error {
 	log()
 	return nil
 }
 
-// GetTCPUserTimeout is a no-op function under non-linux or appengine environments
-// a negative return value indicates the operation is not supported
+// GetTCPUserTimeout is a no-op function under non-linux environments.
+// A negative return value indicates the operation is not supported
 func GetTCPUserTimeout(conn net.Conn) (int, error) {
 	log()
 	return -1, nil
diff --git a/vendor/google.golang.org/grpc/internal/transport/http2_client.go b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
index 0cd6da1e73..7558630743 100644
--- a/vendor/google.golang.org/grpc/internal/transport/http2_client.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_client.go
@@ -616,12 +616,22 @@ func (t *http2Client) getCallAuthData(ctx context.Context, audience string, call
 	return callAuthData, nil
 }
 
-// NewStreamError wraps an error and reports additional information.
+// NewStreamError wraps an error and reports additional information.  Typically
+// NewStream errors result in transparent retry, as they mean nothing went onto
+// the wire.  However, there are two notable exceptions:
+//
+// 1. If the stream headers violate the max header list size allowed by the
+//    server.  In this case there is no reason to retry at all, as it is
+//    assumed the RPC would continue to fail on subsequent attempts.
+// 2. If the credentials errored when requesting their headers.  In this case,
+//    it's possible a retry can fix the problem, but indefinitely transparently
+//    retrying is not appropriate as it is likely the credentials, if they can
+//    eventually succeed, would need I/O to do so.
 type NewStreamError struct {
 	Err error
 
-	DoNotRetry  bool
-	PerformedIO bool
+	DoNotRetry            bool
+	DoNotTransparentRetry bool
 }
 
 func (e NewStreamError) Error() string {
@@ -631,24 +641,10 @@ func (e NewStreamError) Error() string {
 // NewStream creates a stream and registers it into the transport as "active"
 // streams.  All non-nil errors returned will be *NewStreamError.
 func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) {
-	defer func() {
-		if err != nil {
-			nse, ok := err.(*NewStreamError)
-			if !ok {
-				nse = &NewStreamError{Err: err}
-			}
-			if len(t.perRPCCreds) > 0 || callHdr.Creds != nil {
-				// We may have performed I/O in the per-RPC creds callback, so do not
-				// allow transparent retry.
-				nse.PerformedIO = true
-			}
-			err = nse
-		}
-	}()
 	ctx = peer.NewContext(ctx, t.getPeer())
 	headerFields, err := t.createHeaderFields(ctx, callHdr)
 	if err != nil {
-		return nil, err
+		return nil, &NewStreamError{Err: err, DoNotTransparentRetry: true}
 	}
 	s := t.newStream(ctx, callHdr)
 	cleanup := func(err error) {
@@ -748,7 +744,7 @@ func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Strea
 			return true
 		}, hdr)
 		if err != nil {
-			return nil, err
+			return nil, &NewStreamError{Err: err}
 		}
 		if success {
 			break
@@ -759,12 +755,12 @@ func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Strea
 		firstTry = false
 		select {
 		case <-ch:
-		case <-s.ctx.Done():
-			return nil, ContextErr(s.ctx.Err())
+		case <-ctx.Done():
+			return nil, &NewStreamError{Err: ContextErr(ctx.Err())}
 		case <-t.goAway:
-			return nil, errStreamDrain
+			return nil, &NewStreamError{Err: errStreamDrain}
 		case <-t.ctx.Done():
-			return nil, ErrConnClosing
+			return nil, &NewStreamError{Err: ErrConnClosing}
 		}
 	}
 	if t.statsHandler != nil {
diff --git a/vendor/google.golang.org/grpc/internal/transport/http2_server.go b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
index e3799d50aa..19c13e041d 100644
--- a/vendor/google.golang.org/grpc/internal/transport/http2_server.go
+++ b/vendor/google.golang.org/grpc/internal/transport/http2_server.go
@@ -133,6 +133,22 @@ type http2Server struct {
 // underlying conn gets closed before the client preface could be read, it
 // returns a nil transport and a nil error.
 func NewServerTransport(conn net.Conn, config *ServerConfig) (_ ServerTransport, err error) {
+	var authInfo credentials.AuthInfo
+	rawConn := conn
+	if config.Credentials != nil {
+		var err error
+		conn, authInfo, err = config.Credentials.ServerHandshake(rawConn)
+		if err != nil {
+			// ErrConnDispatched means that the connection was dispatched away
+			// from gRPC; those connections should be left open. io.EOF means
+			// the connection was closed before handshaking completed, which can
+			// happen naturally from probers. Return these errors directly.
+			if err == credentials.ErrConnDispatched || err == io.EOF {
+				return nil, err
+			}
+			return nil, connectionErrorf(false, err, "ServerHandshake(%q) failed: %v", rawConn.RemoteAddr(), err)
+		}
+	}
 	writeBufSize := config.WriteBufferSize
 	readBufSize := config.ReadBufferSize
 	maxHeaderListSize := defaultServerMaxHeaderListSize
@@ -215,14 +231,15 @@ func NewServerTransport(conn net.Conn, config *ServerConfig) (_ ServerTransport,
 	if kep.MinTime == 0 {
 		kep.MinTime = defaultKeepalivePolicyMinTime
 	}
+
 	done := make(chan struct{})
 	t := &http2Server{
-		ctx:               context.Background(),
+		ctx:               setConnection(context.Background(), rawConn),
 		done:              done,
 		conn:              conn,
 		remoteAddr:        conn.RemoteAddr(),
 		localAddr:         conn.LocalAddr(),
-		authInfo:          config.AuthInfo,
+		authInfo:          authInfo,
 		framer:            framer,
 		readerDone:        make(chan struct{}),
 		writerDone:        make(chan struct{}),
@@ -1345,3 +1362,18 @@ func getJitter(v time.Duration) time.Duration {
 	j := grpcrand.Int63n(2*r) - r
 	return time.Duration(j)
 }
+
+type connectionKey struct{}
+
+// GetConnection gets the connection from the context.
+func GetConnection(ctx context.Context) net.Conn {
+	conn, _ := ctx.Value(connectionKey{}).(net.Conn)
+	return conn
+}
+
+// SetConnection adds the connection to the context to be able to get
+// information about the destination ip and port for an incoming RPC. This also
+// allows any unary or streaming interceptors to see the connection.
+func setConnection(ctx context.Context, conn net.Conn) context.Context {
+	return context.WithValue(ctx, connectionKey{}, conn)
+}
diff --git a/vendor/google.golang.org/grpc/internal/transport/transport.go b/vendor/google.golang.org/grpc/internal/transport/transport.go
index 1419812645..d3bf65b2bd 100644
--- a/vendor/google.golang.org/grpc/internal/transport/transport.go
+++ b/vendor/google.golang.org/grpc/internal/transport/transport.go
@@ -30,6 +30,7 @@ import (
 	"net"
 	"sync"
 	"sync/atomic"
+	"time"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
@@ -518,7 +519,8 @@ const (
 // ServerConfig consists of all the configurations to establish a server transport.
 type ServerConfig struct {
 	MaxStreams            uint32
-	AuthInfo              credentials.AuthInfo
+	ConnectionTimeout     time.Duration
+	Credentials           credentials.TransportCredentials
 	InTapHandle           tap.ServerInHandle
 	StatsHandler          stats.Handler
 	KeepaliveParams       keepalive.ServerParameters
diff --git a/vendor/google.golang.org/grpc/internal/xds/env/env.go b/vendor/google.golang.org/grpc/internal/xds/env/env.go
new file mode 100644
index 0000000000..b171ac91f1
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/xds/env/env.go
@@ -0,0 +1,95 @@
+/*
+ *
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package env acts a single source of definition for all environment variables
+// related to the xDS implementation in gRPC.
+package env
+
+import (
+	"os"
+	"strings"
+)
+
+const (
+	// BootstrapFileNameEnv is the env variable to set bootstrap file name.
+	// Do not use this and read from env directly. Its value is read and kept in
+	// variable BootstrapFileName.
+	//
+	// When both bootstrap FileName and FileContent are set, FileName is used.
+	BootstrapFileNameEnv = "GRPC_XDS_BOOTSTRAP"
+	// BootstrapFileContentEnv is the env variable to set bootstrapp file
+	// content. Do not use this and read from env directly. Its value is read
+	// and kept in variable BootstrapFileName.
+	//
+	// When both bootstrap FileName and FileContent are set, FileName is used.
+	BootstrapFileContentEnv = "GRPC_XDS_BOOTSTRAP_CONFIG"
+
+	ringHashSupportEnv           = "GRPC_XDS_EXPERIMENTAL_ENABLE_RING_HASH"
+	clientSideSecuritySupportEnv = "GRPC_XDS_EXPERIMENTAL_SECURITY_SUPPORT"
+	aggregateAndDNSSupportEnv    = "GRPC_XDS_EXPERIMENTAL_ENABLE_AGGREGATE_AND_LOGICAL_DNS_CLUSTER"
+	retrySupportEnv              = "GRPC_XDS_EXPERIMENTAL_ENABLE_RETRY"
+	rbacSupportEnv               = "GRPC_XDS_EXPERIMENTAL_ENABLE_RBAC"
+
+	c2pResolverSupportEnv                    = "GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER"
+	c2pResolverTestOnlyTrafficDirectorURIEnv = "GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI"
+)
+
+var (
+	// BootstrapFileName holds the name of the file which contains xDS bootstrap
+	// configuration. Users can specify the location of the bootstrap file by
+	// setting the environment variable "GRPC_XDS_BOOTSTRAP".
+	//
+	// When both bootstrap FileName and FileContent are set, FileName is used.
+	BootstrapFileName = os.Getenv(BootstrapFileNameEnv)
+	// BootstrapFileContent holds the content of the xDS bootstrap
+	// configuration. Users can specify the bootstrap config by
+	// setting the environment variable "GRPC_XDS_BOOTSTRAP_CONFIG".
+	//
+	// When both bootstrap FileName and FileContent are set, FileName is used.
+	BootstrapFileContent = os.Getenv(BootstrapFileContentEnv)
+	// RingHashSupport indicates whether ring hash support is enabled, which can
+	// be disabled by setting the environment variable
+	// "GRPC_XDS_EXPERIMENTAL_ENABLE_RING_HASH" to "false".
+	RingHashSupport = !strings.EqualFold(os.Getenv(ringHashSupportEnv), "false")
+	// ClientSideSecuritySupport is used to control processing of security
+	// configuration on the client-side.
+	//
+	// Note that there is no env var protection for the server-side because we
+	// have a brand new API on the server-side and users explicitly need to use
+	// the new API to get security integration on the server.
+	ClientSideSecuritySupport = !strings.EqualFold(os.Getenv(clientSideSecuritySupportEnv), "false")
+	// AggregateAndDNSSupportEnv indicates whether processing of aggregated
+	// cluster and DNS cluster is enabled, which can be enabled by setting the
+	// environment variable
+	// "GRPC_XDS_EXPERIMENTAL_ENABLE_AGGREGATE_AND_LOGICAL_DNS_CLUSTER" to
+	// "true".
+	AggregateAndDNSSupportEnv = strings.EqualFold(os.Getenv(aggregateAndDNSSupportEnv), "true")
+
+	// RetrySupport indicates whether xDS retry is enabled.
+	RetrySupport = !strings.EqualFold(os.Getenv(retrySupportEnv), "false")
+
+	// RBACSupport indicates whether xDS configured RBAC HTTP Filter is enabled.
+	RBACSupport = strings.EqualFold(os.Getenv(rbacSupportEnv), "true")
+
+	// C2PResolverSupport indicates whether support for C2P resolver is enabled.
+	// This can be enabled by setting the environment variable
+	// "GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER" to "true".
+	C2PResolverSupport = strings.EqualFold(os.Getenv(c2pResolverSupportEnv), "true")
+	// C2PResolverTestOnlyTrafficDirectorURI is the TD URI for testing.
+	C2PResolverTestOnlyTrafficDirectorURI = os.Getenv(c2pResolverTestOnlyTrafficDirectorURIEnv)
+)
diff --git a/vendor/google.golang.org/grpc/pickfirst.go b/vendor/google.golang.org/grpc/pickfirst.go
index b858c2a5e6..f194d14a08 100644
--- a/vendor/google.golang.org/grpc/pickfirst.go
+++ b/vendor/google.golang.org/grpc/pickfirst.go
@@ -107,10 +107,12 @@ func (b *pickfirstBalancer) UpdateSubConnState(sc balancer.SubConn, s balancer.S
 	}
 
 	switch s.ConnectivityState {
-	case connectivity.Ready, connectivity.Idle:
+	case connectivity.Ready:
 		b.cc.UpdateState(balancer.State{ConnectivityState: s.ConnectivityState, Picker: &picker{result: balancer.PickResult{SubConn: sc}}})
 	case connectivity.Connecting:
 		b.cc.UpdateState(balancer.State{ConnectivityState: s.ConnectivityState, Picker: &picker{err: balancer.ErrNoSubConnAvailable}})
+	case connectivity.Idle:
+		b.cc.UpdateState(balancer.State{ConnectivityState: s.ConnectivityState, Picker: &idlePicker{sc: sc}})
 	case connectivity.TransientFailure:
 		b.cc.UpdateState(balancer.State{
 			ConnectivityState: s.ConnectivityState,
@@ -122,6 +124,12 @@ func (b *pickfirstBalancer) UpdateSubConnState(sc balancer.SubConn, s balancer.S
 func (b *pickfirstBalancer) Close() {
 }
 
+func (b *pickfirstBalancer) ExitIdle() {
+	if b.state == connectivity.Idle {
+		b.sc.Connect()
+	}
+}
+
 type picker struct {
 	result balancer.PickResult
 	err    error
@@ -131,6 +139,17 @@ func (p *picker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
 	return p.result, p.err
 }
 
+// idlePicker is used when the SubConn is IDLE and kicks the SubConn into
+// CONNECTING when Pick is called.
+type idlePicker struct {
+	sc balancer.SubConn
+}
+
+func (i *idlePicker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
+	i.sc.Connect()
+	return balancer.PickResult{}, balancer.ErrNoSubConnAvailable
+}
+
 func init() {
 	balancer.Register(newPickfirstBuilder())
 }
diff --git a/vendor/google.golang.org/grpc/server.go b/vendor/google.golang.org/grpc/server.go
index 0251f48daf..557f29559d 100644
--- a/vendor/google.golang.org/grpc/server.go
+++ b/vendor/google.golang.org/grpc/server.go
@@ -710,13 +710,6 @@ func (s *Server) GetServiceInfo() map[string]ServiceInfo {
 // the server being stopped.
 var ErrServerStopped = errors.New("grpc: the server has been stopped")
 
-func (s *Server) useTransportAuthenticator(rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) {
-	if s.opts.creds == nil {
-		return rawConn, nil, nil
-	}
-	return s.opts.creds.ServerHandshake(rawConn)
-}
-
 type listenSocket struct {
 	net.Listener
 	channelzID int64
@@ -839,35 +832,14 @@ func (s *Server) handleRawConn(lisAddr string, rawConn net.Conn) {
 		return
 	}
 	rawConn.SetDeadline(time.Now().Add(s.opts.connectionTimeout))
-	conn, authInfo, err := s.useTransportAuthenticator(rawConn)
-	if err != nil {
-		// ErrConnDispatched means that the connection was dispatched away from
-		// gRPC; those connections should be left open.
-		if err != credentials.ErrConnDispatched {
-			// In deployments where a gRPC server runs behind a cloud load
-			// balancer which performs regular TCP level health checks, the
-			// connection is closed immediately by the latter. Skipping the
-			// error here will help reduce log clutter.
-			if err != io.EOF {
-				s.mu.Lock()
-				s.errorf("ServerHandshake(%q) failed: %v", rawConn.RemoteAddr(), err)
-				s.mu.Unlock()
-				channelz.Warningf(logger, s.channelzID, "grpc: Server.Serve failed to complete security handshake from %q: %v", rawConn.RemoteAddr(), err)
-			}
-			rawConn.Close()
-		}
-		rawConn.SetDeadline(time.Time{})
-		return
-	}
 
 	// Finish handshaking (HTTP2)
-	st := s.newHTTP2Transport(conn, authInfo)
+	st := s.newHTTP2Transport(rawConn)
+	rawConn.SetDeadline(time.Time{})
 	if st == nil {
-		conn.Close()
 		return
 	}
 
-	rawConn.SetDeadline(time.Time{})
 	if !s.addConn(lisAddr, st) {
 		return
 	}
@@ -888,10 +860,11 @@ func (s *Server) drainServerTransports(addr string) {
 
 // newHTTP2Transport sets up a http/2 transport (using the
 // gRPC http2 server transport in transport/http2_server.go).
-func (s *Server) newHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) transport.ServerTransport {
+func (s *Server) newHTTP2Transport(c net.Conn) transport.ServerTransport {
 	config := &transport.ServerConfig{
 		MaxStreams:            s.opts.maxConcurrentStreams,
-		AuthInfo:              authInfo,
+		ConnectionTimeout:     s.opts.connectionTimeout,
+		Credentials:           s.opts.creds,
 		InTapHandle:           s.opts.inTapHandle,
 		StatsHandler:          s.opts.statsHandler,
 		KeepaliveParams:       s.opts.keepaliveParams,
@@ -909,8 +882,17 @@ func (s *Server) newHTTP2Transport(c net.Conn, authInfo credentials.AuthInfo) tr
 		s.mu.Lock()
 		s.errorf("NewServerTransport(%q) failed: %v", c.RemoteAddr(), err)
 		s.mu.Unlock()
-		c.Close()
-		channelz.Warning(logger, s.channelzID, "grpc: Server.Serve failed to create ServerTransport: ", err)
+		// ErrConnDispatched means that the connection was dispatched away from
+		// gRPC; those connections should be left open.
+		if err != credentials.ErrConnDispatched {
+			c.Close()
+		}
+		// Don't log on ErrConnDispatched and io.EOF to prevent log spam.
+		if err != credentials.ErrConnDispatched {
+			if err != io.EOF {
+				channelz.Warning(logger, s.channelzID, "grpc: Server.Serve failed to create ServerTransport: ", err)
+			}
+		}
 		return nil
 	}
 
diff --git a/vendor/google.golang.org/grpc/stats/stats.go b/vendor/google.golang.org/grpc/stats/stats.go
index a5ebeeb693..0285dcc6a2 100644
--- a/vendor/google.golang.org/grpc/stats/stats.go
+++ b/vendor/google.golang.org/grpc/stats/stats.go
@@ -36,12 +36,12 @@ type RPCStats interface {
 	IsClient() bool
 }
 
-// Begin contains stats when an RPC begins.
+// Begin contains stats when an RPC attempt begins.
 // FailFast is only valid if this Begin is from client side.
 type Begin struct {
 	// Client is true if this Begin is from client side.
 	Client bool
-	// BeginTime is the time when the RPC begins.
+	// BeginTime is the time when the RPC attempt begins.
 	BeginTime time.Time
 	// FailFast indicates if this RPC is failfast.
 	FailFast bool
@@ -49,6 +49,9 @@ type Begin struct {
 	IsClientStream bool
 	// IsServerStream indicates whether the RPC is a server streaming RPC.
 	IsServerStream bool
+	// IsTransparentRetryAttempt indicates whether this attempt was initiated
+	// due to transparently retrying a previous attempt.
+	IsTransparentRetryAttempt bool
 }
 
 // IsClient indicates if the stats information is from client side.
diff --git a/vendor/google.golang.org/grpc/stream.go b/vendor/google.golang.org/grpc/stream.go
index e224af12d2..625d47b34e 100644
--- a/vendor/google.golang.org/grpc/stream.go
+++ b/vendor/google.golang.org/grpc/stream.go
@@ -274,35 +274,6 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 	if c.creds != nil {
 		callHdr.Creds = c.creds
 	}
-	var trInfo *traceInfo
-	if EnableTracing {
-		trInfo = &traceInfo{
-			tr: trace.New("grpc.Sent."+methodFamily(method), method),
-			firstLine: firstLine{
-				client: true,
-			},
-		}
-		if deadline, ok := ctx.Deadline(); ok {
-			trInfo.firstLine.deadline = time.Until(deadline)
-		}
-		trInfo.tr.LazyLog(&trInfo.firstLine, false)
-		ctx = trace.NewContext(ctx, trInfo.tr)
-	}
-	ctx = newContextWithRPCInfo(ctx, c.failFast, c.codec, cp, comp)
-	sh := cc.dopts.copts.StatsHandler
-	var beginTime time.Time
-	if sh != nil {
-		ctx = sh.TagRPC(ctx, &stats.RPCTagInfo{FullMethodName: method, FailFast: c.failFast})
-		beginTime = time.Now()
-		begin := &stats.Begin{
-			Client:         true,
-			BeginTime:      beginTime,
-			FailFast:       c.failFast,
-			IsClientStream: desc.ClientStreams,
-			IsServerStream: desc.ServerStreams,
-		}
-		sh.HandleRPC(ctx, begin)
-	}
 
 	cs := &clientStream{
 		callHdr:      callHdr,
@@ -316,7 +287,6 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 		cp:           cp,
 		comp:         comp,
 		cancel:       cancel,
-		beginTime:    beginTime,
 		firstAttempt: true,
 		onCommit:     onCommit,
 	}
@@ -325,9 +295,7 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 	}
 	cs.binlog = binarylog.GetMethodLogger(method)
 
-	// Only this initial attempt has stats/tracing.
-	// TODO(dfawley): move to newAttempt when per-attempt stats are implemented.
-	if err := cs.newAttemptLocked(sh, trInfo); err != nil {
+	if err := cs.newAttemptLocked(false /* isTransparent */); err != nil {
 		cs.finish(err)
 		return nil, err
 	}
@@ -375,8 +343,43 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 
 // newAttemptLocked creates a new attempt with a transport.
 // If it succeeds, then it replaces clientStream's attempt with this new attempt.
-func (cs *clientStream) newAttemptLocked(sh stats.Handler, trInfo *traceInfo) (retErr error) {
+func (cs *clientStream) newAttemptLocked(isTransparent bool) (retErr error) {
+	ctx := newContextWithRPCInfo(cs.ctx, cs.callInfo.failFast, cs.callInfo.codec, cs.cp, cs.comp)
+	method := cs.callHdr.Method
+	sh := cs.cc.dopts.copts.StatsHandler
+	var beginTime time.Time
+	if sh != nil {
+		ctx = sh.TagRPC(ctx, &stats.RPCTagInfo{FullMethodName: method, FailFast: cs.callInfo.failFast})
+		beginTime = time.Now()
+		begin := &stats.Begin{
+			Client:                    true,
+			BeginTime:                 beginTime,
+			FailFast:                  cs.callInfo.failFast,
+			IsClientStream:            cs.desc.ClientStreams,
+			IsServerStream:            cs.desc.ServerStreams,
+			IsTransparentRetryAttempt: isTransparent,
+		}
+		sh.HandleRPC(ctx, begin)
+	}
+
+	var trInfo *traceInfo
+	if EnableTracing {
+		trInfo = &traceInfo{
+			tr: trace.New("grpc.Sent."+methodFamily(method), method),
+			firstLine: firstLine{
+				client: true,
+			},
+		}
+		if deadline, ok := ctx.Deadline(); ok {
+			trInfo.firstLine.deadline = time.Until(deadline)
+		}
+		trInfo.tr.LazyLog(&trInfo.firstLine, false)
+		ctx = trace.NewContext(ctx, trInfo.tr)
+	}
+
 	newAttempt := &csAttempt{
+		ctx:          ctx,
+		beginTime:    beginTime,
 		cs:           cs,
 		dc:           cs.cc.dopts.dc,
 		statsHandler: sh,
@@ -391,15 +394,14 @@ func (cs *clientStream) newAttemptLocked(sh stats.Handler, trInfo *traceInfo) (r
 		}
 	}()
 
-	if err := cs.ctx.Err(); err != nil {
+	if err := ctx.Err(); err != nil {
 		return toRPCErr(err)
 	}
 
-	ctx := cs.ctx
 	if cs.cc.parsedTarget.Scheme == "xds" {
 		// Add extra metadata (metadata that will be added by transport) to context
 		// so the balancer can see them.
-		ctx = grpcutil.WithExtraMetadata(cs.ctx, metadata.Pairs(
+		ctx = grpcutil.WithExtraMetadata(ctx, metadata.Pairs(
 			"content-type", grpcutil.ContentType(cs.callHdr.ContentSubtype),
 		))
 	}
@@ -419,7 +421,7 @@ func (cs *clientStream) newAttemptLocked(sh stats.Handler, trInfo *traceInfo) (r
 func (a *csAttempt) newStream() error {
 	cs := a.cs
 	cs.callHdr.PreviousAttempts = cs.numRetries
-	s, err := a.t.NewStream(cs.ctx, cs.callHdr)
+	s, err := a.t.NewStream(a.ctx, cs.callHdr)
 	if err != nil {
 		// Return without converting to an RPC error so retry code can
 		// inspect.
@@ -444,8 +446,7 @@ type clientStream struct {
 
 	cancel context.CancelFunc // cancels all attempts
 
-	sentLast  bool // sent an end stream
-	beginTime time.Time
+	sentLast bool // sent an end stream
 
 	methodConfig *MethodConfig
 
@@ -485,6 +486,7 @@ type clientStream struct {
 // csAttempt implements a single transport stream attempt within a
 // clientStream.
 type csAttempt struct {
+	ctx  context.Context
 	cs   *clientStream
 	t    transport.ClientTransport
 	s    *transport.Stream
@@ -503,6 +505,7 @@ type csAttempt struct {
 	trInfo *traceInfo
 
 	statsHandler stats.Handler
+	beginTime    time.Time
 }
 
 func (cs *clientStream) commitAttemptLocked() {
@@ -520,15 +523,16 @@ func (cs *clientStream) commitAttempt() {
 }
 
 // shouldRetry returns nil if the RPC should be retried; otherwise it returns
-// the error that should be returned by the operation.
-func (cs *clientStream) shouldRetry(err error) error {
+// the error that should be returned by the operation.  If the RPC should be
+// retried, the bool indicates whether it is being retried transparently.
+func (cs *clientStream) shouldRetry(err error) (bool, error) {
 	if cs.attempt.s == nil {
 		// Error from NewClientStream.
 		nse, ok := err.(*transport.NewStreamError)
 		if !ok {
 			// Unexpected, but assume no I/O was performed and the RPC is not
 			// fatal, so retry indefinitely.
-			return nil
+			return true, nil
 		}
 
 		// Unwrap and convert error.
@@ -537,19 +541,19 @@ func (cs *clientStream) shouldRetry(err error) error {
 		// Never retry DoNotRetry errors, which indicate the RPC should not be
 		// retried due to max header list size violation, etc.
 		if nse.DoNotRetry {
-			return err
+			return false, err
 		}
 
 		// In the event of a non-IO operation error from NewStream, we never
 		// attempted to write anything to the wire, so we can retry
 		// indefinitely.
-		if !nse.PerformedIO {
-			return nil
+		if !nse.DoNotTransparentRetry {
+			return true, nil
 		}
 	}
 	if cs.finished || cs.committed {
 		// RPC is finished or committed; cannot retry.
-		return err
+		return false, err
 	}
 	// Wait for the trailers.
 	unprocessed := false
@@ -559,17 +563,17 @@ func (cs *clientStream) shouldRetry(err error) error {
 	}
 	if cs.firstAttempt && unprocessed {
 		// First attempt, stream unprocessed: transparently retry.
-		return nil
+		return true, nil
 	}
 	if cs.cc.dopts.disableRetry {
-		return err
+		return false, err
 	}
 
 	pushback := 0
 	hasPushback := false
 	if cs.attempt.s != nil {
 		if !cs.attempt.s.TrailersOnly() {
-			return err
+			return false, err
 		}
 
 		// TODO(retry): Move down if the spec changes to not check server pushback
@@ -580,13 +584,13 @@ func (cs *clientStream) shouldRetry(err error) error {
 			if pushback, e = strconv.Atoi(sps[0]); e != nil || pushback < 0 {
 				channelz.Infof(logger, cs.cc.channelzID, "Server retry pushback specified to abort (%q).", sps[0])
 				cs.retryThrottler.throttle() // This counts as a failure for throttling.
-				return err
+				return false, err
 			}
 			hasPushback = true
 		} else if len(sps) > 1 {
 			channelz.Warningf(logger, cs.cc.channelzID, "Server retry pushback specified multiple values (%q); not retrying.", sps)
 			cs.retryThrottler.throttle() // This counts as a failure for throttling.
-			return err
+			return false, err
 		}
 	}
 
@@ -599,16 +603,16 @@ func (cs *clientStream) shouldRetry(err error) error {
 
 	rp := cs.methodConfig.RetryPolicy
 	if rp == nil || !rp.RetryableStatusCodes[code] {
-		return err
+		return false, err
 	}
 
 	// Note: the ordering here is important; we count this as a failure
 	// only if the code matched a retryable code.
 	if cs.retryThrottler.throttle() {
-		return err
+		return false, err
 	}
 	if cs.numRetries+1 >= rp.MaxAttempts {
-		return err
+		return false, err
 	}
 
 	var dur time.Duration
@@ -631,10 +635,10 @@ func (cs *clientStream) shouldRetry(err error) error {
 	select {
 	case <-t.C:
 		cs.numRetries++
-		return nil
+		return false, nil
 	case <-cs.ctx.Done():
 		t.Stop()
-		return status.FromContextError(cs.ctx.Err()).Err()
+		return false, status.FromContextError(cs.ctx.Err()).Err()
 	}
 }
 
@@ -642,12 +646,13 @@ func (cs *clientStream) shouldRetry(err error) error {
 func (cs *clientStream) retryLocked(lastErr error) error {
 	for {
 		cs.attempt.finish(toRPCErr(lastErr))
-		if err := cs.shouldRetry(lastErr); err != nil {
+		isTransparent, err := cs.shouldRetry(lastErr)
+		if err != nil {
 			cs.commitAttemptLocked()
 			return err
 		}
 		cs.firstAttempt = false
-		if err := cs.newAttemptLocked(nil, nil); err != nil {
+		if err := cs.newAttemptLocked(isTransparent); err != nil {
 			return err
 		}
 		if lastErr = cs.replayBufferLocked(); lastErr == nil {
@@ -937,7 +942,7 @@ func (a *csAttempt) sendMsg(m interface{}, hdr, payld, data []byte) error {
 		return io.EOF
 	}
 	if a.statsHandler != nil {
-		a.statsHandler.HandleRPC(cs.ctx, outPayload(true, m, data, payld, time.Now()))
+		a.statsHandler.HandleRPC(a.ctx, outPayload(true, m, data, payld, time.Now()))
 	}
 	if channelz.IsOn() {
 		a.t.IncrMsgSent()
@@ -985,7 +990,7 @@ func (a *csAttempt) recvMsg(m interface{}, payInfo *payloadInfo) (err error) {
 		a.mu.Unlock()
 	}
 	if a.statsHandler != nil {
-		a.statsHandler.HandleRPC(cs.ctx, &stats.InPayload{
+		a.statsHandler.HandleRPC(a.ctx, &stats.InPayload{
 			Client:   true,
 			RecvTime: time.Now(),
 			Payload:  m,
@@ -1047,12 +1052,12 @@ func (a *csAttempt) finish(err error) {
 	if a.statsHandler != nil {
 		end := &stats.End{
 			Client:    true,
-			BeginTime: a.cs.beginTime,
+			BeginTime: a.beginTime,
 			EndTime:   time.Now(),
 			Trailer:   tr,
 			Error:     err,
 		}
-		a.statsHandler.HandleRPC(a.cs.ctx, end)
+		a.statsHandler.HandleRPC(a.ctx, end)
 	}
 	if a.trInfo != nil && a.trInfo.tr != nil {
 		if err == nil {
diff --git a/vendor/google.golang.org/grpc/version.go b/vendor/google.golang.org/grpc/version.go
index e3510e10f1..48594bc246 100644
--- a/vendor/google.golang.org/grpc/version.go
+++ b/vendor/google.golang.org/grpc/version.go
@@ -19,4 +19,4 @@
 package grpc
 
 // Version is the current grpc version.
-const Version = "1.40.0"
+const Version = "1.41.0"
diff --git a/vendor/google.golang.org/grpc/vet.sh b/vendor/google.golang.org/grpc/vet.sh
index 5eaa8b05d6..d923187a7b 100644
--- a/vendor/google.golang.org/grpc/vet.sh
+++ b/vendor/google.golang.org/grpc/vet.sh
@@ -89,10 +89,6 @@ not git grep "\(import \|^\s*\)\"github.com/golang/protobuf/ptypes/" -- "*.go"
 # - Ensure all xds proto imports are renamed to *pb or *grpc.
 git grep '"github.com/envoyproxy/go-control-plane/envoy' -- '*.go' ':(exclude)*.pb.go' | not grep -v 'pb "\|grpc "'
 
-# - Check imports that are illegal in appengine (until Go 1.11).
-# TODO: Remove when we drop Go 1.10 support
-go list -f {{.Dir}} ./... | xargs go run test/go_vet/vet.go
-
 misspell -error .
 
 # - Check that generated proto files are up to date.
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 55a56718ac..a13800615a 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -400,7 +400,7 @@ github.com/mattn/go-colorable
 github.com/mattn/go-isatty
 # github.com/mattn/go-runewidth v0.0.9
 github.com/mattn/go-runewidth
-# github.com/mattn/go-sqlite3 v1.14.6
+# github.com/mattn/go-sqlite3 v1.14.10
 github.com/mattn/go-sqlite3
 # github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369
 github.com/matttproud/golang_protobuf_extensions/pbutil
@@ -959,7 +959,7 @@ google.golang.org/genproto/googleapis/api/expr/v1alpha1
 google.golang.org/genproto/googleapis/api/httpbody
 google.golang.org/genproto/googleapis/rpc/status
 google.golang.org/genproto/protobuf/field_mask
-# google.golang.org/grpc v1.40.0
+# google.golang.org/grpc v1.41.0
 google.golang.org/grpc
 google.golang.org/grpc/attributes
 google.golang.org/grpc/backoff
@@ -998,6 +998,7 @@ google.golang.org/grpc/internal/status
 google.golang.org/grpc/internal/syscall
 google.golang.org/grpc/internal/transport
 google.golang.org/grpc/internal/transport/networktype
+google.golang.org/grpc/internal/xds/env
 google.golang.org/grpc/keepalive
 google.golang.org/grpc/metadata
 google.golang.org/grpc/peer