@an5/adapters 0.2.6 → 0.2.10

package/dotnet/Base/Core.cs

@@ -7,7 +7,8 @@ namespace An5Orm
 public enum Dialect
     {
         Mssql,
-        Postgres
+        Postgres,
+        Sqlite
     }
 
     // ─── Config ────────────────────────────────────────────────────────────────
@@ -39,6 +40,38 @@ public enum Dialect
         public abstract void Dispose();
     }
 
+    // ─── Connection scope ──────────────────────────────────────────────────────
+
+    /// <summary>
+    /// A connection borrowed for the length of one operation, and whether the
+    /// caller still owns it.
+    ///
+    /// A statement issued while a transaction is open has to run on that
+    /// transaction's connection. Opening a second one is not merely wasteful: on
+    /// SQLite the open transaction holds a write lock, so the second connection
+    /// is refused with "database is locked", and on the server engines the write
+    /// silently lands outside the transaction, so commit and rollback do not
+    /// cover it. Each engine keeps the transaction connection and hands it back
+    /// through this scope while it is set.
+    /// </summary>
+    internal readonly struct ConnectionScope<T> : IDisposable where T : class
+    {
+        public T Connection { get; }
+
+        private readonly bool _owned;
+
+        internal ConnectionScope(T connection, bool owned)
+        {
+            Connection = connection;
+            _owned = owned;
+        }
+
+        public void Dispose()
+        {
+            if (_owned && Connection is IDisposable disposable) disposable.Dispose();
+        }
+    }
+
 // ─── Dialect detection ─────────────────────────────────────────────────────
 
     internal static class DialectDetector
