@eltjs/sdk-microsoft-sql-server 0.0.0-stage → 0.1.0

package/dist/codecs/integer-codec.js

@@ -0,0 +1,23 @@
+import { SqlServerCodec } from './sql-server-codec.js';
+// tinyint, smallint and int, which a JavaScript number holds exactly.
+export class IntegerCodec extends SqlServerCodec {
+    value = { kind: 'integer' };
+    #type;
+    constructor(type) {
+        super();
+        this.#type = type;
+    }
+    select(reference) {
+        return [reference];
+    }
+    decode([value]) {
+        if (value === null)
+            return null;
+        if (!Number.isSafeInteger(value))
+            throw new TypeError(`SQL Server returned ${String(value)} for ${this.#type}`);
+        return Number(value);
+    }
+    cast(parameter) {
+        return `CAST(${parameter} AS ${this.#type})`;
+    }
+}

package/dist/codecs/local-time-codec.d.ts

@@ -0,0 +1,12 @@
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class LocalTimeCodec extends SqlServerCodec<string> {
+    #private;
+    readonly value: {
+        readonly kind: 'local-time';
+        readonly precision: number;
+    };
+    constructor(declared: string, precision: number);
+    select(reference: string): readonly string[];
+    decode([value]: readonly unknown[]): string | null;
+    cast(parameter: string): string;
+}

package/dist/codecs/local-time-codec.js

