diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index f6f5cba40..4cddab1e3 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -81,10 +81,6 @@ jobs:
       - name: Test
         run: make test
         timeout-minutes: 20
-  #      - uses: "./.github/shared/install_sqlite"
-  #      - name: Test with index enabled
-  #        run: SQLITE_EXEC="scripts/limbo-sqlite3-index-experimental" make test
-  #        timeout-minutes: 20
   test-sqlite:
     runs-on: blacksmith-4vcpu-ubuntu-2404
     steps:
diff --git a/bindings/python/src/lib.rs b/bindings/python/src/lib.rs
index 419e9481a..cac0a7280 100644
--- a/bindings/python/src/lib.rs
+++ b/bindings/python/src/lib.rs
@@ -317,7 +317,7 @@ impl Drop for Connection {
 #[allow(clippy::arc_with_non_send_sync)]
 #[pyfunction(signature = (path, experimental_indexes=None))]
 pub fn connect(path: &str, experimental_indexes: Option<bool>) -> Result<Connection> {
-    let experimental_indexes = experimental_indexes.unwrap_or(false);
+    let experimental_indexes = experimental_indexes.unwrap_or(true);
     match turso_core::Connection::from_uri(path, experimental_indexes, false) {
         Ok((io, conn)) => Ok(Connection { conn, _io: io }),
         Err(e) => Err(PyErr::new::<ProgrammingError, _>(format!(
diff --git a/bindings/rust/Cargo.toml b/bindings/rust/Cargo.toml
index a1cdf873b..f1d98b403 100644
--- a/bindings/rust/Cargo.toml
+++ b/bindings/rust/Cargo.toml
@@ -10,7 +10,7 @@ repository.workspace = true
 description = "Turso Rust API"
 
 [features]
-default = []
+default = ["experimental_indexes"]
 experimental_indexes = []
 antithesis = ["turso_core/antithesis"]
 
diff --git a/cli/app.rs b/cli/app.rs
index 2b422af86..d624ce3a7 100644
--- a/cli/app.rs
+++ b/cli/app.rs
@@ -61,7 +61,7 @@ pub struct Opts {
     #[clap(long, help = "Enable experimental MVCC feature")]
     pub experimental_mvcc: bool,
     #[clap(long, help = "Enable experimental indexing feature")]
-    pub experimental_indexes: bool,
+    pub experimental_indexes: Option<bool>,
     #[clap(short = 't', long, help = "specify output file for log traces")]
     pub tracing_output: Option<String>,
     #[clap(long, help = "Start MCP server instead of interactive shell")]
@@ -119,8 +119,9 @@ impl Limbo {
             .database
             .as_ref()
             .map_or(":memory:".to_string(), |p| p.to_string_lossy().to_string());
+        let indexes_enabled = opts.experimental_indexes.unwrap_or(true);
         let (io, conn) = if db_file.contains([':', '?', '&', '#']) {
-            Connection::from_uri(&db_file, opts.experimental_indexes, opts.experimental_mvcc)?
+            Connection::from_uri(&db_file, indexes_enabled, opts.experimental_mvcc)?
         } else {
             let flags = if opts.readonly {
                 OpenFlags::ReadOnly
@@ -131,7 +132,7 @@ impl Limbo {
                 &db_file,
                 opts.vfs.as_ref(),
                 flags,
-                opts.experimental_indexes,
+                indexes_enabled,
                 opts.experimental_mvcc,
             )?;
             let conn = db.connect()?;
diff --git a/core/translate/alter.rs b/core/translate/alter.rs
index 48a61d698..9fad5b8bb 100644
--- a/core/translate/alter.rs
+++ b/core/translate/alter.rs
@@ -30,7 +30,7 @@ pub fn translate_alter_table(
         // Let's disable altering a table with indices altogether instead of checking column by
         // column to be extra safe.
         crate::bail_parse_error!(
-            "ALTER TABLE for table with indexes is disabled by default. Run with `--experimental-indexes` to enable this feature."
+            "ALTER TABLE for table with indexes is disabled. Omit the `--experimental-indexes=false` flag to enable this feature."
         );
     }
 
diff --git a/core/translate/delete.rs b/core/translate/delete.rs
index 02bb345b8..24490f455 100644
--- a/core/translate/delete.rs
+++ b/core/translate/delete.rs
@@ -25,7 +25,7 @@ pub fn translate_delete(
         // Let's disable altering a table with indices altogether instead of checking column by
         // column to be extra safe.
         crate::bail_parse_error!(
-            "DELETE for table with indexes is disabled by default. Run with `--experimental-indexes` to enable this feature."
+            "DELETE for table with indexes is disabled. Omit the `--experimental-indexes=false` flag to enable this feature."
         );
     }
 
diff --git a/core/translate/insert.rs b/core/translate/insert.rs
index acbf10649..6448d8d21 100644
--- a/core/translate/insert.rs
+++ b/core/translate/insert.rs
@@ -67,7 +67,7 @@ pub fn translate_insert(
         // Let's disable altering a table with indices altogether instead of checking column by
         // column to be extra safe.
         crate::bail_parse_error!(
-            "INSERT to table with indexes is disabled by default. Run with `--experimental-indexes` to enable this feature."
+            "INSERT to table with indexes is disabled. Omit the `--experimental-indexes=false` flag to enable this feature."
         );
     }
     let table_name = &tbl_name.name;
diff --git a/core/translate/schema.rs b/core/translate/schema.rs
index 9ee88125d..ef3739644 100644
--- a/core/translate/schema.rs
+++ b/core/translate/schema.rs
@@ -626,7 +626,7 @@ pub fn translate_drop_table(
 ) -> Result<ProgramBuilder> {
     if !schema.indexes_enabled() && schema.table_has_indexes(&tbl_name.name.to_string()) {
         bail_parse_error!(
-            "DROP TABLE with indexes on the table is disabled by default. Run with `--experimental-indexes` to enable this feature."
+            "DROP TABLE with indexes on the table is disabled by default. Omit the `--experimental-indexes=false` flag to enable this feature."
         );
     }
     let opts = ProgramBuilderOpts {
diff --git a/core/translate/update.rs b/core/translate/update.rs
index ed199f27b..285446160 100644
--- a/core/translate/update.rs
+++ b/core/translate/update.rs
@@ -110,7 +110,7 @@ pub fn prepare_update_plan(
         // Let's disable altering a table with indices altogether instead of checking column by
         // column to be extra safe.
         bail_parse_error!(
-            "UPDATE table disabled for table with indexes is disabled by default. Run with `--experimental-indexes` to enable this feature."
+            "UPDATE table disabled for table with indexes is disabled. Omit the `--experimental-indexes=false` flag to enable this feature."
         );
     }
     let table = match schema.get_table(table_name.as_str()) {
diff --git a/perf/clickbench/benchmark.sh b/perf/clickbench/benchmark.sh
index 32e3e29a2..189c84c57 100755
--- a/perf/clickbench/benchmark.sh
+++ b/perf/clickbench/benchmark.sh
@@ -23,7 +23,7 @@ rm "$CLICKBENCH_DIR/mydb"* || true
 
 # Create DB using tursodb
 echo "Creating DB..."
-"$RELEASE_BUILD_DIR/tursodb" --quiet --experimental-indexes "$CLICKBENCH_DIR/mydb" < "$CLICKBENCH_DIR/create.sql"
+"$RELEASE_BUILD_DIR/tursodb" --quiet "$CLICKBENCH_DIR/mydb" < "$CLICKBENCH_DIR/create.sql"
 
 # Download a subset of the clickbench dataset if it doesn't exist
 NUM_ROWS=1000000
diff --git a/perf/clickbench/run.sh b/perf/clickbench/run.sh
index 09e5396a9..329a4caac 100755
--- a/perf/clickbench/run.sh
+++ b/perf/clickbench/run.sh
@@ -37,7 +37,7 @@ grep -v '^--' "$CLICKBENCH_DIR/queries.sql" | while read -r query; do
     for _ in $(seq 1 $TRIES); do
         clear_caches
         echo "----tursodb----"
-        ((time "$RELEASE_BUILD_DIR/tursodb" --quiet --experimental-indexes -m list "$CLICKBENCH_DIR/mydb" <<< "${query}") 2>&1) | tee -a clickbench-tursodb.txt
+        ((time "$RELEASE_BUILD_DIR/tursodb" --quiet -m list "$CLICKBENCH_DIR/mydb" <<< "${query}") 2>&1) | tee -a clickbench-tursodb.txt
         clear_caches
         echo
         echo "----sqlite----"
diff --git a/perf/tpc-h/run.sh b/perf/tpc-h/run.sh
index b4b40ca10..7bea14c23 100755
--- a/perf/tpc-h/run.sh
+++ b/perf/tpc-h/run.sh
@@ -66,7 +66,7 @@ for query_file in $(ls "$QUERIES_DIR"/*.sql | sort -V); do
         # Clear caches before Limbo run
         clear_caches
         # Run Limbo
-        limbo_output=$( { time -p "$LIMBO_BIN" "$DB_FILE" --experimental-indexes --quiet --output-mode list "$(cat $query_file)" 2>&1; } 2>&1)
+        limbo_output=$( { time -p "$LIMBO_BIN" "$DB_FILE" --quiet --output-mode list "$(cat $query_file)" 2>&1; } 2>&1)
         limbo_non_time_lines=$(echo "$limbo_output" | grep -v -e "^real" -e "^user" -e "^sys")
         limbo_real_time=$(echo "$limbo_output" | grep "^real" | awk '{print $2}')
         echo "Running $query_name with SQLite3..." >&2
diff --git a/stress/Cargo.toml b/stress/Cargo.toml
index 76d81ad39..b667e773d 100644
--- a/stress/Cargo.toml
+++ b/stress/Cargo.toml
@@ -17,7 +17,7 @@ path = "main.rs"
 [features]
 default = ["experimental_indexes"]
 antithesis = ["turso/antithesis"]
-experimental_indexes = ["turso/experimental_indexes"]
+experimental_indexes = []
 
 [dependencies]
 anarchist-readable-name-generator-lib = "0.1.0"
diff --git a/testing/agg-functions.test b/testing/agg-functions.test
index e83849391..9becf56a4 100755
--- a/testing/agg-functions.test
+++ b/testing/agg-functions.test
@@ -141,8 +141,6 @@ do_execsql_test select-agg-json-array-object {
   SELECT json_group_array(json_object('name', name)) FROM products;
 } {[{"name":"hat"},{"name":"cap"},{"name":"shirt"},{"name":"sweater"},{"name":"sweatshirt"},{"name":"shorts"},{"name":"jeans"},{"name":"sneakers"},{"name":"boots"},{"name":"coat"},{"name":"accessories"}]}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test select-distinct-agg-functions {
-    SELECT sum(distinct age), count(distinct age), avg(distinct age) FROM users;
-    } {5050|100|50.5}
-}
+do_execsql_test select-distinct-agg-functions {
+SELECT sum(distinct age), count(distinct age), avg(distinct age) FROM users;
+} {5050|100|50.5}
\ No newline at end of file
diff --git a/testing/alter_table.test b/testing/alter_table.test
index 98676d558..24bf74fe8 100755
--- a/testing/alter_table.test
+++ b/testing/alter_table.test
@@ -9,16 +9,14 @@ do_execsql_test_on_specific_db {:memory:} alter-table-rename-table {
     SELECT name FROM sqlite_schema WHERE type = 'table';
 } { "t2" }
 
-if {[info exists ::env(SQLITE_EXEC)] && $::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental"} {
-    do_execsql_test_on_specific_db {:memory:} alter-table-rename-column {
-        CREATE TABLE t (a);
-        CREATE INDEX i ON t(a);
-        ALTER TABLE t RENAME a TO b;
-        SELECT sql FROM sqlite_schema;
-    } {
-        "CREATE TABLE t (b)"
-        "CREATE INDEX i ON t(b)"
-    }
+do_execsql_test_on_specific_db {:memory:} alter-table-rename-column {
+    CREATE TABLE t (a);
+    CREATE INDEX i ON t (a);
+    ALTER TABLE t RENAME a TO b;
+    SELECT sql FROM sqlite_schema;
+} {
+    "CREATE TABLE t (b)"
+    "CREATE INDEX i ON t (b)"
 }
 
 do_execsql_test_on_specific_db {:memory:} alter-table-add-column {
@@ -48,34 +46,32 @@ do_execsql_test_on_specific_db {:memory:} alter-table-add-column-typed {
   "1|0"
 }
 
-if {[info exists ::env(SQLITE_EXEC)] && $::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental"} {
-    do_execsql_test_on_specific_db {:memory:} alter-table-add-column-default {
-        CREATE TABLE test (a);
-        INSERT INTO test VALUES (1), (2), (3);
+do_execsql_test_on_specific_db {:memory:} alter-table-add-column-default {
+    CREATE TABLE test (a);
+    INSERT INTO test VALUES (1), (2), (3);
 
-        ALTER TABLE test ADD b DEFAULT 0.1;
-        ALTER TABLE test ADD c DEFAULT 'hello';
-        SELECT * FROM test;
+    ALTER TABLE test ADD b DEFAULT 0.1;
+    ALTER TABLE test ADD c DEFAULT 'hello';
+    SELECT * FROM test;
 
-        CREATE INDEX idx ON test (b);
-        SELECT b, c FROM test WHERE b = 0.1;
+    CREATE INDEX idx ON test (b);
+    SELECT b, c FROM test WHERE b = 0.1;
 
-        ALTER TABLE test DROP a;
-        SELECT * FROM test;
+    ALTER TABLE test DROP a;
+    SELECT * FROM test;
 
-    } {
-    "1|0.1|hello"
-    "2|0.1|hello"
-    "3|0.1|hello"
+} {
+"1|0.1|hello"
+"2|0.1|hello"
+"3|0.1|hello"
 
-    "0.1|hello"
-    "0.1|hello"
-    "0.1|hello"
+"0.1|hello"
+"0.1|hello"
+"0.1|hello"
 
-    "0.1|hello"
-    "0.1|hello"
-    "0.1|hello"
-    }
+"0.1|hello"
+"0.1|hello"
+"0.1|hello"
 }
 
 do_execsql_test_on_specific_db {:memory:} alter-table-drop-column {
diff --git a/testing/create_table.test b/testing/create_table.test
index 63a9dc2b2..0ffca2e7d 100755
--- a/testing/create_table.test
+++ b/testing/create_table.test
@@ -3,16 +3,14 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_in_memory_any_error create_table_one_unique_set {
-        CREATE TABLE t4 (a, unique(b));
-    }
-
-    do_execsql_test_on_specific_db {:memory:} create_table_same_uniques_and_primary_keys {
-        CREATE TABLE t2 (a,b, unique(a,b), primary key(a,b));
-    } {}
-
-    do_execsql_test_on_specific_db {:memory:} create_table_unique_contained_in_primary_keys {
-        CREATE TABLE t4 (a,b, primary key(a,b), unique(a));
-    } {}
+do_execsql_test_in_memory_any_error create_table_one_unique_set {
+    CREATE TABLE t4 (a, unique(b));
 }
+
+do_execsql_test_on_specific_db {:memory:} create_table_same_uniques_and_primary_keys {
+    CREATE TABLE t2 (a,b, unique(a,b), primary key(a,b));
+} {}
+
+do_execsql_test_on_specific_db {:memory:} create_table_unique_contained_in_primary_keys {
+    CREATE TABLE t4 (a,b, primary key(a,b), unique(a));
+} {}
\ No newline at end of file
diff --git a/testing/delete.test b/testing/delete.test
index 8237a2533..e134270c7 100755
--- a/testing/delete.test
+++ b/testing/delete.test
@@ -52,16 +52,14 @@ do_execsql_test_on_specific_db {:memory:} delete-reuse-1 {
 } {1 2 3}
 
 # Test delete works when there are indexes
-if {[info exists ::env(SQLITE_EXEC)] && $::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental"} {
-    do_execsql_test_on_specific_db {:memory:} delete-all-with-indexes-1 {
-        CREATE TABLE t (a PRIMARY KEY);
-        CREATE INDEX tasc ON t(a);
-        CREATE INDEX tdesc ON t(a DESC);
-        INSERT INTO t VALUES (randomblob(1000));
-        DELETE FROM t;
-        SELECT * FROM t;
-    } {}
-}
+do_execsql_test_on_specific_db {:memory:} delete-all-with-indexes-1 {
+    CREATE TABLE t (a PRIMARY KEY);
+    CREATE INDEX tasc ON t(a);
+    CREATE INDEX tdesc ON t(a DESC);
+    INSERT INTO t VALUES (randomblob(1000));
+    DELETE FROM t;
+    SELECT * FROM t;
+} {}
 
 do_execsql_test_on_specific_db {:memory:} delete_where_falsy {
     CREATE TABLE resourceful_schurz (diplomatic_kaplan BLOB);
diff --git a/testing/drop_index.test b/testing/drop_index.test
index 5582f55f8..4edbfc2bc 100755
--- a/testing/drop_index.test
+++ b/testing/drop_index.test
@@ -3,46 +3,44 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    # Basic DROP INDEX functionality
-    do_execsql_test_on_specific_db {:memory:} drop-index-basic-1 {
-        CREATE TABLE t1 (x INTEGER PRIMARY KEY);
-        CREATE INDEX t_idx on t1 (x);
-        INSERT INTO t1 VALUES (1);
-        INSERT INTO t1 VALUES (2);
-        DROP INDEX t_idx;
-        SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx';
-    } {0}
+# Basic DROP INDEX functionality
+do_execsql_test_on_specific_db {:memory:} drop-index-basic-1 {
+    CREATE TABLE t1 (x INTEGER PRIMARY KEY);
+    CREATE INDEX t_idx on t1 (x);
+    INSERT INTO t1 VALUES (1);
+    INSERT INTO t1 VALUES (2);
+    DROP INDEX t_idx;
+    SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx';
+} {0}
 
-    # Test DROP INDEX IF EXISTS on existing index
-    do_execsql_test_on_specific_db {:memory:} drop-index-if-exists-1 {
-        CREATE TABLE t2 (x INTEGER PRIMARY KEY);
-        CREATE INDEX t_idx2 on t2 (x);
-        DROP INDEX IF EXISTS t_idx2;
-        SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx2';
-    } {0}
+# Test DROP INDEX IF EXISTS on existing index
+do_execsql_test_on_specific_db {:memory:} drop-index-if-exists-1 {
+    CREATE TABLE t2 (x INTEGER PRIMARY KEY);
+    CREATE INDEX t_idx2 on t2 (x);
+    DROP INDEX IF EXISTS t_idx2;
+    SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx2';
+} {0}
 
-    # Test DROP INDEX IF EXISTS on non-existent index
-    do_execsql_test_on_specific_db {:memory:} drop-index-if-exists-2 {
-        DROP TABLE IF EXISTS nonexistent_index;
-        SELECT 'success';
-    } {success}
+# Test DROP INDEX IF EXISTS on non-existent index
+do_execsql_test_on_specific_db {:memory:} drop-index-if-exists-2 {
+    DROP TABLE IF EXISTS nonexistent_index;
+    SELECT 'success';
+} {success}
 
-    # Test dropping non-existant index produces an error
-    do_execsql_test_error_content drop-index-no-index {
-        DROP INDEX t_idx;
-    } {"No such index: t_idx"}
+# Test dropping non-existant index produces an error
+do_execsql_test_error_content drop-index-no-index {
+    DROP INDEX t_idx;
+} {"No such index: t_idx"}
 
 
-    # Test dropping index after multiple inserts and deletes
-    do_execsql_test_on_specific_db {:memory:} drop-index-after-ops-1 {
-        CREATE TABLE t6 (x INTEGER PRIMARY KEY);
-        CREATE INDEX t_idx6 on t6 (x);
-        INSERT INTO t6 VALUES (1);
-        INSERT INTO t6 VALUES (2);
-        DELETE FROM t6 WHERE x = 1;
-        INSERT INTO t6 VALUES (3);
-        DROP INDEX t_idx6;
-        SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx6';
-    } {0}
-}
+# Test dropping index after multiple inserts and deletes
+do_execsql_test_on_specific_db {:memory:} drop-index-after-ops-1 {
+    CREATE TABLE t6 (x INTEGER PRIMARY KEY);
+    CREATE INDEX t_idx6 on t6 (x);
+    INSERT INTO t6 VALUES (1);
+    INSERT INTO t6 VALUES (2);
+    DELETE FROM t6 WHERE x = 1;
+    INSERT INTO t6 VALUES (3);
+    DROP INDEX t_idx6;
+    SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='t_idx6';
+} {0}
diff --git a/testing/drop_table.test b/testing/drop_table.test
index 3e2b56f85..9365b70d4 100755
--- a/testing/drop_table.test
+++ b/testing/drop_table.test
@@ -25,26 +25,23 @@ do_execsql_test_on_specific_db {:memory:} drop-table-if-exists-2 {
     SELECT 'success';
 } {success}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    # Test dropping table with index
-    do_execsql_test_on_specific_db {:memory:} drop-table-with-index-1 {
-        CREATE TABLE t3 (x INTEGER PRIMARY KEY, y TEXT);
-        CREATE INDEX idx_t3_y ON t3(y);
-        INSERT INTO t3 VALUES(1, 'one');
-        DROP TABLE t3;
-        SELECT count(*) FROM sqlite_schema WHERE tbl_name='t3';
-    } {0}
-    # Test dropping table cleans up related schema entries
-    do_execsql_test_on_specific_db {:memory:} drop-table-schema-cleanup-1 {
-        CREATE TABLE t4 (x INTEGER PRIMARY KEY, y TEXT);
-        CREATE INDEX idx1_t4 ON t4(x);
-        CREATE INDEX idx2_t4 ON t4(y);
-        INSERT INTO t4 VALUES(1, 'one');
-        DROP TABLE t4;
-        SELECT count(*) FROM sqlite_schema WHERE tbl_name='t4';
-    } {0}
-}
-
+# Test dropping table with index
+do_execsql_test_on_specific_db {:memory:} drop-table-with-index-1 {
+    CREATE TABLE t3 (x INTEGER PRIMARY KEY, y TEXT);
+    CREATE INDEX idx_t3_y ON t3(y);
+    INSERT INTO t3 VALUES(1, 'one');
+    DROP TABLE t3;
+    SELECT count(*) FROM sqlite_schema WHERE tbl_name='t3';
+} {0}
+# Test dropping table cleans up related schema entries
+do_execsql_test_on_specific_db {:memory:} drop-table-schema-cleanup-1 {
+    CREATE TABLE t4 (x INTEGER PRIMARY KEY, y TEXT);
+    CREATE INDEX idx1_t4 ON t4(x);
+    CREATE INDEX idx2_t4 ON t4(y);
+    INSERT INTO t4 VALUES(1, 'one');
+    DROP TABLE t4;
+    SELECT count(*) FROM sqlite_schema WHERE tbl_name='t4';
+} {0}
 
 # Test dropping table after multiple inserts and deletes
 do_execsql_test_on_specific_db {:memory:} drop-table-after-ops-1 {
diff --git a/testing/groupby.test b/testing/groupby.test
index 3a2a05086..c159b9892 100755
--- a/testing/groupby.test
+++ b/testing/groupby.test
@@ -206,33 +206,29 @@ do_execsql_test group_by_no_sorting_required_and_const_agg_arg {
 } {CA,PW,ME,AS,LA,OH,AL,UT,WA,MO,WA,SC,AR,CO,OK,ME,FM,AR,CT,MT,TN,FL,MA,ND,LA,NE,KS,IN,RI,NH,IL,FM,WA,MH,RI,SC,AS,IL,VA,MI,ID,ME,WY,TN,IN,IN,UT,WA,AZ,VA,NM,IA,MP,WY,RI,OR,OR,FM,WA,DC,RI,GU,TX,HI,IL,TX,WY,OH,TX,CT,KY,NE,MH,AR,MN,IL,NH,HI,NV,UT,FL,MS,NM,NJ,CA,MS,GA,MT,GA,AL,IN,SC,PA,FL,CT,PA,GA,RI,HI,WV,VT,IA,PR,FM,MA,TX,MS,LA,MD,PA,TX,WY
 OR,SD,KS,MP,WA,VI,SC,SD,SD,MP,WA,MT,FM,IN,ME,OH,KY,RI,DC,MS,OK,VI,KY,MD,SC,OK,NY,WY,AK,MN,UT,NE,VA,MD,AZ,VI,SC,NV,IN,VA,HI,VI,MS,NE,WY,NY,GU,MT,AL,IA,VA,ND,MN,FM,IA,ID,IL,FL,PR,WA,AS,HI,NH,WI,FL,HI,AL,ID,DC,CT,IL,VT,AZ,VI,AK,PW,NC,SD,NV,WA,MO,MS,WY,VA,FM,MN,NH,MN,MT,TX,MS,FM,OH,GU,IN,WA,IA,PA,ID,MI,LA,GU,ND,AR,ND,WV,DC,NY,CO,CT,FM,CT,ND}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-  do_execsql_test_on_specific_db {:memory:} group_by_no_sorting_required_reordered_columns {
-    create table t0 (a INT, b INT, c INT);
-    create index a_b_idx on t0 (a, b);
-    insert into t0 values
-      (1,1,1),
-      (1,1,2),
-      (2,1,3),
-      (2,2,3),
-      (2,2,5);
+do_execsql_test_on_specific_db {:memory:} group_by_no_sorting_required_reordered_columns {
+  create table t0 (a INT, b INT, c INT);
+  create index a_b_idx on t0 (a, b);
+  insert into t0 values
+    (1,1,1),
+    (1,1,2),
+    (2,1,3),
+    (2,2,3),
+    (2,2,5);
 
-    select c, b, a from t0 group by a, b;
-  } {1|1|1
-  3|1|2
-  3|2|2}
-}
+  select c, b, a from t0 group by a, b;
+} {1|1|1
+3|1|2
+3|2|2}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test distinct_agg_functions {
-    select first_name, sum(distinct age), count(distinct age), avg(distinct age)
-    from users
-    group by 1
-    limit 3;
-    } {Aaron|1769|33|53.6060606060606
-    Abigail|833|15|55.5333333333333
-    Adam|1517|30|50.5666666666667}
-}
+do_execsql_test distinct_agg_functions {
+select first_name, sum(distinct age), count(distinct age), avg(distinct age)
+from users
+group by 1
+limit 3;
+} {Aaron|1769|33|53.6060606060606
+Abigail|833|15|55.5333333333333
+Adam|1517|30|50.5666666666667}
 
 do_execsql_test_on_specific_db {:memory:} having_or {
   CREATE TABLE users (first_name TEXT, age INTEGER);
diff --git a/testing/insert.test b/testing/insert.test
index 8944d1b77..78f881094 100755
--- a/testing/insert.test
+++ b/testing/insert.test
@@ -188,23 +188,21 @@ do_execsql_test_on_specific_db {:memory:} multi-rows {
 } {1|1
 2|1}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} unique_insert_no_pkey {
-        CREATE TABLE t2 (x INTEGER, y INTEGER UNIQUE);
-        INSERT INTO t2 (y) VALUES (1);
-        INSERT INTO t2 (y) VALUES (6);
-        SELECT * FROM t2;
-    } {|1
-    |6}
+do_execsql_test_on_specific_db {:memory:} unique_insert_no_pkey {
+    CREATE TABLE t2 (x INTEGER, y INTEGER UNIQUE);
+    INSERT INTO t2 (y) VALUES (1);
+    INSERT INTO t2 (y) VALUES (6);
+    SELECT * FROM t2;
+} {|1
+|6}
 
-    do_execsql_test_on_specific_db {:memory:} unique_insert_with_pkey {
-        CREATE TABLE t2 (x INTEGER PRIMARY KEY, y INTEGER UNIQUE);
-        INSERT INTO t2 (y) VALUES (1);
-        INSERT INTO t2 (y) VALUES (6);
-        SELECT * FROM t2;
-    } {1|1
-    2|6}
-}
+do_execsql_test_on_specific_db {:memory:} unique_insert_with_pkey {
+    CREATE TABLE t2 (x INTEGER PRIMARY KEY, y INTEGER UNIQUE);
+    INSERT INTO t2 (y) VALUES (1);
+    INSERT INTO t2 (y) VALUES (6);
+    SELECT * FROM t2;
+} {1|1
+2|6}
 
 do_execsql_test_on_specific_db {:memory:} not_null_insert {
     CREATE TABLE t2 (y INTEGER NOT NULL);
@@ -333,61 +331,59 @@ do_execsql_test_on_specific_db {:memory:} insert_from_select_same_table_2 {
 5|2|200
 6|3|300}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} insert_from_select_union {
-        CREATE TABLE t (a, b); 
-        CREATE TABLE t2 (b, c);
+do_execsql_test_on_specific_db {:memory:} insert_from_select_union {
+    CREATE TABLE t (a, b); 
+    CREATE TABLE t2 (b, c);
 
-        INSERT INTO t2 VALUES (1, 100), (2, 200);
-        INSERT INTO t SELECT * FROM t UNION SELECT * FROM t2;
-        SELECT * FROM t;
-    } {1|100
-    2|200}
+    INSERT INTO t2 VALUES (1, 100), (2, 200);
+    INSERT INTO t SELECT * FROM t UNION SELECT * FROM t2;
+    SELECT * FROM t;
+} {1|100
+2|200}
 
-    do_execsql_test_on_specific_db {:memory:} insert_from_select_union-2 {
-        CREATE TABLE t (a, b);
-        CREATE TABLE t2 (b, c);
+do_execsql_test_on_specific_db {:memory:} insert_from_select_union-2 {
+    CREATE TABLE t (a, b);
+    CREATE TABLE t2 (b, c);
 
-        INSERT INTO t SELECT * FROM t UNION values(1, 100), (2, 200);
-        SELECT * FROM t;
-    } {1|100
-    2|200}
+    INSERT INTO t SELECT * FROM t UNION values(1, 100), (2, 200);
+    SELECT * FROM t;
+} {1|100
+2|200}
 
-    do_execsql_test_on_specific_db {:memory:} insert_from_select_intersect {
-        CREATE TABLE t (a, b);
-        CREATE TABLE t1 (a, b);
-        CREATE TABLE t2 (a, b);
+do_execsql_test_on_specific_db {:memory:} insert_from_select_intersect {
+    CREATE TABLE t (a, b);
+    CREATE TABLE t1 (a, b);
+    CREATE TABLE t2 (a, b);
 
-        INSERT INTO t1 VALUES (1, 100), (2, 200);
-        INSERT INTO t2 VALUES (2, 200), (3, 300);
-        INSERT INTO t SELECT * FROM t1 INTERSECT SELECT * FROM t2;
-        SELECT * FROM t;
-    } {2|200}
+    INSERT INTO t1 VALUES (1, 100), (2, 200);
+    INSERT INTO t2 VALUES (2, 200), (3, 300);
+    INSERT INTO t SELECT * FROM t1 INTERSECT SELECT * FROM t2;
+    SELECT * FROM t;
+} {2|200}
 
-    do_execsql_test_on_specific_db {:memory:} insert_from_select_intersect-2 {
-        CREATE TABLE t (a, b);
-        CREATE TABLE t1 (a, b);
-        CREATE TABLE t2 (a, b);
-        CREATE TABLE t3 (a, b);
+do_execsql_test_on_specific_db {:memory:} insert_from_select_intersect-2 {
+    CREATE TABLE t (a, b);
+    CREATE TABLE t1 (a, b);
+    CREATE TABLE t2 (a, b);
+    CREATE TABLE t3 (a, b);
 
-        INSERT INTO t1 VALUES (1, 100), (2, 200);
-        INSERT INTO t2 VALUES (2, 200), (3, 300);
-        INSERT INTO t3 VALUES (2, 200), (4, 400);
-        INSERT INTO t SELECT * FROM t1 INTERSECT SELECT * FROM t2 INTERSECT SELECT * FROM t3;
-        SELECT * FROM t;
-    } {2|200}
+    INSERT INTO t1 VALUES (1, 100), (2, 200);
+    INSERT INTO t2 VALUES (2, 200), (3, 300);
+    INSERT INTO t3 VALUES (2, 200), (4, 400);
+    INSERT INTO t SELECT * FROM t1 INTERSECT SELECT * FROM t2 INTERSECT SELECT * FROM t3;
+    SELECT * FROM t;
+} {2|200}
 
-    do_execsql_test_on_specific_db {:memory:} insert_from_select_except {
-        CREATE TABLE t (a, b);
-        CREATE TABLE t1 (a, b);
-        CREATE TABLE t2 (a, b);
+do_execsql_test_on_specific_db {:memory:} insert_from_select_except {
+    CREATE TABLE t (a, b);
+    CREATE TABLE t1 (a, b);
+    CREATE TABLE t2 (a, b);
 
-        INSERT INTO t1 VALUES (1, 100), (2, 200);
-        INSERT INTO t2 VALUES (2, 200), (3, 300);
-        INSERT INTO t SELECT * FROM t1 EXCEPT SELECT * FROM t2;
-        SELECT * FROM t;
-    } {1|100}
-}
+    INSERT INTO t1 VALUES (1, 100), (2, 200);
+    INSERT INTO t2 VALUES (2, 200), (3, 300);
+    INSERT INTO t SELECT * FROM t1 EXCEPT SELECT * FROM t2;
+    SELECT * FROM t;
+} {1|100}
 
 do_execsql_test_on_specific_db {:memory:} negative-primary-integer-key {
     CREATE TABLE t (a INTEGER PRIMARY KEY);
@@ -411,21 +407,19 @@ do_execsql_test_on_specific_db {:memory:} rowid-overflow-random-generation {
 } {3}
 
 # regression test for incorrect processing of record header in the case of large text columns
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} large-text-index-seek {
-        CREATE TABLE t (x TEXT, y);
-        CREATE INDEX t_idx ON t(x);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'a', 1);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'b', 2);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'c', 3);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'd', 4);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'e', 5);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'f', 6);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'g', 7);
-        INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'h', 8);
-        SELECT COUNT(*) FROM t WHERE x >= replace(hex(zeroblob(100)), '00', 'a');
-    } {8}
-}
+do_execsql_test_on_specific_db {:memory:} large-text-index-seek {
+    CREATE TABLE t (x TEXT, y);
+    CREATE INDEX t_idx ON t(x);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'a', 1);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'b', 2);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'c', 3);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'd', 4);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'e', 5);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'f', 6);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'g', 7);
+    INSERT INTO t VALUES (replace(hex(zeroblob(1000)), '00', 'a') || 'h', 8);
+    SELECT COUNT(*) FROM t WHERE x >= replace(hex(zeroblob(100)), '00', 'a');
+} {8}
 
 do_execsql_test_skip_lines_on_specific_db 1 {:memory:} double-quote-string-literals {
     .dbconfig dqs_dml on
diff --git a/testing/join.test b/testing/join.test
index 8a82a4f5c..664be10e6 100755
--- a/testing/join.test
+++ b/testing/join.test
@@ -228,21 +228,11 @@ do_execsql_test left-join-constant-condition-true-inner-join-constant-condition-
     select u.first_name, p.name, u2.first_name from users u left join products as p on 1 join users u2 on 0 limit 5;
 } {}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test join-utilizing-both-seekrowid-and-secondary-index {
+do_execsql_test join-utilizing-both-seekrowid-and-secondary-index {
     select u.first_name, p.name from users u join products p on u.id = p.id and u.age > 70;
-    } {Matthew|boots
-    Nicholas|shorts
-    Jamie|hat}
-} else {
-    # without index experimental the order is different since we don't use indexes
-    do_execsql_test join-utilizing-both-seekrowid-and-secondary-index {
-    select u.first_name, p.name from users u join products p on u.id = p.id and u.age > 70;
-    } {Jamie|hat
-    Nicholas|shorts
-    Matthew|boots}
-
-}
+} {Matthew|boots
+Nicholas|shorts
+Jamie|hat}
 
 # important difference between regular SELECT * join and a SELECT * USING join is that the join keys are deduplicated
 # from the result in the USING case.
diff --git a/testing/orderby.test b/testing/orderby.test
index 555fccf6d..277ac9652 100755
--- a/testing/orderby.test
+++ b/testing/orderby.test
@@ -142,13 +142,11 @@ do_execsql_test case-insensitive-alias {
     select u.first_name as fF, count(1) > 0 as cC from users u where fF = 'Jamie' group by fF order by cC;
 } {Jamie|1}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test age_idx_order_desc {
-        select first_name from users order by age desc limit 3;
-    } {Robert
-    Sydney
-    Matthew}
-}
+do_execsql_test age_idx_order_desc {
+    select first_name from users order by age desc limit 3;
+} {Robert
+Sydney
+Matthew}
 
 do_execsql_test rowid_or_integer_pk_desc {
     select first_name from users order by id desc limit 3;
@@ -165,21 +163,19 @@ do_execsql_test orderby_desc_verify_rows {
     select count(1) from (select * from users order by age desc)
 } {10000}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test orderby_desc_with_offset {
-        select first_name, age from users order by age desc limit 3 offset 666;
-    } {Francis|94
-    Matthew|94
-    Theresa|94}
+do_execsql_test orderby_desc_with_offset {
+    select first_name, age from users order by age desc limit 3 offset 666;
+} {Francis|94
+Matthew|94
+Theresa|94}
 
-    do_execsql_test orderby_desc_with_filter {
-        select first_name, age from users where age <= 50 order by age desc limit 5;
-    } {Gerald|50
-    Nicole|50
-    Tammy|50
-    Marissa|50
-    Daniel|50}
-}
+do_execsql_test orderby_desc_with_filter {
+    select first_name, age from users where age <= 50 order by age desc limit 5;
+} {Gerald|50
+Nicole|50
+Tammy|50
+Marissa|50
+Daniel|50}
 
 do_execsql_test orderby_asc_with_filter_range {
     select first_name, age from users where age <= 50 and age >= 49 order by age asc limit 5;
diff --git a/testing/rollback.test b/testing/rollback.test
index a22f024c7..1132b6dc9 100755
--- a/testing/rollback.test
+++ b/testing/rollback.test
@@ -127,15 +127,13 @@ do_execsql_test_on_specific_db {:memory:} schema-alter-rollback-and-repeat {
     select sql from sqlite_schema;
 } {"CREATE TABLE t (x, y)"}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} schema-create-index-rollback {
-        create table t (x);
-        begin;
-        create index i on t(x);
-        rollback;
-        select sql from sqlite_schema;
-    } {"CREATE TABLE t (x)"}
-}
+do_execsql_test_on_specific_db {:memory:} schema-create-index-rollback {
+    create table t (x);
+    begin;
+    create index i on t(x);
+    rollback;
+    select sql from sqlite_schema;
+} {"CREATE TABLE t (x)"}
 
 do_execsql_test_on_specific_db {:memory:} schema-drop-table-rollback {
     create table t (x);
diff --git a/testing/select.test b/testing/select.test
index 0a0acbab3..9ed482e4e 100755
--- a/testing/select.test
+++ b/testing/select.test
@@ -309,368 +309,366 @@ do_execsql_test_error select-star-subquery {
   SELECT 1 FROM (SELECT *);
 } {no tables specified}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} select-union-1 {
+  do_execsql_test_on_specific_db {:memory:} select-union-1 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+
+  select * from t UNION select * from u;
+  } {x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-all-union {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  CREATE TABLE v (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+  INSERT INTO v VALUES('x','x'),('y','y');
+
+  select * from t UNION select * from u UNION ALL select * from v;
+  } {x|x
+  y|y
+  x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-all-union-2 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  CREATE TABLE v (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+  INSERT INTO v VALUES('x','x'),('y','y');
+
+  select * from t UNION ALL select * from u UNION select * from v;
+  } {x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-3 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  CREATE TABLE v (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+  INSERT INTO v VALUES('x','x'),('y','y');
+
+  select * from t UNION select * from u UNION select * from v;
+  } {x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-4 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  CREATE TABLE v (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+  INSERT INTO v VALUES('x','x'),('y','y');
+
+  select * from t UNION select * from u UNION select * from v UNION select * from t;
+  } {x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-all-union-3 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  CREATE TABLE v (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y');
+  INSERT INTO v VALUES('x','x'),('y','y');
+
+  select * from t UNION select * from u UNION select * from v UNION ALL select * from t;
+  } {x|x
+  y|y
+  x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-all-with-offset {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y'),('z', 'z');
+
+  select * from t UNION ALL select * from u limit 1 offset 1;
+  } {y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-union-with-offset {
+  CREATE TABLE t (x TEXT, y TEXT);
+  CREATE TABLE u (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
+  INSERT INTO u VALUES('x','x'),('y','y'),('z', 'z');
+
+  select * from t UNION select * from u limit 1 offset 1;
+  } {y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-intersect-1 {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
 
-    select * from t UNION select * from u;
-    } {x|x
-    y|y}
+    select * from t INTERSECT select * from u;
+  } {x|x}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-all-union {
+  do_execsql_test_on_specific_db {:memory:} select-intersect-2 {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
     INSERT INTO u VALUES('x','x'),('y','y');
-    INSERT INTO v VALUES('x','x'),('y','y');
+    INSERT INTO v VALUES('a','x'),('y','y');
 
-    select * from t UNION select * from u UNION ALL select * from v;
-    } {x|x
-    y|y
-    x|x
-    y|y}
+    select * from t INTERSECT select * from u INTERSECT select * from v INTERSECT select * from t;
+  } {y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-all-union-2 {
+  do_execsql_test_on_specific_db {:memory:} select-intersect-union {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y');
-    INSERT INTO v VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-    select * from t UNION ALL select * from u UNION select * from v;
-    } {x|x
-    y|y}
+    select * from t INTERSECT select * from u UNION select * from v;
+  } {x|x
+  z|z}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-3 {
+  do_execsql_test_on_specific_db {:memory:} select-union-intersect {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y');
-    INSERT INTO v VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-    select * from t UNION select * from u UNION select * from v;
-    } {x|x
-    y|y}
+    select * from t UNION select * from u INTERSECT select * from v;
+  } {x|x}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-4 {
+  do_execsql_test_on_specific_db {:memory:} select-union-all-intersect {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y');
-    INSERT INTO v VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-    select * from t UNION select * from u UNION select * from v UNION select * from t;
-    } {x|x
-    y|y}
+    select * from t UNION ALL select * from u INTERSECT select * from v;
+  } {x|x}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-all-union-3 {
+  do_execsql_test_on_specific_db {:memory:} select-intersect-union-all {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
     CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
+
+    select * from t INTERSECT select * from u UNION ALL select * from v;
+  } {x|x
+  x|x
+  z|z}
+
+  do_execsql_test_on_specific_db {:memory:} select-intersect-with-limit {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
+    INSERT INTO u VALUES('x','x'),('y','y'), ('z','z');
+
+    select * from t INTERSECT select * from u limit 2;
+  } {x|x
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-intersect-with-offset {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
+    INSERT INTO u VALUES('x','x'),('y','y'), ('z','z');
+
+    select * from t INTERSECT select * from u limit 2 offset 1;
+  } {y|y
+  z|z}
+
+  do_execsql_test_on_specific_db {:memory:} select-intersect-union-with-limit {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
+    INSERT INTO u VALUES('d','d'),('e','e'), ('z','z');
+    INSERT INTO v VALUES('a','a'),('b','b');
+
+    select * from t INTERSECT select * from u UNION select * from v limit 3;
+  } {a|a
+  b|b
+  z|z}
+
+  do_execsql_test_on_specific_db {:memory:} select-except-1 {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+
+    select * from t EXCEPT select * from u;
+  } {y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-except-2 {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
     INSERT INTO u VALUES('x','x'),('y','y');
+
+    select * from t EXCEPT select * from u;
+  } {}
+
+  do_execsql_test_on_specific_db {:memory:} select-except-3 {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('a','y');
+    INSERT INTO v VALUES('a','x'),('b','y');
+
+    select * from t EXCEPT select * from u EXCEPT select * from v;
+  } {y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-except-limit {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    INSERT INTO t VALUES('a', 'a'),('x','x'),('y','y'),('z','z');
+    INSERT INTO u VALUES('x','x'),('z','y');
+
+    select * from t EXCEPT select * from u limit 2;
+  } {a|a
+  y|y}
+
+  do_execsql_test_on_specific_db {:memory:} select-except-union-all {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
     INSERT INTO v VALUES('x','x'),('y','y');
 
-    select * from t UNION select * from u UNION select * from v UNION ALL select * from t;
-    } {x|x
-    y|y
-    x|x
-    y|y}
+    select * from t EXCEPT select * from u UNION ALL select * from v;
+  } {y|y
+  x|x
+  y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-all-with-offset {
+  do_execsql_test_on_specific_db {:memory:} select-union-all-except {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y'),('z', 'z');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('y','y');
 
-    select * from t UNION ALL select * from u limit 1 offset 1;
-    } {y|y}
+    select * from t UNION ALL select * from u EXCEPT select * from v;
+  } {z|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-with-offset {
+  do_execsql_test_on_specific_db {:memory:} select-except-union {
     CREATE TABLE t (x TEXT, y TEXT);
     CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
-    INSERT INTO u VALUES('x','x'),('y','y'),('z', 'z');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-    select * from t UNION select * from u limit 1 offset 1;
-    } {y|y}
+    select * from t EXCEPT select * from u UNION select * from v;
+  } {x|x
+  y|y
+  z|z}
 
-    do_execsql_test_on_specific_db {:memory:} select-intersect-1 {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
+  do_execsql_test_on_specific_db {:memory:} select-union-except {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-      select * from t INTERSECT select * from u;
-    } {x|x}
+    select * from t UNION select * from u EXCEPT select * from v;
+  } {y|y
+  z|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-intersect-2 {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('y','y');
-      INSERT INTO v VALUES('a','x'),('y','y');
+  do_execsql_test_on_specific_db {:memory:} select-except-intersect {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('y','y'),('z','z');
 
-      select * from t INTERSECT select * from u INTERSECT select * from v INTERSECT select * from t;
-    } {y|y}
+    select * from t EXCEPT select * from u INTERSECT select * from v;
+  } {y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-intersect-union {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
+  do_execsql_test_on_specific_db {:memory:} select-intersect-except {
+    CREATE TABLE t (x TEXT, y TEXT);
+    CREATE TABLE u (x TEXT, y TEXT);
+    CREATE TABLE v (x TEXT, y TEXT);
+    INSERT INTO t VALUES('x','x'),('y','y');
+    INSERT INTO u VALUES('x','x'),('z','y');
+    INSERT INTO v VALUES('x','x'),('z','z');
 
-      select * from t INTERSECT select * from u UNION select * from v;
-    } {x|x
-    z|z}
+    select * from t INTERSECT select * from u EXCEPT select * from v;
+  } {}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-intersect {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
+  do_execsql_test_on_specific_db {:memory:} select-values-union {
+  CREATE TABLE t (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
 
-      select * from t UNION select * from u INTERSECT select * from v;
-    } {x|x}
+  values('x', 'x') UNION select * from t;
+  } {x|x
+  y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-union-all-intersect {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
+  do_execsql_test_on_specific_db {:memory:} select-values-union-2 {
+  CREATE TABLE t (x TEXT, y TEXT);
+  INSERT INTO t VALUES('x','x'),('y','y');
 
-      select * from t UNION ALL select * from u INTERSECT select * from v;
-    } {x|x}
+  values('x', 'x'), ('y', 'y') UNION select * from t;
+  } {x|x
+  y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-intersect-union-all {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
-
-      select * from t INTERSECT select * from u UNION ALL select * from v;
-    } {x|x
-    x|x
-    z|z}
-
-    do_execsql_test_on_specific_db {:memory:} select-intersect-with-limit {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
-      INSERT INTO u VALUES('x','x'),('y','y'), ('z','z');
-
-      select * from t INTERSECT select * from u limit 2;
-    } {x|x
-    y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-intersect-with-offset {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
-      INSERT INTO u VALUES('x','x'),('y','y'), ('z','z');
-
-      select * from t INTERSECT select * from u limit 2 offset 1;
-    } {y|y
-    z|z}
-
-    do_execsql_test_on_specific_db {:memory:} select-intersect-union-with-limit {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y'), ('z','z');
-      INSERT INTO u VALUES('d','d'),('e','e'), ('z','z');
-      INSERT INTO v VALUES('a','a'),('b','b');
-
-      select * from t INTERSECT select * from u UNION select * from v limit 3;
-    } {a|a
-    b|b
-    z|z}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-1 {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-
-      select * from t EXCEPT select * from u;
-    } {y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-2 {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('y','y');
-
-      select * from t EXCEPT select * from u;
-    } {}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-3 {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('a','y');
-      INSERT INTO v VALUES('a','x'),('b','y');
-
-      select * from t EXCEPT select * from u EXCEPT select * from v;
-    } {y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-limit {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      INSERT INTO t VALUES('a', 'a'),('x','x'),('y','y'),('z','z');
-      INSERT INTO u VALUES('x','x'),('z','y');
-
-      select * from t EXCEPT select * from u limit 2;
-    } {a|a
-    y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-union-all {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('y','y');
-
-      select * from t EXCEPT select * from u UNION ALL select * from v;
-    } {y|y
-    x|x
-    y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-union-all-except {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('y','y');
-
-      select * from t UNION ALL select * from u EXCEPT select * from v;
-    } {z|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-union {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
-
-      select * from t EXCEPT select * from u UNION select * from v;
-    } {x|x
-    y|y
-    z|z}
-
-    do_execsql_test_on_specific_db {:memory:} select-union-except {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
-
-      select * from t UNION select * from u EXCEPT select * from v;
-    } {y|y
-    z|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-except-intersect {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('y','y'),('z','z');
-
-      select * from t EXCEPT select * from u INTERSECT select * from v;
-    } {y|y}
-
-    do_execsql_test_on_specific_db {:memory:} select-intersect-except {
-      CREATE TABLE t (x TEXT, y TEXT);
-      CREATE TABLE u (x TEXT, y TEXT);
-      CREATE TABLE v (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
-      INSERT INTO u VALUES('x','x'),('z','y');
-      INSERT INTO v VALUES('x','x'),('z','z');
-
-      select * from t INTERSECT select * from u EXCEPT select * from v;
-    } {}
-
-    do_execsql_test_on_specific_db {:memory:} select-values-union {
+  do_execsql_test_on_specific_db {:memory:} select-values-except {
     CREATE TABLE t (x TEXT, y TEXT);
     INSERT INTO t VALUES('x','x'),('y','y');
 
-    values('x', 'x') UNION select * from t;
-    } {x|x
-    y|y}
+    select * from t EXCEPT values('x','x'),('z','y');
+  } {y|y}
 
-    do_execsql_test_on_specific_db {:memory:} select-values-union-2 {
-    CREATE TABLE t (x TEXT, y TEXT);
-    INSERT INTO t VALUES('x','x'),('y','y');
+  do_execsql_test_on_specific_db {:memory:} select-values-union-all-limit {
+  CREATE TABLE t (x TEXT);
+  INSERT INTO t VALUES('x'), ('y'), ('z');
 
-    values('x', 'x'), ('y', 'y') UNION select * from t;
-    } {x|x
-    y|y}
+  values('x') UNION ALL select * from t limit 3;
+  } {x
+  x
+  y}
 
-    do_execsql_test_on_specific_db {:memory:} select-values-except {
-      CREATE TABLE t (x TEXT, y TEXT);
-      INSERT INTO t VALUES('x','x'),('y','y');
+  do_execsql_test_on_specific_db {:memory:} select-values-union-all-limit-1 {
+  CREATE TABLE t (x TEXT);
+  INSERT INTO t VALUES('x'), ('y'), ('z');
 
-      select * from t EXCEPT values('x','x'),('z','y');
-    } {y|y}
+  values('a'), ('b') UNION ALL select * from t limit 3;
+  } {a
+  b
+  x}
 
-    do_execsql_test_on_specific_db {:memory:} select-values-union-all-limit {
-    CREATE TABLE t (x TEXT);
-    INSERT INTO t VALUES('x'), ('y'), ('z');
+  do_execsql_test_on_specific_db {:memory:} select-values-union-all-offset {
+  CREATE TABLE t (x TEXT);
+  INSERT INTO t VALUES('x'), ('y'), ('z');
 
-    values('x') UNION ALL select * from t limit 3;
-    } {x
-    x
-    y}
+  values('a'), ('b') UNION ALL select * from t limit 3 offset 1;
+  } {b
+  x
+  y}
 
-    do_execsql_test_on_specific_db {:memory:} select-values-union-all-limit-1 {
-    CREATE TABLE t (x TEXT);
-    INSERT INTO t VALUES('x'), ('y'), ('z');
+  do_execsql_test_on_specific_db {:memory:} select-values-union-all-offset-1 {
+  CREATE TABLE t (x TEXT);
+  INSERT INTO t VALUES('i'), ('j'), ('x'), ('y'), ('z');
 
-    values('a'), ('b') UNION ALL select * from t limit 3;
-    } {a
-    b
-    x}
-
-    do_execsql_test_on_specific_db {:memory:} select-values-union-all-offset {
-    CREATE TABLE t (x TEXT);
-    INSERT INTO t VALUES('x'), ('y'), ('z');
-
-    values('a'), ('b') UNION ALL select * from t limit 3 offset 1;
-    } {b
-    x
-    y}
-
-    do_execsql_test_on_specific_db {:memory:} select-values-union-all-offset-1 {
-    CREATE TABLE t (x TEXT);
-    INSERT INTO t VALUES('i'), ('j'), ('x'), ('y'), ('z');
-
-    values('a') UNION ALL select * from t limit 3 offset 1;
-    } {i
-    j
-    x}
-}
+  values('a') UNION ALL select * from t limit 3 offset 1;
+  } {i
+  j
+  x}
 
 do_execsql_test_on_specific_db {:memory:} select-no-match-in-leaf-page {
     CREATE TABLE t (a INTEGER PRIMARY KEY, b);
diff --git a/testing/subquery.test b/testing/subquery.test
index 1cec4c8ec..98ecec001 100644
--- a/testing/subquery.test
+++ b/testing/subquery.test
@@ -412,21 +412,19 @@ do_execsql_test subquery-ignore-unused-cte {
     select * from sub;
 } {Jamie}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    # Test verifying that select distinct works (distinct ages are 1-100)
-    do_execsql_test subquery-count-distinct-age {
-        select count(1) from (select distinct age from users);
-    } {100}
+# Test verifying that select distinct works (distinct ages are 1-100)
+do_execsql_test subquery-count-distinct-age {
+    select count(1) from (select distinct age from users);
+} {100}
 
-    # Test verifying that select distinct works for multiple columns, and across joins
-    do_execsql_test subquery-count-distinct {
-        select count(1) from (
-            select distinct first_name, name 
-            from users u join products p 
-            where u.id < 100
-        );
-    } {902}
-}
+# Test verifying that select distinct works for multiple columns, and across joins
+do_execsql_test subquery-count-distinct {
+    select count(1) from (
+        select distinct first_name, name 
+        from users u join products p 
+        where u.id < 100
+    );
+} {902}
 
 do_execsql_test subquery-count-all {
     select count(1) from (
diff --git a/testing/update.test b/testing/update.test
index 2228dd29d..091b5c1f0 100755
--- a/testing/update.test
+++ b/testing/update.test
@@ -190,32 +190,30 @@ do_execsql_test_on_specific_db {:memory:} update_cache_full_regression_test_#162
     SELECT count(*) FROM t;
 } {1}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test_on_specific_db {:memory:} update_index_regression_test {
-        CREATE TABLE t (x, y);
-        CREATE INDEX tx ON t (x);
-        CREATE UNIQUE INDEX tyu ON t (y);
-        INSERT INTO t VALUES (1, 1);
-        SELECT x FROM t; -- uses tx index
-        SELECT y FROM t; -- uses ty index
-        UPDATE t SET x=2, y=2;
-        SELECT x FROM t; -- uses tx index
-        SELECT y FROM t; -- uses ty index
-    } {1
-    1
-    2
-    2}
+do_execsql_test_on_specific_db {:memory:} update_index_regression_test {
+    CREATE TABLE t (x, y);
+    CREATE INDEX tx ON t (x);
+    CREATE UNIQUE INDEX tyu ON t (y);
+    INSERT INTO t VALUES (1, 1);
+    SELECT x FROM t; -- uses tx index
+    SELECT y FROM t; -- uses ty index
+    UPDATE t SET x=2, y=2;
+    SELECT x FROM t; -- uses tx index
+    SELECT y FROM t; -- uses ty index
+} {1
+1
+2
+2}
 
-    do_execsql_test_on_specific_db {:memory:} update_rowid_alias_index_regression_test {
-        CREATE TABLE t (a INTEGER PRIMARY KEY, b);
-        CREATE INDEX idx_b ON t (b);
-        INSERT INTO t VALUES (1, 'foo');
-        SELECT a FROM t WHERE b = 'foo';
-        UPDATE t SET a = 2, b = 'bar';
-        SELECT a FROM t WHERE b = 'bar';
-    } {1
-    2}
-}
+do_execsql_test_on_specific_db {:memory:} update_rowid_alias_index_regression_test {
+    CREATE TABLE t (a INTEGER PRIMARY KEY, b);
+    CREATE INDEX idx_b ON t (b);
+    INSERT INTO t VALUES (1, 'foo');
+    SELECT a FROM t WHERE b = 'foo';
+    UPDATE t SET a = 2, b = 'bar';
+    SELECT a FROM t WHERE b = 'bar';
+} {1
+2}
 
 do_execsql_test_on_specific_db {:memory:} update_where_or_regression_test {
     CREATE TABLE t (a INTEGER);
diff --git a/testing/where.test b/testing/where.test
index 42a51e9d8..4763f142f 100755
--- a/testing/where.test
+++ b/testing/where.test
@@ -163,47 +163,24 @@ do_execsql_test where-clause-no-table-constant-condition-false-7 {
     select 1 where 'hamburger';
 } {}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    # this test functions as an assertion that the index on users.age is being used, since the results are ordered by age without an order by.
-    do_execsql_test select-where-and {
-        select first_name, age from users where first_name = 'Jamie' and age > 80
-    } {Jamie|87
-    Jamie|88
-    Jamie|88
-    Jamie|92
-    Jamie|94
-    Jamie|99
-    }
-    do_execsql_test select-where-or {
-        select first_name, age from users where first_name = 'Jamie' and age > 80
-    } {Jamie|87
-    Jamie|88
-    Jamie|88
-    Jamie|92
-    Jamie|94
-    Jamie|99
-    }
-} else {
-    # this test functions as an assertion that the index on users.age is being used, since the results are ordered by age without an order by.
-    do_execsql_test select-where-and {
-        select first_name, age from users where first_name = 'Jamie' and age > 80
-    } {Jamie|94
-    Jamie|88
-    Jamie|99
-    Jamie|92
-    Jamie|87
-    Jamie|88
-    }
-    do_execsql_test select-where-or {
-        select first_name, age from users where first_name = 'Jamie' and age > 80
-    } {Jamie|94
-    Jamie|88
-    Jamie|99
-    Jamie|92
-    Jamie|87
-    Jamie|88
-    }
-
+# this test functions as an assertion that the index on users.age is being used, since the results are ordered by age without an order by.
+do_execsql_test select-where-and {
+    select first_name, age from users where first_name = 'Jamie' and age > 80
+} {Jamie|87
+Jamie|88
+Jamie|88
+Jamie|92
+Jamie|94
+Jamie|99
+}
+do_execsql_test select-where-or {
+    select first_name, age from users where first_name = 'Jamie' and age > 80
+} {Jamie|87
+Jamie|88
+Jamie|88
+Jamie|92
+Jamie|94
+Jamie|99
 }
 
 
@@ -414,16 +391,9 @@ do_execsql_test where-age-index-seek-regression-test-2 {
     select count(1) from users where age > 0;
 } {10000}
 
-if {[info exists ::env(SQLITE_EXEC)] && ($::env(SQLITE_EXEC) eq "scripts/limbo-sqlite3-index-experimental" || $::env(SQLITE_EXEC) eq "sqlite3")} {
-    do_execsql_test where-age-index-seek-regression-test-3 {
-        select age from users where age > 90 limit 1;
-    } {91}
-} else {
-    do_execsql_test where-age-index-seek-regression-test-3 {
-        select age from users where age > 90 limit 1;
-    } {94}
-
-}
+do_execsql_test where-age-index-seek-regression-test-3 {
+    select age from users where age > 90 limit 1;
+} {91}
 
 do_execsql_test where-simple-between {
     SELECT * FROM products WHERE price BETWEEN 70 AND 100;