@@ -46,6 +79,13 @@ public enum Dialect
         public static Dialect Detect(string connectionString)
         {
             var cs = (connectionString ?? "").Trim().ToLowerInvariant();
+            // SQLite first: `Data Source=app.db` and a bare file path would
+            // otherwise fall through, and a Postgres string never looks like
+            // any of these.
+            if (cs.StartsWith("sqlite:") || cs.StartsWith("file:") || cs == ":memory:"
+                || cs.Contains("data source=") || cs.Contains("datasource=")
+                || cs.EndsWith(".db") || cs.EndsWith(".sqlite") || cs.EndsWith(".sqlite3"))
+                return Dialect.Sqlite;
             if (cs.StartsWith("postgres://") || cs.StartsWith("postgresql://") || cs.Contains("host="))
                 return Dialect.Postgres;
             return Dialect.Mssql;
@@ -66,7 +106,7 @@ public enum Dialect
         public static string QuoteName(string name, Dialect dialect)
         {
             var raw = name ?? "";
-            if (dialect == Dialect.Postgres)
+            if (dialect == Dialect.Postgres || dialect == Dialect.Sqlite)
             {
                 var unwrapped = StripWrapping(StripWrapping(raw, "[", "]"), "\"", "\"");
                 return "\"" + unwrapped.Replace("\"", "\"\"") + "\"";
@@ -219,40 +259,30 @@ public enum Dialect
             {
                 var key = kv.Key;
                 var value = kv.Value;
-                if (key == "OR" && value is System.Collections.IList orList && orList.Count > 0)
+                if (key == "OR" || key == "AND" || key == "NOT")
                 {
+                    var items = value is System.Collections.IList list
+                        ? list : new object[] { value };
                     var subs = new List<string>();
                     var i = 0;
-                    foreach (var item in orList)
+                    foreach (var item in items)
                     {
                         if (item is Dictionary<string, object> subMap)
                         {
-                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}or{i++}_");
-                            if (!string.IsNullOrEmpty(s)) subs.Add(s);
+                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}{key}{i++}_");
+                            subs.Add(string.IsNullOrEmpty(s) ? "1=1" : s);
                         }
                     }
-                    if (subs.Count > 0) conditions.Add("(" + string.Join(" OR ", subs) + ")");
-                    continue;
-                }
-                if (key == "AND" && value is System.Collections.IList andList && andList.Count > 0)
-                {
-                    var subs = new List<string>();
-                    var i = 0;
-                    foreach (var item in andList)
+                    if (subs.Count == 0)
                     {
-                        if (item is Dictionary<string, object> subMap)
-                        {
-                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}and{i++}_");
-                            if (!string.IsNullOrEmpty(s)) subs.Add(s);
-                        }
+                        if (key == "OR") conditions.Add("1=0");
+                    }
+                    else
+                    {
+                        var joiner = key == "AND" ? " AND " : " OR ";
+                        var negation = key == "NOT" ? "NOT " : "";
+                        conditions.Add(negation + "(" + string.Join(joiner, subs) + ")");
                     }
-                    if (subs.Count > 0) conditions.Add("(" + string.Join(" AND ", subs) + ")");
-                    continue;
-                }
-                if (key == "NOT" && value is Dictionary<string, object> notMap)
-                {
-                    var s = ParseWhere(notMap, parameters, dialect, $"{prefix}not_");
-                    if (!string.IsNullOrEmpty(s)) conditions.Add("NOT (" + s + ")");
                     continue;
                 }
 

package/dotnet/Postgres/PostgresEngine.cs

@@ -13,14 +13,22 @@ namespace An5Orm
         private readonly string _connectionString;
         private readonly int _commandTimeout;
 
+        // Same shape as MssqlEngine: while a transaction is open, statements
+        // have to run on its connection and carry its transaction, or they land
+        // outside it and commit/rollback do not cover them.
+        [ThreadStatic] private static Npgsql.NpgsqlConnection _txConn;
+        [ThreadStatic] private static Npgsql.NpgsqlTransaction _tx;
+
         public PostgresEngine(string connectionString, int commandTimeout)
         {
             _connectionString = connectionString;
             _commandTimeout = commandTimeout;
         }
 
-        private Npgsql.NpgsqlConnection OpenConnection()
+        private Npgsql.NpgsqlConnection OpenConnection(out bool isInTransaction)
         {
+            if (_txConn != null) { isInTransaction = true; return _txConn; }
+            isInTransaction = false;
             var conn = new Npgsql.NpgsqlConnection(_connectionString);
             conn.Open();
             return conn;
@@ -30,6 +38,7 @@ namespace An5Orm
             Npgsql.NpgsqlConnection conn, string sql, Dictionary<string, object> parameters)
         {
             var cmd = new Npgsql.NpgsqlCommand(sql, conn) { CommandTimeout = _commandTimeout };
+            if (_tx != null) cmd.Transaction = _tx;
             if (parameters != null)
             {
                 foreach (var kv in parameters)
@@ -44,48 +53,60 @@ namespace An5Orm
         public List<Dictionary<string, object>> QueryRaw(string sql, Dictionary<string, object> parameters)
         {
             var results = new List<Dictionary<string, object>>();
-            using var conn = OpenConnection();
-            using var cmd = BuildCommand(conn, sql, parameters);
-            using var reader = cmd.ExecuteReader();
-            while (reader.Read())
+            var conn = OpenConnection(out bool isTx);
+            try
             {
-                var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
-                for (int i = 0; i < reader.FieldCount; i++)
+                using var cmd = BuildCommand(conn, sql, parameters);
+                using var reader = cmd.ExecuteReader();
+                while (reader.Read())
                 {
-                    row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                    var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                    for (int i = 0; i < reader.FieldCount; i++)
+                    {
+                        row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                    }
+                    results.Add(row);
                 }
-                results.Add(row);
             }
+            finally { if (!isTx) conn.Dispose(); }
             return results;
         }
 
         public List<T> QueryRaw<T>(string sql, Dictionary<string, object> parameters) where T : new()
         {
             var results = new List<T>();
-            using var conn = OpenConnection();
-            using var cmd = BuildCommand(conn, sql, parameters);
-            using var reader = cmd.ExecuteReader();
-            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
-            while (reader.Read())
+            var conn = OpenConnection(out bool isTx);
+            try
             {
-                var item = new T();
-                foreach (var prop in props)
+                using var cmd = BuildCommand(conn, sql, parameters);
+                using var reader = cmd.ExecuteReader();
+                var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+                while (reader.Read())
                 {
-                    if (!HasColumn(reader, prop.Name)) continue;
-                    var val = reader[prop.Name];
-                    if (val == DBNull.Value) continue;
-                    try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                    var item = new T();
+                    foreach (var prop in props)
+                    {
+                        if (!HasColumn(reader, prop.Name)) continue;
+                        var val = reader[prop.Name];
+                        if (val == DBNull.Value) continue;
+                        try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                    }
+                    results.Add(item);
                 }
-                results.Add(item);
             }
+            finally { if (!isTx) conn.Dispose(); }
             return results;
         }
 
         public int ExecuteRaw(string sql, Dictionary<string, object> parameters)
         {
-            using var conn = OpenConnection();
-            using var cmd = BuildCommand(conn, sql, parameters);
-            return cmd.ExecuteNonQuery();
+            var conn = OpenConnection(out bool isTx);
+            try
+            {
+                using var cmd = BuildCommand(conn, sql, parameters);
+                return cmd.ExecuteNonQuery();
+            }
+            finally { if (!isTx) conn.Dispose(); }
         }
 
         private static bool HasColumn(Npgsql.NpgsqlDataReader reader, string name)
@@ -97,9 +118,14 @@ namespace An5Orm
 
         public An5TransactionBase BeginTransaction()
         {
-            var conn = OpenConnection();
+            if (_txConn != null)
+                throw new InvalidOperationException("A transaction is already open on this thread.");
+            var conn = new Npgsql.NpgsqlConnection(_connectionString);
+            conn.Open();
             var tx = conn.BeginTransaction();
-            return new PostgresTransaction(conn, tx);
+            _txConn = conn;
+            _tx = tx;
+            return new PostgresTransaction(conn, tx, () => { _txConn = null; _tx = null; });
         }
     }
 
@@ -107,15 +133,17 @@ namespace An5Orm
     {
         private readonly Npgsql.NpgsqlConnection _conn;
         private readonly Npgsql.NpgsqlTransaction _tx;
+        private readonly Action _cleanup;
 
-        public PostgresTransaction(Npgsql.NpgsqlConnection conn, Npgsql.NpgsqlTransaction tx)
+        public PostgresTransaction(Npgsql.NpgsqlConnection conn, Npgsql.NpgsqlTransaction tx, Action cleanup)
         {
             _conn = conn;
             _tx = tx;
+            _cleanup = cleanup;
         }
 
-        public override void Commit() { _tx.Commit(); }
-        public override void Rollback() { _tx.Rollback(); }
-        public override void Dispose() { _tx.Dispose(); _conn.Dispose(); }
+        public override void Commit() { _tx.Commit(); _cleanup(); }
+        public override void Rollback() { _tx.Rollback(); _cleanup(); }
+        public override void Dispose() { _tx.Dispose(); _conn.Dispose(); _cleanup(); }
     }
 }

package/dotnet/Sqlite/SqliteEngine.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+
+namespace An5Orm
+{
+    // ─── SQLite Engine ──────────────────────────────────────────────────────────
+    //
+    // Microsoft.Data.Sqlite is a different type family from the other two
+    // providers (SqliteConnection/SqliteCommand, not DbConnection subclasses you
+    // can reuse), so it gets its own engine rather than a shared abstraction.
+    //
+    // Notable differences from MSSQL, all handled by the SQL builder in
+    // An5Adapter rather than here: no WITH (NOLOCK) table hint, no SELECT TOP,
+    // LIMIT/OFFSET instead of OFFSET/FETCH NEXT, and no stored procedures.
+
+    internal class SqliteEngine : IQueryEngine
+    {
+        public Dialect Dialect => Dialect.Sqlite;
+        private readonly string _connectionString;
+        private readonly int _commandTimeout;
+
+        public SqliteEngine(string connectionString, int commandTimeout)
+        {
+            _connectionString = SqliteConnectionString.Normalize(connectionString);
+            _commandTimeout = commandTimeout;
+        }
+
+        // Set while a transaction is open; statements then join it instead of
+        // opening a second connection, which SQLite would refuse.
+        private Microsoft.Data.Sqlite.SqliteConnection _txnConn;
+
+        private Microsoft.Data.Sqlite.SqliteConnection OpenNewConnection()
+        {
+            var conn = new Microsoft.Data.Sqlite.SqliteConnection(_connectionString);
+            conn.Open();
+            // WAL keeps readers from blocking the writer, and foreign keys are
+            // off by default in SQLite even when the schema declares them.
+            using var pragma = conn.CreateCommand();
+            pragma.CommandText = "PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;";
+            pragma.ExecuteNonQuery();
+            return conn;
+        }
+
+        private ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection> Acquire()
+            => _txnConn != null
+                ? new ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection>(_txnConn, owned: false)
+                : new ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection>(OpenNewConnection(), owned: true);
+
+        private Microsoft.Data.Sqlite.SqliteCommand BuildCommand(
+            Microsoft.Data.Sqlite.SqliteConnection conn, string sql, Dictionary<string, object> parameters)
+        {
+            var cmd = conn.CreateCommand();
+            cmd.CommandText = sql;
+            cmd.CommandTimeout = _commandTimeout;
+            if (parameters != null)
+            {
+                foreach (var kv in parameters)
+                {
+                    // SqliteParameter names must not carry the prefix; the SQL
+                    // keeps @name and the parameter is registered as name.
+                    var paramName = kv.Key.TrimStart('@');
+                    var value = kv.Value ?? DBNull.Value;
+
+                    var param = cmd.CreateParameter();
+                    param.ParameterName = paramName;
+                    // A JSON vector or a bool needs a type SQLite will store in a
+                    // column rather than coerce to an integer.
+                    if (value is bool flag) param.Value = flag ? 1 : 0;
+                    else param.Value = value;
+                    cmd.Parameters.Add(param);
+                }
+            }
+            return cmd;
+        }
+
+        public List<Dictionary<string, object>> QueryRaw(string sql, Dictionary<string, object> parameters)
+        {
+            var results = new List<Dictionary<string, object>>();
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            while (reader.Read())
+            {
+                var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                for (int i = 0; i < reader.FieldCount; i++)
+                {
+                    row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                }
+                results.Add(row);
+            }
+            return results;
+        }
+
+        public List<T> QueryRaw<T>(string sql, Dictionary<string, object> parameters) where T : new()
+        {
+            var results = new List<T>();
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            while (reader.Read())
+            {
+                var item = new T();
+                foreach (var prop in props)
+                {
+                    if (!HasColumn(reader, prop.Name)) continue;
+                    var val = reader[prop.Name];
+                    if (val == DBNull.Value) continue;
+                    try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                }
+                results.Add(item);
+            }
+            return results;
+        }
+
+        public int ExecuteRaw(string sql, Dictionary<string, object> parameters)
+        {
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            return cmd.ExecuteNonQuery();
+        }
+
+        private static bool HasColumn(Microsoft.Data.Sqlite.SqliteDataReader reader, string name)
+        {
+            for (int i = 0; i < reader.FieldCount; i++)
+                if (reader.GetName(i).Equals(name, StringComparison.OrdinalIgnoreCase)) return true;
+            return false;
+        }
+
+        /// <summary>Detaches the transaction connection, so later statements open their own.</summary>
+        internal void ReleaseTransactionConnection() => _txnConn = null;
+
+        public An5TransactionBase BeginTransaction()
+        {
+            if (_txnConn != null)
+                throw new InvalidOperationException("A transaction is already open on this adapter.");
+            var conn = OpenNewConnection();
+            var tx = conn.BeginTransaction();
+            _txnConn = conn;
+            return new SqliteTransaction(this, conn, tx);
+        }
+    }
+
+    internal class SqliteTransaction : An5TransactionBase
+    {
+        private readonly SqliteEngine _engine;
+        private readonly Microsoft.Data.Sqlite.SqliteConnection _conn;
+        private readonly Microsoft.Data.Sqlite.SqliteTransaction _tx;
+
+        public SqliteTransaction(SqliteEngine engine, Microsoft.Data.Sqlite.SqliteConnection conn, Microsoft.Data.Sqlite.SqliteTransaction tx)
+        {
+            _engine = engine;
+            _conn = conn;
+            _tx = tx;
+        }
+
+        public override void Commit() { _tx.Commit(); }
+
+        public override void Rollback() { _tx.Rollback(); }
+
+        public override void Dispose()
+        {
+            _engine.ReleaseTransactionConnection();
+            _tx.Dispose();
+            _conn.Dispose();
+        }
+    }
+
+    // ─── Connection string normalisation ──────────────────────────────────────
+
+    internal static class SqliteConnectionString
+    {
+        /// <summary>
+        /// Turns the accepted spellings into a Data Source string.
+        ///
+        /// Microsoft.Data.Sqlite only understands `Data Source=`, so the bare
+        /// paths and `sqlite:` URLs the rest of the ORM accepts have to be
+        /// rewritten. An in-memory database has to stay open for the life of the
+        /// connection, which is why callers keep one connection per operation
+        /// open only for the duration of a statement.
+        /// </summary>
+        public static string Normalize(string connectionString)
+        {
+            var cs = (connectionString ?? "").Trim();
+            if (cs.Length == 0) return "Data Source=:memory:";
+
+            // Already a Microsoft.Data.Sqlite connection string.
+            if (cs.IndexOf("Data Source", StringComparison.OrdinalIgnoreCase) >= 0
+                || cs.IndexOf("DataSource", StringComparison.OrdinalIgnoreCase) >= 0
+                || cs.IndexOf("Mode", StringComparison.OrdinalIgnoreCase) >= 0)
+                return cs;
+
+            if (cs == ":memory:")
+                return "Data Source=:memory:";
+
+            if (cs.StartsWith("sqlite://", StringComparison.OrdinalIgnoreCase))
+                return "Data Source=" + cs.Substring("sqlite://".Length);
+
+            if (cs.StartsWith("sqlite:", StringComparison.OrdinalIgnoreCase))
+            {
+                // `sqlite:app.db` and `sqlite::memory:`
+                return "Data Source=" + cs.Substring("sqlite:".Length);
+            }
+
+            if (cs.StartsWith("file:", StringComparison.OrdinalIgnoreCase))
+                return cs; // SQLite URI, understood as-is.
+
+            // A bare path.
+            return "Data Source=" + cs;
+        }
+    }
+}

package/golang/base/where.go

@@ -80,55 +80,41 @@ func buildWhereRec(where map[string]interface{}, dialect Dialect, args *[]interf
 		value := where[key]
 
 		switch key {
-		case "OR":
-			if list, ok := toSlice(value); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%sor%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
-					}
-				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "("+strings.Join(subs, " OR ")+")")
-				}
-				continue
-			}
-		case "AND":
-			if list, ok := toSlice(value); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%sand%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
-					}
-				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "("+strings.Join(subs, " AND ")+")")
-				}
-				continue
-			}
-		case "NOT":
+		case "OR", "AND", "NOT":
 			items := value
 			if m, ok := value.(map[string]interface{}); ok {
 				items = []interface{}{m}
 			}