@@ -0,0 +1,21 @@
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// time: a time of day, which the default style spells with exactly its
+// precision's fraction digits, zeros included.
+export class LocalTimeCodec extends SqlServerCodec {
+    value;
+    #declared;
+    constructor(declared, precision) {
+        super();
+        this.value = { kind: 'local-time', precision };
+        this.#declared = declared;
+    }
+    select(reference) {
+        return [`CONVERT(varchar(16), ${reference})`];
+    }
+    decode([value]) {
+        return value === null ? null : text(value, this.#declared);
+    }
+    cast(parameter) {
+        return `CAST(${parameter} AS ${this.#declared})`;
+    }
+}

package/dist/codecs/local-timestamp-codec.d.ts

@@ -0,0 +1,12 @@
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class LocalTimestampCodec extends SqlServerCodec<string> {
+    #private;
+    readonly value: {
+        readonly kind: 'local-timestamp';
+        readonly precision: number;
+    };
+    constructor(declared: string, precision: number);
+    select(reference: string): readonly string[];
+    decode([value]: readonly unknown[]): string | null;
+    cast(parameter: string): string;
+}

package/dist/codecs/local-timestamp-codec.js

@@ -0,0 +1,25 @@
+import { withFraction } from './fraction.js';
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// datetime2, datetime and smalldatetime: a wall-clock time with no zone, to
+// its precision's fraction digits, which the driver's millisecond Date would
+// round.
+export class LocalTimestampCodec extends SqlServerCodec {
+    value;
+    #declared;
+    constructor(declared, precision) {
+        super();
+        this.value = { kind: 'local-timestamp', precision };
+        this.#declared = declared;
+    }
+    select(reference) {
+        return [`CONVERT(varchar(27), ${reference}, 126)`];
+    }
+    decode([value]) {
+        return value === null
+            ? null
+            : withFraction(text(value, this.#declared), this.value.precision);
+    }
+    cast(parameter) {
+        return `CONVERT(${this.#declared}, ${parameter}, 126)`;
+    }
+}

package/dist/codecs/number-codec.d.ts

@@ -0,0 +1,11 @@
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class NumberCodec extends SqlServerCodec<number> {
+    #private;
+    readonly value: {
+        readonly kind: 'number';
+    };
+    constructor(type: string);
+    select(reference: string): readonly string[];
+    decode([value]: readonly unknown[]): number | null;
+    cast(parameter: string): string;
+}

package/dist/codecs/number-codec.js

@@ -0,0 +1,24 @@
+import { SqlServerCodec } from './sql-server-codec.js';
+// real and float, IEEE values a JavaScript number holds exactly; its shortest
+// spelling reads back as the same value.
+export class NumberCodec extends SqlServerCodec {
+    value = { kind: 'number' };
+    #type;
+    constructor(type) {
+        super();
+        this.#type = type;
+    }
+    select(reference) {
+        return [reference];
+    }
+    decode([value]) {
+        if (value === null)
+            return null;
+        if (typeof value !== 'number')
+            throw new TypeError(`SQL Server returned a ${typeof value} for ${this.#type}`);
+        return value;
+    }
+    cast(parameter) {
+        return `CAST(${parameter} AS ${this.#type})`;
+    }
+}

package/dist/codecs/spatial-codec.d.ts

@@ -0,0 +1,8 @@
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class SpatialCodec extends SqlServerCodec<string> {
+    readonly value: {
+        readonly kind: 'spatial';
+    };
+    select(reference: string): readonly string[];
+    decode([value]: readonly unknown[]): string | null;
+}

package/dist/codecs/spatial-codec.js

@@ -0,0 +1,14 @@
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// geography and geometry as extended well-known text: the SRID, then every
+// coordinate with its Z and M, which plain well-known text drops.
+export class SpatialCodec extends SqlServerCodec {
+    value = { kind: 'spatial' };
+    select(reference) {
+        return [
+            `'SRID=' + CONVERT(varchar(11), ${reference}.STSrid) + ';' + ${reference}.AsTextZM()`,
+        ];
+    }
+    decode([value]) {
+        return value === null ? null : text(value, 'spatial');
+    }
+}

package/dist/codecs/sql-server-codec.d.ts

@@ -0,0 +1,41 @@
+import type { SqlServerValue } from '../values.ts';
+export type ValueKind = {
+    readonly kind: 'text';
+} | {
+    readonly kind: 'integer';
+} | {
+    readonly kind: 'int64';
+} | {
+    readonly kind: 'boolean';
+} | {
+    readonly kind: 'number';
+} | {
+    readonly kind: 'decimal';
+    readonly precision: number;
+    readonly scale: number;
+} | {
+    readonly kind: 'date';
+} | {
+    readonly kind: 'local-timestamp';
+    readonly precision: number;
+} | {
+    readonly kind: 'timestamp';
+    readonly precision: number;
+} | {
+    readonly kind: 'local-time';
+    readonly precision: number;
+} | {
+    readonly kind: 'bytes';
+} | {
+    readonly kind: 'spatial';
+} | {
+    readonly kind: 'variant';
+};
+export declare abstract class SqlServerCodec<Value extends SqlServerValue> {
+    abstract readonly value: ValueKind;
+    abstract select(reference: string): readonly string[];
+    abstract decode(values: readonly unknown[]): Value | null;
+    cast(_parameter: string): string | undefined;
+    position(value: Value): string;
+}
+export declare function text(value: unknown, type: string): string;

package/dist/codecs/sql-server-codec.js

@@ -0,0 +1,21 @@
+// How a read takes one SQL Server type exactly. The driver hands decimal and
+// money over as JavaScript numbers and datetime2 as a millisecond Date, and
+// drops a datetimeoffset's offset, so each codec selects text SQL Server
+// spells exactly, and decodes it into the value's canonical form.
+export class SqlServerCodec {
+    // A key column pages through a table: its value as text, and the SQL that
+    // turns a parameter holding that text back into the column's type, so a
+    // comparison orders as the column sorts. A type that cannot be compared,
+    // such as xml, returns undefined.
+    cast(_parameter) {
+        return undefined;
+    }
+    position(value) {
+        return String(value);
+    }
+}
+export function text(value, type) {
+    if (typeof value !== 'string')
+        throw new TypeError(`SQL Server returned a ${typeof value} for ${type}`);
+    return value;
+}

package/dist/codecs/text-codec.d.ts

@@ -0,0 +1,11 @@
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class TextCodec extends SqlServerCodec<string> {
+    #private;
+    readonly value: {
+        readonly kind: 'text';
+    };
+    constructor(type: string, read: (reference: string) => string, cast?: (parameter: string) => string);
+    select(reference: string): readonly string[];
+    decode([value]: readonly unknown[]): string | null;
+    cast(parameter: string): string | undefined;
+}

package/dist/codecs/text-codec.js

@@ -0,0 +1,24 @@
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// Character types, and the types SQL Server spells as text: uniqueidentifier,
+// xml, hierarchyid and json.
+export class TextCodec extends SqlServerCodec {
+    value = { kind: 'text' };
+    #type;
+    #read;
+    #cast;
+    constructor(type, read, cast) {
+        super();
+        this.#type = type;
+        this.#read = read;
+        this.#cast = cast;
+    }
+    select(reference) {
+        return [this.#read(reference)];
+    }
+    decode([value]) {
+        return value === null ? null : text(value, this.#type);
+    }
+    cast(parameter) {
+        return this.#cast?.(parameter);
+    }
+}

package/dist/codecs/timestamp-codec.d.ts

@@ -0,0 +1,14 @@
+import { OffsetTimestamp } from '../values.ts';
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class TimestampCodec extends SqlServerCodec<OffsetTimestamp> {
+    #private;
+    readonly value: {
+        readonly kind: 'timestamp';
+        readonly precision: number;
+    };
+    constructor(declared: string, precision: number);
+    select(reference: string): readonly string[];
+    decode([instant, offset]: readonly unknown[]): OffsetTimestamp | null;
+    cast(parameter: string): string;
+    position(value: OffsetTimestamp): string;
+}

package/dist/codecs/timestamp-codec.js

@@ -0,0 +1,35 @@
+import { OffsetTimestamp } from '../values.js';
+import { withFraction } from './fraction.js';
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// datetimeoffset: its UTC instant to the column's precision, and the offset
+// it was written with, in minutes. The driver keeps neither the seventh
+// digit nor the offset.
+export class TimestampCodec extends SqlServerCodec {
+    value;
+    #declared;
+    constructor(declared, precision) {
+        super();
+        this.value = { kind: 'timestamp', precision };
+        this.#declared = declared;
+    }
+    select(reference) {
+        return [
+            `CONVERT(varchar(27), CAST(SWITCHOFFSET(${reference}, 0) AS datetime2(${this.value.precision})), 126)`,
+            `DATEPART(TZOFFSET, ${reference})`,
+        ];
+    }
+    decode([instant, offset]) {
+        if (instant === null)
+            return null;
+        if (!Number.isSafeInteger(offset))
+            throw new TypeError(`SQL Server returned offset ${String(offset)}`);
+        return new OffsetTimestamp(`${withFraction(text(instant, this.#declared), this.value.precision)}Z`, Number(offset));
+    }
+    // datetimeoffset values compare by their instant, whatever their offset.
+    cast(parameter) {
+        return `CONVERT(${this.#declared}, ${parameter}, 127)`;
+    }
+    position(value) {
+        return value.instant;
+    }
+}

package/dist/codecs/variant-codec.d.ts

@@ -0,0 +1,9 @@
+import { VariantValue } from '../values.ts';
+import { SqlServerCodec } from './sql-server-codec.ts';
+export declare class VariantCodec extends SqlServerCodec<VariantValue> {
+    readonly value: {
+        readonly kind: 'variant';
+    };
+    select(reference: string): readonly string[];
+    decode([value, type]: readonly unknown[]): VariantValue | null;
+}

package/dist/codecs/variant-codec.js

@@ -0,0 +1,20 @@
+import { VariantValue } from '../values.js';
+import { SqlServerCodec, text } from './sql-server-codec.js';
+// sql_variant: the value as text, by the style that keeps its base type
+// exact (126 for times, 3 for floating point, 1 for bytes in hex), and the
+// base type itself.
+export class VariantCodec extends SqlServerCodec {
+    value = { kind: 'variant' };
+    select(reference) {
+        const type = `SQL_VARIANT_PROPERTY(${reference}, 'BaseType')`;
+        return [
+            `CASE WHEN ${type} IN ('binary', 'varbinary') THEN CONVERT(nvarchar(max), CAST(${reference} AS varbinary(8000)), 1) WHEN ${type} IN ('float', 'real') THEN CONVERT(nvarchar(max), CAST(${reference} AS float), 3) ELSE CONVERT(nvarchar(max), ${reference}, 126) END`,
+            `CONVERT(varchar(128), ${type})`,
+        ];
+    }
+    decode([value, type]) {
+        return value === null
+            ? null
+            : new VariantValue(text(value, 'sql_variant'), text(type, 'sql_variant'));
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class SqlServerUnavailableError extends Error {
+    name: string;
+    constructor(location: string, cause: unknown);
+}
+export declare class SqlServerLoginError extends Error {
+    name: string;
+    constructor(location: string, cause: unknown);
+}
+export declare class SqlServerPermissionError extends Error {
+    name: string;
+    readonly grant: string;
+    constructor(grant: string, cause?: unknown);
+}
+export declare class SqlServerVersionError extends Error {
+    name: string;
+    constructor(location: string, version: number);
+}
+export declare class ChangeHistoryExpiredError extends Error {
+    name: string;
+    constructor(table: string, since: string);
+}

package/dist/errors.js

@@ -0,0 +1,44 @@
+// The server could not be reached: it is down, restarting or failing over,
+// its address is wrong, or the network dropped the connection. A later
+// attempt can succeed.
+export class SqlServerUnavailableError extends Error {
+    name = 'SqlServerUnavailableError';
+    constructor(location, cause) {
+        super(`SQL Server ${location} cannot be reached.`, { cause });
+    }
+}
+// The server answered and refused the login: the credentials are wrong, the
+// login is disabled, or it cannot open the database. Only the user can fix
+// it.
+export class SqlServerLoginError extends Error {
+    name = 'SqlServerLoginError';
+    constructor(location, cause) {
+        super(`SQL Server ${location} refused the login.`, { cause });
+    }
+}
+// The login lacks a permission a read needs. grant names what to give it.
+export class SqlServerPermissionError extends Error {
+    name = 'SqlServerPermissionError';
+    grant;
+    constructor(grant, cause) {
+        super(`SQL Server refused the read; grant the login ${grant}.`, { cause });
+        this.grant = grant;
+    }
+}
+// Reading needs SQL Server 2016 or later (or Azure SQL): the masking and
+// external-table metadata and the text styles the reads rely on start there.
+export class SqlServerVersionError extends Error {
+    name = 'SqlServerVersionError';
+    constructor(location, version) {
+        super(`SQL Server ${location} is version ${version}; reading it needs SQL Server 2016 (13) or later.`);
+    }
+}
+// The saved Change Tracking version is no longer one the table's change
+// history covers: cleanup removed what followed it, the table was truncated,
+// or the database was restored. The table has to be read in full again.
+export class ChangeHistoryExpiredError extends Error {
+    name = 'ChangeHistoryExpiredError';
+    constructor(table, since) {
+        super(`The change history of ${table} no longer covers version ${since}; read the table in full again.`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { type ChangePosition, type SqlServerChange } from './change-set.ts';
+export { ChangeHistoryExpiredError, SqlServerLoginError, SqlServerPermissionError, SqlServerUnavailableError, SqlServerVersionError, } from './errors.ts';
+export { SqlServerColumn } from './sql-server-column.ts';
+export { SqlServerDatabase } from './sql-server-database.ts';
+export { SqlServerRow } from './sql-server-row.ts';
+export { SqlServerSession } from './sql-server-session.ts';
+export { SqlServerTable } from './sql-server-table.ts';
+export { OffsetTimestamp, type SqlServerValue, VariantValue, } from './values.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { ChangeHistoryExpiredError, SqlServerLoginError, SqlServerPermissionError, SqlServerUnavailableError, SqlServerVersionError, } from './errors.js';
+export { SqlServerColumn } from './sql-server-column.js';
+export { SqlServerDatabase } from './sql-server-database.js';
+export { SqlServerRow } from './sql-server-row.js';
+export { SqlServerSession } from './sql-server-session.js';
+export { SqlServerTable } from './sql-server-table.js';
+export { OffsetTimestamp, VariantValue, } from './values.js';

package/dist/quote-name.d.ts

@@ -0,0 +1 @@
+export declare function quoteName(name: string): string;

package/dist/quote-name.js

@@ -0,0 +1,4 @@
+// SQL Server's QUOTENAME: an identifier in brackets, any ] doubled.
+export function quoteName(name) {
+    return `[${name.replaceAll(']', ']]')}]`;
+}

package/dist/sql-server-column.d.ts

@@ -0,0 +1,19 @@
+import type { SqlServerCodec } from './codecs/sql-server-codec.ts';
+import type { SqlServerValue } from './values.ts';
+export declare class SqlServerColumn {
+    readonly name: string;
+    readonly type: string;
+    readonly nullable: boolean;
+    readonly masked: boolean;
+    readonly description: string | null;
+    readonly codec: SqlServerCodec<SqlServerValue>;
+    constructor(column: {
+        name: string;
+        type: string;
+        nullable: boolean;
+        masked: boolean;
+        description: string | null;
+        codec: SqlServerCodec<SqlServerValue>;
+    });
+    get quoted(): string;
+}

package/dist/sql-server-column.js

@@ -0,0 +1,24 @@
+import { quoteName } from './quote-name.js';
+export class SqlServerColumn {
+    name;
+    // The type as the column declares it, such as decimal(19, 4).
+    type;
+    nullable;
+    // Dynamic data masking hides its values from a login without UNMASK.
+    masked;
+    // Its MS_Description extended property.
+    description;
+    codec;
+    constructor(column) {
+        this.name = column.name;
+        this.type = column.type;
+        this.nullable = column.nullable;
+        this.masked = column.masked;
+        this.description = column.description;
+        this.codec = column.codec;
+        Object.freeze(this);
+    }
+    get quoted() {
+        return quoteName(this.name);
+    }
+}

package/dist/sql-server-database.d.ts

@@ -0,0 +1,8 @@
+import { SqlServerSession } from './sql-server-session.ts';
+export declare class SqlServerDatabase {
+    #private;
+    readonly location: string;
+    readonly name: string;
+    constructor(connectionString: string);
+    open(): Promise<SqlServerSession>;
+}

package/dist/sql-server-database.js

@@ -0,0 +1,65 @@
+import sql from 'mssql';
+import { cellNumber } from './cells.js';
+import { SqlServerLoginError, SqlServerUnavailableError, SqlServerVersionError, } from './errors.js';
+import { query } from './sql-server-request.js';
+import { SqlServerSession } from './sql-server-session.js';
+// One database on a SQL Server, named by an ADO.NET connection string
+// (Server=host,port;Database=name;User Id=...;Password=...), the form SQL
+// Server's own tools print.
+export class SqlServerDatabase {
+    // Server and database, without credentials.
+    location;
+    // The database's own name, which stays when the server is reached another
+    // way.
+    name;
+    #config;
+    constructor(connectionString) {
+        const config = sql.ConnectionPool.parseConnectionString(connectionString);
+        // Without a database the login's default one opens, which the caller
+        // did not choose.
+        if (!config.server || !config.database)
+            throw new TypeError('A SQL Server connection string must name its Server and its Database');
+        const instance = config.options?.instanceName;
+        this.location = `${config.server}${instance ? `\\${instance}` : ''}:${config.port ?? 1433}/${config.database}`;
+        this.name = config.database;
+        // A read streams a whole table, so no time limit fits every table.
+        this.#config = { ...config, requestTimeout: 0, pool: { min: 0, max: 4 } };
+        Object.freeze(this);
+    }
+    async open() {
+        const pool = new sql.ConnectionPool(this.#config);
+        try {
+            await pool.connect();
+        }
+        catch (cause) {
+            throw refused(cause)
+                ? new SqlServerLoginError(this.location, cause)
+                : new SqlServerUnavailableError(this.location, cause);
+        }
+        try {
+            const [[edition, major, snapshot] = []] = await query(pool.request(), `SELECT CAST(SERVERPROPERTY('EngineEdition') AS int), CAST(SERVERPROPERTY('ProductMajorVersion') AS int), CAST(snapshot_isolation_state AS int) FROM sys.databases WHERE database_id = DB_ID()`);
+            const version = cellNumber(major, 'ProductMajorVersion');
+            // Azure SQL Database (5) and Managed Instance (8) report version 12
+            // but run the current engine.
+            if (edition !== 5 && edition !== 8 && version < 13)
+                throw new SqlServerVersionError(this.location, version);
+            return new SqlServerSession(pool, this.location, snapshot === 1);
+        }
+        catch (error) {
+            await pool.close();
+            throw error;
+        }
+    }
+}
+// Whether the server answered and refused the login. tedious marks the login
+// errors SQL Server raises while it fails over or is busy (4060, 10928,
+// 10929, 40197, 40501, 40613) as transient, and tries them again before it
+// gives up; those mean the server cannot be reached now.
+function refused(error) {
+    if (!(error instanceof sql.ConnectionError) || error.code !== 'ELOGIN')
+        return false;
+    const { originalError } = error;
+    return !(originalError !== undefined &&
+        'isTransient' in originalError &&
+        originalError.isTransient === true);
+}

package/dist/sql-server-request.d.ts

@@ -0,0 +1,3 @@
+import sql from 'mssql';
+export declare function query(request: sql.Request, text: string, parameters?: readonly string[]): Promise<unknown[][]>;
+export declare function stream(request: sql.Request, text: string, parameters?: readonly string[]): AsyncGenerator<unknown[]>;

package/dist/sql-server-request.js

@@ -0,0 +1,71 @@
+import sql from 'mssql';
+import { SqlServerPermissionError } from './errors.js';
+// Every parameter travels as text and the statement casts it, so a value
+// keeps the exact spelling a read gave it, whatever the driver would make of
+// a number or a Date.
+function bind(request, parameters) {
+    for (const [index, value] of parameters.entries())
+        request.input(`p${index}`, sql.NVarChar(sql.MAX), value);
+}
+// A refused read names the grant it needs (errors 229 and 230).
+function readError(error) {
+    if (!(error instanceof sql.RequestError))
+        return error;
+    if (error.number !== 229 && error.number !== 230)
+        return error;
+    const denied = /^The (.+) permission was denied on the (?:column '(.+)' of the )?object '(.+)', database '.+', schema '(.+)'\.$/.exec(error.message);
+    if (denied === null)
+        return error;
+    const [, permission, column, object, schema] = denied;
+    const on = `[${schema}].[${object}]${column === undefined ? '' : ` ([${column}])`}`;
+    return new SqlServerPermissionError(`${permission} ON ${on}`, error);
+}
+function asRow(row) {
+    if (!Array.isArray(row))
+        throw new TypeError('SQL Server returned a row that is not a list');
+    return row;
+}
+// Every row of one statement, each as the values it selects in order.
+export async function query(request, text, parameters = []) {
+    request.arrayRowMode = true;
+    bind(request, parameters);
+    try {
+        const { recordset } = await request.query(text);
+        return recordset.map(asRow);
+    }
+    catch (error) {
+        throw readError(error);
+    }
+}
+// The rows of one statement as the driver receives them; stopping early
+// cancels the statement so its connection returns to the pool.
+export async function* stream(request, text, parameters = []) {
+    request.arrayRowMode = true;
+    bind(request, parameters);
+    const rows = request.toReadableStream();
+    // The driver ends every statement, cancelled or failed too, with done.
+    const ended = new Promise((resolve) => request.once('done', () => resolve()));
+    let finished = false;
+    void ended.then(() => {
+        finished = true;
+    });
+    // In stream mode the promise always resolves; failures arrive on rows.
+    void request.query(text);
+    try {
+        for await (const row of rows) {
+            yield asRow(row);
+        }
+    }
+    catch (error) {
+        throw readError(error);
+    }
+    finally {
+        // A reader that stops early cancels the statement, and waits for it to
+        // end: until then the connection, or a transaction on it, is not free.
+        if (!finished) {
+            rows.on('error', () => { });
+            request.cancel();
+            await ended;
+        }
+    }
+}

package/dist/sql-server-row.d.ts

@@ -0,0 +1,10 @@
+import type { SqlServerColumn } from './sql-server-column.ts';
+import type { SqlServerTable } from './sql-server-table.ts';
+import type { SqlServerValue } from './values.ts';
+export declare class SqlServerRow {
+    readonly table: SqlServerTable;
+    readonly values: readonly SqlServerValue[];
+    constructor(table: SqlServerTable, values: readonly SqlServerValue[]);
+    value(column: SqlServerColumn): SqlServerValue;
+    get position(): readonly string[];
+}