@an5/adapters 0.2.6 → 0.2.9

package/dist/nbase/client.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * NBase — Neural Vector Database client.
+ *
+ * NBase is a vector database with HNSW/LSH/KNN indexing exposed over a REST
+ * API. an5 uses it to move similarity search out of the database process: the
+ * vectors live in NBase, the rows stay in the relational table, and the search
+ * results are hydrated from the table by the id kept in vector metadata.
+ *
+ * The client only uses the global `fetch`, so it works in Node 18+ and in the
+ * browser without pulling in a dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NBaseVectorClient = exports.NBaseError = void 0;
+exports.createNBaseVectorClient = createNBaseVectorClient;
+const DEFAULT_TIMEOUT_MS = 30000;
+class NBaseError extends Error {
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'NBaseError';
+    }
+}
+exports.NBaseError = NBaseError;
+class NBaseVectorClient {
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = String(config.url).replace(/\/+$/, '');
+        const impl = config.fetchImpl ?? globalThis.fetch;
+        if (!impl) {
+            throw new NBaseError('No fetch implementation available. Node 18+ or a fetch polyfill is required.');
+        }
+        this.fetchImpl = impl;
+        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    }
+    async request(path, init) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+                ...init,
+                signal: controller.signal,
+                headers: {
+                    'content-type': 'application/json',
+                    ...(this.config.token ? { authorization: `Bearer ${this.config.token}` } : {}),
+                    ...init?.headers,
+                },
+            });
+            const text = await response.text();
+            let body;
+            try {
+                body = text ? JSON.parse(text) : undefined;
+            }
+            catch {
+                body = text;
+            }
+            if (!response.ok) {
+                const message = (body && typeof body === 'object' && 'error' in body
+                    ? String(body.error)
+                    : undefined) ?? `HTTP ${response.status}`;
+                throw new NBaseError(`NBase request ${path} failed: ${message}`, response.status, body);
+            }
+            return body;
+        }
+        catch (err) {
+            if (err instanceof NBaseError)
+                throw err;
+            if (err?.name === 'AbortError') {
+                throw new NBaseError(`NBase request ${path} timed out after ${this.timeoutMs}ms`);
+            }
+            throw new NBaseError(`Could not reach NBase at ${this.baseUrl}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** Liveness probe. NBase mounts its status routes at the server root. */
+    async health() {
+        return this.request('/health');
+    }
+    /** Vector count, memory use and other database statistics. */
+    async stats() {
+        return this.request('/stats');
+    }
+    /** Adds or replaces vectors. NBase accepts a single vector or a bulk array. */
+    async addVectors(vectors) {
+        if (vectors.length === 0)
+            return { count: 0 };
+        const result = await this.request('/api/vectors', { method: 'POST', body: JSON.stringify({ vectors: vectors.length === 1 ? vectors[0] : vectors }) });
+        return { count: result.count ?? vectors.length, ...(result.addedIds ? { ids: result.addedIds } : {}) };
+    }
+    /** Nearest-neighbour search. Results are ordered by ascending `dist`. */
+    async search(vector, options = {}) {
+        const body = await this.request('/api/search', {
+            method: 'POST',
+            body: JSON.stringify({
+                query: vector,
+                k: options.k ?? 10,
+                ...(options.distanceMetric ? { distanceMetric: options.distanceMetric } : {}),
+                ...(options.method ? { method: options.method } : {}),
+                ...(options.efSearch !== undefined ? { efSearch: options.efSearch } : {}),
+                ...(options.filters ? { filters: options.filters } : {}),
+                ...(options.includeMetadata !== undefined ? { includeMetadata: options.includeMetadata } : {}),
+                ...(options.includeVectors !== undefined ? { includeVectors: options.includeVectors } : {}),
+                ...(options.skipCache !== undefined ? { skipCache: options.skipCache } : {}),
+                ...(options.searchTimeoutMs !== undefined ? { searchTimeoutMs: options.searchTimeoutMs } : {}),
+                ...(options.rerank !== undefined ? { rerank: options.rerank } : {}),
+                ...(options.rerankingMethod ? { rerankingMethod: options.rerankingMethod } : {}),
+                ...(options.rerankLambda !== undefined ? { rerankLambda: options.rerankLambda } : {}),
+                ...(options.partitionIds ? { partitionIds: options.partitionIds } : {}),
+            }),
+        });
+        return body.results ?? [];
+    }
+    /** Reads a single vector. Returns undefined when the id is unknown. */
+    async get(id) {
+        try {
+            return await this.request(`/api/vectors/${encodeURIComponent(String(id))}`);
+        }
+        catch (err) {
+            if (err instanceof NBaseError && err.status === 404)
+                return undefined;
+            throw err;
+        }
+    }
+    async exists(id) {
+        const result = await this.request(`/api/vectors/${encodeURIComponent(String(id))}/exists`);
+        return result.exists === true;
+    }
+    async delete(id) {
+        await this.request(`/api/vectors/${encodeURIComponent(String(id))}`, { method: 'DELETE' });
+        return true;
+    }
+    async updateMetadata(id, metadata) {
+        await this.request(`/api/vectors/${encodeURIComponent(String(id))}/metadata`, {
+            method: 'PATCH',
+            body: JSON.stringify(metadata),
+        });
+        return true;
+    }
+}
+exports.NBaseVectorClient = NBaseVectorClient;
+/** Creates an NBase vector client. */
+function createNBaseVectorClient(config) {
+    return new NBaseVectorClient(config);
+}

package/dist/nbase/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * NBase connection-string and adapter configuration.
+ *
+ * NBase is configured through the connection string alone:
+ *
+ *    createAn5Adapter({ connectionString: 'nbase://localhost:1307' })
+ *
+ * Accepted forms are `nbase://host:port`, `nbase:host:port` and an explicit
+ * scheme, with optional `?token=…&timeoutMs=…&method=…` options. An adapter
+ * created this way is vector-only: it has no relational database, so a search
+ * returns the NBase hits instead of table rows.
+ */
+import { NBaseVectorClient, NBaseError, createNBaseVectorClient, type NBaseClientConfig, type NBaseVector, type NBaseSearchOptions, type NBaseSearchResult, type NBaseStats } from './client';
+export interface NBaseAdapterConfig extends NBaseClientConfig {
+    url: string;
+    /**
+     * Metadata key that holds the relational row id. `an5Id` by default, which
+     * is what `indexTableVectors` writes.
+     */
+    idField?: string;
+    /** Metadata key holding the model name, used to keep collections apart. */
+    modelField?: string;
+    /** Force the search method instead of letting NBase choose. */
+    method?: 'hnsw' | 'clustered';
+}
+/** True when the whole connection string points at NBase. */
+export declare function isNBaseConnectionString(connectionString: string): boolean;
+/**
+ * Parses an NBase connection string.
+ *
+ * Accepts `nbase:http://host:port`, `nbase://host:port` and
+ * `nbase:host:port`, with optional `?token=…&timeoutMs=…` options.
+ */
+export declare function parseNBaseConnectionString(connectionString: string): NBaseAdapterConfig;
+/** Builds the vector id used to link a NBase vector back to a relational row. */
+export declare function buildVectorId(model: string, id: string | number): string;
+/** Splits a vector id produced by {@link buildVectorId}. */
+export declare function parseVectorId(vectorId: string | number): {
+    model: string;
+    id: string;
+};
+export declare function createNBaseClient(config: NBaseAdapterConfig | string): {
+    client: NBaseVectorClient;
+    options: NBaseAdapterConfig;
+};
+export { NBaseVectorClient, NBaseError, createNBaseVectorClient };
+export type { NBaseClientConfig, NBaseVector, NBaseSearchOptions, NBaseSearchResult, NBaseStats };

package/dist/nbase/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNBaseVectorClient = exports.NBaseError = exports.NBaseVectorClient = void 0;
+exports.isNBaseConnectionString = isNBaseConnectionString;
+exports.parseNBaseConnectionString = parseNBaseConnectionString;
+exports.buildVectorId = buildVectorId;
+exports.parseVectorId = parseVectorId;
+exports.createNBaseClient = createNBaseClient;
+/**
+ * NBase connection-string and adapter configuration.
+ *
+ * NBase is configured through the connection string alone:
+ *
+ *    createAn5Adapter({ connectionString: 'nbase://localhost:1307' })
+ *
+ * Accepted forms are `nbase://host:port`, `nbase:host:port` and an explicit
+ * scheme, with optional `?token=…&timeoutMs=…&method=…` options. An adapter
+ * created this way is vector-only: it has no relational database, so a search
+ * returns the NBase hits instead of table rows.
+ */
+const client_1 = require("./client");
+Object.defineProperty(exports, "NBaseVectorClient", { enumerable: true, get: function () { return client_1.NBaseVectorClient; } });
+Object.defineProperty(exports, "NBaseError", { enumerable: true, get: function () { return client_1.NBaseError; } });
+Object.defineProperty(exports, "createNBaseVectorClient", { enumerable: true, get: function () { return client_1.createNBaseVectorClient; } });
+/** Matches `nbase:`, `nbase://` and `nbase=http(s)://` at the start of a value. */
+const NBASE_PREFIX = /^nbase:(?:\/\/)?/i;
+/** True when the whole connection string points at NBase. */
+function isNBaseConnectionString(connectionString) {
+    return NBASE_PREFIX.test(connectionString.trim());
+}
+/** Builds options from a URL and an optional query string. */
+function buildOptions(url, query) {
+    const params = new URLSearchParams(query ?? '');
+    const trimmed = url.trim().replace(/\/+$/, '');
+    // `nbase://host:port` is shorthand for the same host over HTTP; an explicit
+    // scheme is used as-is so https deployments work.
+    const withScheme = !trimmed
+        ? 'http://localhost:1307'
+        : /^[a-z]+:\/\//i.test(trimmed)
+            ? trimmed
+            : `http://${trimmed}`;
+    return {
+        url: withScheme,
+        ...(params.get('token') ? { token: params.get('token') } : {}),
+        ...(params.get('timeoutMs') ? { timeoutMs: Number(params.get('timeoutMs')) } : {}),
+        ...(params.get('idField') ? { idField: params.get('idField') } : {}),
+        ...(params.get('modelField') ? { modelField: params.get('modelField') } : {}),
+        ...(params.get('method') ? { method: params.get('method') } : {}),
+    };
+}
+/**
+ * Parses an NBase connection string.
+ *
+ * Accepts `nbase:http://host:port`, `nbase://host:port` and
+ * `nbase:host:port`, with optional `?token=…&timeoutMs=…` options.
+ */
+function parseNBaseConnectionString(connectionString) {
+    const raw = connectionString.trim();
+    if (!isNBaseConnectionString(raw)) {
+        throw new Error(`Not an NBase connection string: ${raw}`);
+    }
+    const [url, query] = raw.replace(NBASE_PREFIX, '').split('?');
+    return buildOptions(url ?? '', query);
+}
+/** Builds the vector id used to link a NBase vector back to a relational row. */
+function buildVectorId(model, id) {
+    return `${model}:${id}`;
+}
+/** Splits a vector id produced by {@link buildVectorId}. */
+function parseVectorId(vectorId) {
+    const raw = String(vectorId);
+    const separator = raw.indexOf(':');
+    if (separator === -1)
+        return { model: '', id: raw };
+    return { model: raw.slice(0, separator), id: raw.slice(separator + 1) };
+}
+function createNBaseClient(config) {
+    const options = typeof config === 'string' ? parseNBaseConnectionString(config) : config;
+    return { client: (0, client_1.createNBaseVectorClient)(options), options };
+}

package/dotnet/An5Adapter.cs

@@ -25,6 +25,7 @@ namespace An5Orm
             _engine = DialectDetector.Detect(connectionString) switch
             {
                 Dialect.Postgres => new PostgresEngine(connectionString, commandTimeout),
+                Dialect.Sqlite => new SqliteEngine(connectionString, commandTimeout),
                 _ => new MssqlEngine(connectionString, commandTimeout)
             };
         }
@@ -44,8 +45,16 @@ namespace An5Orm
 
         // ── Stored Procedure Execution ────────────────────────────────────────
 
+        private void ThrowIfNoStoredProcedures()
+        {
+            if (Dialect == Dialect.Sqlite)
+                throw new NotSupportedException(
+                    "SQLite has no stored procedures. Run the statements directly with QueryRaw or ExecuteRaw.");
+        }
+
         public List<T> QueryProc<T>(string procName, Dictionary<string, object> parameters = null) where T : new()
         {
+            ThrowIfNoStoredProcedures();
             var paramList = new List<string>();
             if (parameters != null)
             {
@@ -62,6 +71,7 @@ namespace An5Orm
 
         public int ExecuteProc(string procName, Dictionary<string, object> parameters = null)
         {
+            ThrowIfNoStoredProcedures();
             var paramList = new List<string>();
             if (parameters != null)
             {
@@ -418,12 +428,27 @@ namespace An5Orm
 
         private string Nolock => _dialect == Dialect.Mssql ? " WITH (NOLOCK)" : "";
 
+        /// <summary>
+        /// True for the dialects that paginate with LIMIT/OFFSET rather than
+        /// OFFSET ... FETCH NEXT, and have no SELECT TOP.
+        /// </summary>
+        private bool UsesLimitOffset => _dialect == Dialect.Postgres || _dialect == Dialect.Sqlite;
+
         private string BuildPagination(string orderBy, int? skip, int? take)
         {
-            if (take == null) return "";
-            if (_dialect == Dialect.Postgres)
-                return $" LIMIT {take.Value} OFFSET {skip ?? 0}";
+            // A skip on its own still has to skip. OFFSET without FETCH NEXT is
+            // valid on MSSQL, and on the LIMIT/OFFSET dialects an unbounded page
+            // is LIMIT -1; without this, `skip` was silently discarded whenever
+            // `take` was null.
+            if (take == null && skip == null) return "";
+            if (UsesLimitOffset)
+            {
+                if (take == null) return $" LIMIT -1 OFFSET {skip.Value}";
+                if (skip == null) return $" LIMIT {take.Value}";
+                return $" LIMIT {take.Value} OFFSET {skip.Value}";
+            }
             var o = !string.IsNullOrEmpty(orderBy) ? $" ORDER BY {orderBy}" : " ORDER BY (SELECT NULL)";
+            if (take == null) return $"{o} OFFSET {skip.Value} ROWS";
             return $"{o} OFFSET {skip ?? 0} ROWS FETCH NEXT {take.Value} ROWS ONLY";
         }
 
@@ -432,17 +457,11 @@ namespace An5Orm
         {
             var sb = new StringBuilder($"SELECT * FROM {_tableName}{Nolock}");
             if (!string.IsNullOrEmpty(whereClause)) sb.Append($" WHERE {whereClause}");
-            if (take != null && _dialect == Dialect.Postgres)
-            {
-                if (!string.IsNullOrEmpty(orderBy)) sb.Append($" ORDER BY {orderBy}");
-                if (skip != null) sb.Append($" OFFSET {skip.Value} ROWS");
-                sb.Append($" LIMIT {take.Value}");
-            }
-            else
-            {
-                if (!string.IsNullOrEmpty(orderBy)) sb.Append($" ORDER BY {orderBy}");
-                sb.Append(BuildPagination(orderBy, skip, take));
-            }
+            if (!string.IsNullOrEmpty(orderBy)) sb.Append($" ORDER BY {orderBy}");
+            // LIMIT precedes OFFSET, and neither carries MSSQL's `ROWS` keyword.
+            // Postgres tolerates either order, SQLite does not: `OFFSET n LIMIT m`
+            // is a syntax error there.
+            sb.Append(BuildPagination(orderBy, skip, take));
             return _adapter.QueryRaw<T>(sb.ToString(), parameters);
         }
 
@@ -457,7 +476,7 @@ namespace An5Orm
 
             var cols = "*";
             var keys = ArgsHelper.SelectedFields(args?.Select);
-            var isPostgres = _dialect == Dialect.Postgres;
+            var usesLimitOffset = UsesLimitOffset;
 
             if (keys.Count > 0 && !ArgsHelper.HasRelationSelect(args?.Select, An5Metadata.GetRelationsForModel(_modelName)))
             {
@@ -468,7 +487,7 @@ namespace An5Orm
             string query;
             if (take != null && !hasSkip)
             {
-                if (!isPostgres)
+                if (!usesLimitOffset)
                 {
                     query = $"SELECT TOP ({take.Value}) {cols} FROM {_tableName}{Nolock}";
                     if (!string.IsNullOrEmpty(whereSql)) query += $" WHERE {whereSql}";
@@ -484,7 +503,7 @@ namespace An5Orm
             }
             else if (hasSkip)
             {
-                if (!isPostgres)
+                if (!usesLimitOffset)
                 {
                     query = $"SELECT {cols} FROM {_tableName}{Nolock}";
                     if (!string.IsNullOrEmpty(whereSql)) query += $" WHERE {whereSql}";
@@ -498,7 +517,7 @@ namespace An5Orm
                     if (!string.IsNullOrEmpty(whereSql)) query += $" WHERE {whereSql}";
                     if (!string.IsNullOrEmpty(orderSql)) query += $" {orderSql}";
                     if (take != null) query += $" LIMIT {take.Value}";
-                    else query += " LIMIT ALL";
+                    else query += _dialect == Dialect.Sqlite ? " LIMIT -1" : " LIMIT ALL";
                     query += $" OFFSET {skip.Value}";
                 }
             }
@@ -988,6 +1007,10 @@ namespace An5Orm
             string vectorField = "Embedding", string distanceMetric = "cosine")
         {
             // 1. Primary path: Native database SQL vector query execution (MSSQL VECTOR_DISTANCE / Postgres pgvector)
+            //    SQLite has no vector operator, so it is skipped outright: building the
+            //    statement only to have it rejected costs a round trip and lands on the
+            //    in-memory path below anyway.
+            if (_dialect != Dialect.Sqlite)
             try
             {
                 var dim = vector.Count;

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("\"", "\"\"") + "\"";

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(); }
     }
 }