-			if list, ok := toSlice(items); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%snot%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
+			list, ok := toSlice(items)
+			if !ok {
+				continue
+			}
+			var subs []string
+			for i, item := range list {
+				if m, ok := item.(map[string]interface{}); ok {
+					s := buildWhereRec(cleanWhere(m), dialect, args, ph, fmt.Sprintf("%s%s%d_", prefix, key, i))
+					if s == "" {
+						s = "1=1"
 					}
+					subs = append(subs, s)
 				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "NOT ("+strings.Join(subs, " AND ")+")")
+			}
+			if len(subs) == 0 {
+				if key == "OR" {
+					conditions = append(conditions, "1=0")
 				}
-				continue
+			} else {
+				joiner := " OR "
+				if key == "AND" {
+					joiner = " AND "
+				}
+				clause := "(" + strings.Join(subs, joiner) + ")"
+				if key == "NOT" {
+					clause = "NOT " + clause
+				}
+				conditions = append(conditions, clause)
 			}
+			continue
 		}
 
 		conditions = append(conditions, buildFieldCondition(key, value, dialect, args, ph, prefix)...)
@@ -171,13 +157,10 @@ func buildFieldCondition(key string, value interface{}, dialect Dialect, args *[
 		case "not":
 			if val == nil {
 				parts = append(parts, col+" IS NOT NULL")
-			} else if nested, ok := val.(map[string]interface{}); ok && !isOperatorMap(val) {
-				if nestedArgs := len(*args); true {
-					nestedCond := buildWhereRec(map[string]interface{}{key: nested}, dialect, args, ph, key+"_not_")
-					_ = nestedArgs
-					if nestedCond != "" {
-						parts = append(parts, "NOT ("+nestedCond+")")
-					}
+			} else if nested, ok := val.(map[string]interface{}); ok {
+				nestedCond := buildWhereRec(map[string]interface{}{key: nested}, dialect, args, ph, key+"_not_")
+				if nestedCond != "" {
+					parts = append(parts, "NOT ("+nestedCond+")")
 				}
 			} else {
 				parts = append(parts, fmt.Sprintf("%s <> %s", col, addArg(val)))
@@ -308,4 +291,4 @@ func BuildOrderBy(orderBy interface{}, dialect Dialect) string {
 		return ""
 	}
 	return "ORDER BY " + strings.Join(parts, ", ")
-}
+}

package/golang/base/where_test.go

@@ -0,0 +1,57 @@
+package base
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// SQLite is provided by Python's standard library to keep the adapter driver-neutral.
+func TestSharedQueryContract(t *testing.T) {
+	fixtures, err := os.ReadFile(filepath.Join("..", "..", "test", "fixtures", "query-semantics.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var contract struct {
+		Rows  []map[string]interface{} `json:"rows"`
+		Cases []struct {
+			Name  string                 `json:"name"`
+			Where map[string]interface{} `json:"where"`
+			IDs   []int                  `json:"ids"`
+		} `json:"cases"`
+	}
+	if err := json.Unmarshal(fixtures, &contract); err != nil {
+		t.Fatal(err)
+	}
+	python, err := exec.LookPath("python3")
+	if err != nil {
+		t.Fatal("python3 is required for the SQLite query contract")
+	}
+	for _, c := range contract.Cases {
+		t.Run(c.Name, func(t *testing.T) {
+			clause, args := BuildWhere(c.Where, DialectSqlite, func(int) string { return "?" })
+			payload, _ := json.Marshal(map[string]interface{}{"rows": contract.Rows, "clause": clause, "args": args})
+			cmd := exec.Command(python, "-c", `import json,sqlite3,sys
+p=json.loads(sys.argv[1])
+db=sqlite3.connect(':memory:')
+db.execute('CREATE TABLE users (id INTEGER, score INTEGER)')
+db.executemany('INSERT INTO users VALUES (?,?)',[(r['id'],r['score']) for r in p['rows']])
+sql='SELECT id FROM users'+(' WHERE '+p['clause'] if p['clause'] else '')+' ORDER BY id'
+print(json.dumps([r[0] for r in db.execute(sql,p['args'])]))`, string(payload))
+			output, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatalf("query failed: %v\n%s", err, output)
+			}
+			var got []int
+			if err := json.Unmarshal(output, &got); err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(got, c.IDs) {
+				t.Fatalf("got %v, want %v", got, c.IDs)
+			}
+		})
+	}
+}