@an5/adapters 0.2.6 → 0.2.10

package/dist/googlesheets/helpers.js

@@ -25,9 +25,7 @@ function matchWhere(row, where) {
         if (key.includes('_') &&
             value && typeof value === 'object' &&
             !(value instanceof Date) &&
-            !value.in && !value.contains &&
-            !value.not && !value.gte &&
-            !value.lte && !value.gt && !value.lt) {
+            !['equals', 'in', 'notIn', 'contains', 'startsWith', 'endsWith', 'not', 'gte', 'lte', 'gt', 'lt'].some(op => op in value)) {
             Object.assign(cleanWhere, value);
         }
         else {
@@ -35,13 +33,16 @@ function matchWhere(row, where) {
         }
     }
     for (const [key, value] of Object.entries(cleanWhere)) {
+        if (value === undefined)
+            continue;
         if (key === 'OR' && Array.isArray(value)) {
             if (!value.some((v) => matchWhere(row, v)))
                 return false;
             continue;
         }
-        if (key === 'AND' && Array.isArray(value)) {
-            if (!value.every((v) => matchWhere(row, v)))
+        if (key === 'AND') {
+            const clauses = Array.isArray(value) ? value : [value];
+            if (!clauses.every((v) => matchWhere(row, v)))
                 return false;
             continue;
         }
@@ -65,21 +66,25 @@ function matchWhere(row, where) {
                     if (cellVal === null || cellVal === undefined)
                         return false;
                 }
+                else if (v.not && typeof v.not === 'object' && !(v.not instanceof Date) && !Array.isArray(v.not)) {
+                    if (matchWhere(row, { [key]: v.not }))
+                        return false;
+                }
                 else if (normalize(cellVal) == normalize(v.not))
                     return false;
             }
             if (v.equals !== undefined && normalize(cellVal) != normalize(v.equals))
                 return false;
             if (v.contains !== undefined) {
-                if (!cellVal || !normalize(String(cellVal)).includes(normalize(v.contains)))
+                if (cellVal === null || cellVal === undefined || !normalize(String(cellVal)).includes(normalize(v.contains)))
                     return false;
             }
             if (v.startsWith !== undefined) {
-                if (!cellVal || !normalize(String(cellVal)).startsWith(normalize(v.startsWith)))
+                if (cellVal === null || cellVal === undefined || !normalize(String(cellVal)).startsWith(normalize(v.startsWith)))
                     return false;
             }
             if (v.endsWith !== undefined) {
-                if (!cellVal || !normalize(String(cellVal)).endsWith(normalize(v.endsWith)))
+                if (cellVal === null || cellVal === undefined || !normalize(String(cellVal)).endsWith(normalize(v.endsWith)))
                     return false;
             }
             if (v.gte !== undefined && !(Number(cellVal) >= Number(v.gte)))

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { An5Adapter, AdapterTableClient, createAn5Adapter, createAdapterProxy, executorFromAdapter, setAdapterMetadata, } from './an5Adapter';
 export { parseWhere, buildOrderBy, quote } from './base/sql';
+export { NBaseVectorClient, NBaseError, createNBaseVectorClient, createNBaseClient, parseNBaseConnectionString, buildVectorId, parseVectorId, } from './nbase';
+export type { NBaseAdapterConfig, NBaseClientConfig, NBaseVector, NBaseSearchOptions, NBaseSearchResult, NBaseStats, } from './nbase';
 export type { An5AdapterConfig, AdapterMetadata, Dialect, } from './an5Adapter';
 export type { TypedAn5Adapter, AdapterAPI } from './typed';
 export { getLlmConfig, setLlmConfig, getEmbeddingConfig, setEmbeddingConfig, resetAdapter, } from './config';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSheetsConnectionString = exports.createAn5SheetsAdapter = exports.SheetsTableClient = exports.An5SheetsAdapter = exports.resetAdapter = exports.setEmbeddingConfig = exports.getEmbeddingConfig = exports.setLlmConfig = exports.getLlmConfig = exports.quote = exports.buildOrderBy = exports.parseWhere = exports.setAdapterMetadata = exports.executorFromAdapter = exports.createAdapterProxy = exports.createAn5Adapter = exports.AdapterTableClient = exports.An5Adapter = void 0;
+exports.parseSheetsConnectionString = exports.createAn5SheetsAdapter = exports.SheetsTableClient = exports.An5SheetsAdapter = exports.resetAdapter = exports.setEmbeddingConfig = exports.getEmbeddingConfig = exports.setLlmConfig = exports.getLlmConfig = exports.parseVectorId = exports.buildVectorId = exports.parseNBaseConnectionString = exports.createNBaseClient = exports.createNBaseVectorClient = exports.NBaseError = exports.NBaseVectorClient = exports.quote = exports.buildOrderBy = exports.parseWhere = exports.setAdapterMetadata = exports.executorFromAdapter = exports.createAdapterProxy = exports.createAn5Adapter = exports.AdapterTableClient = exports.An5Adapter = void 0;
 var an5Adapter_1 = require("./an5Adapter");
 Object.defineProperty(exports, "An5Adapter", { enumerable: true, get: function () { return an5Adapter_1.An5Adapter; } });
 Object.defineProperty(exports, "AdapterTableClient", { enumerable: true, get: function () { return an5Adapter_1.AdapterTableClient; } });
@@ -12,6 +12,14 @@ var sql_1 = require("./base/sql");
 Object.defineProperty(exports, "parseWhere", { enumerable: true, get: function () { return sql_1.parseWhere; } });
 Object.defineProperty(exports, "buildOrderBy", { enumerable: true, get: function () { return sql_1.buildOrderBy; } });
 Object.defineProperty(exports, "quote", { enumerable: true, get: function () { return sql_1.quote; } });
+var nbase_1 = require("./nbase");
+Object.defineProperty(exports, "NBaseVectorClient", { enumerable: true, get: function () { return nbase_1.NBaseVectorClient; } });
+Object.defineProperty(exports, "NBaseError", { enumerable: true, get: function () { return nbase_1.NBaseError; } });
+Object.defineProperty(exports, "createNBaseVectorClient", { enumerable: true, get: function () { return nbase_1.createNBaseVectorClient; } });
+Object.defineProperty(exports, "createNBaseClient", { enumerable: true, get: function () { return nbase_1.createNBaseClient; } });
+Object.defineProperty(exports, "parseNBaseConnectionString", { enumerable: true, get: function () { return nbase_1.parseNBaseConnectionString; } });
+Object.defineProperty(exports, "buildVectorId", { enumerable: true, get: function () { return nbase_1.buildVectorId; } });
+Object.defineProperty(exports, "parseVectorId", { enumerable: true, get: function () { return nbase_1.parseVectorId; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "getLlmConfig", { enumerable: true, get: function () { return config_1.getLlmConfig; } });
 Object.defineProperty(exports, "setLlmConfig", { enumerable: true, get: function () { return config_1.setLlmConfig; } });

package/dist/nbase/client.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+export interface NBaseVector {
+    id: string | number;
+    vector: number[];
+    metadata?: Record<string, unknown>;
+}
+export interface NBaseSearchOptions {
+    /** Number of neighbours to return. */
+    k?: number;
+    /** Distance metric; NBase accepts `cosine` and `euclidean`. */
+    distanceMetric?: 'cosine' | 'euclidean';
+    /** `hnsw` uses the graph index, anything else uses the clustered path. */
+    method?: 'hnsw' | 'clustered';
+    efSearch?: number;
+    filters?: Record<string, unknown> | Array<Record<string, unknown>>;
+    includeMetadata?: boolean;
+    includeVectors?: boolean;
+    skipCache?: boolean;
+    searchTimeoutMs?: number;
+    rerank?: boolean;
+    rerankingMethod?: string;
+    rerankLambda?: number;
+    partitionIds?: string[];
+}
+export interface NBaseSearchResult {
+    id: string | number;
+    /** Distance from the query vector. Lower is more similar. */
+    dist: number;
+    metadata?: Record<string, unknown>;
+    vector?: number[];
+    dimension?: number;
+}
+export interface NBaseClientConfig {
+    /** Base URL, e.g. `http://localhost:1307`. */
+    url: string;
+    /** Optional bearer token, for deployments behind an auth proxy. */
+    token?: string;
+    /** Per-request timeout in milliseconds. */
+    timeoutMs?: number;
+    /** Injectable for tests and for runtimes without a global fetch. */
+    fetchImpl?: typeof fetch;
+}
+export interface NBaseStats {
+    vectorCount?: number;
+    metadataCount?: number;
+    memoryUsage?: number;
+    [key: string]: unknown;
+}
+export declare class NBaseError extends Error {
+    readonly status?: number | undefined;
+    readonly body?: unknown;
+    constructor(message: string, status?: number | undefined, body?: unknown);
+}
+export declare class NBaseVectorClient {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    constructor(config: NBaseClientConfig);
+    private request;
+    /** Liveness probe. NBase mounts its status routes at the server root. */
+    health(): Promise<{
+        status: string;
+        version?: string;
+    }>;
+    /** Vector count, memory use and other database statistics. */
+    stats(): Promise<NBaseStats>;
+    /** Adds or replaces vectors. NBase accepts a single vector or a bulk array. */
+    addVectors(vectors: NBaseVector[]): Promise<{
+        count: number;
+        ids?: Array<string | number>;
+    }>;
+    /** Nearest-neighbour search. Results are ordered by ascending `dist`. */
+    search(vector: number[], options?: NBaseSearchOptions): Promise<NBaseSearchResult[]>;
+    /** Reads a single vector. Returns undefined when the id is unknown. */
+    get(id: string | number): Promise<NBaseSearchResult | undefined>;
+    exists(id: string | number): Promise<boolean>;
+    delete(id: string | number): Promise<boolean>;
+    updateMetadata(id: string | number, metadata: Record<string, unknown>): Promise<boolean>;
+}
+/** Creates an NBase vector client. */
+export declare function createNBaseVectorClient(config: NBaseClientConfig): NBaseVectorClient;

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/dist/sqlite/engine.js

@@ -15,7 +15,8 @@ class SqliteEngine {
             throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
         this.filePath = (adapterConfig.connectionString ?? '')
             .replace(/^sqlite:\/\/\//i, '/')
-            .replace(/^sqlite:\/\//i, '');
+            .replace(/^sqlite:\/\//i, '')
+            .replace(/^sqlite:/i, '');
     }
     getDb() {
         if (!this.db)

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;