drizzle-databend 0.1.11 → 0.1.12

package/src/databend-core/view.ts

@@ -0,0 +1,127 @@
+import { entityKind, is } from 'drizzle-orm/entity';
+import { SelectionProxyHandler } from 'drizzle-orm/selection-proxy';
+import { getTableColumns } from 'drizzle-orm/utils';
+import { QueryBuilder } from './query-builders/query-builder.ts';
+import { databendTable } from './table.ts';
+import { DatabendViewBase } from './view-base.ts';
+import { DatabendViewConfig } from './view-common.ts';
+
+class DefaultViewBuilderCore {
+  static readonly [entityKind]: string = 'DatabendDefaultViewBuilderCore';
+  config: any = {};
+
+  constructor(protected name: string, protected schema?: string) {}
+
+  with(config: any) {
+    this.config.with = config;
+    return this;
+  }
+}
+
+export class ViewBuilder extends DefaultViewBuilderCore {
+  static override readonly [entityKind]: string = 'DatabendViewBuilder';
+
+  as(qb: any) {
+    if (typeof qb === 'function') {
+      qb = qb(new QueryBuilder());
+    }
+    const selectionProxy = new SelectionProxyHandler({
+      alias: this.name,
+      sqlBehavior: 'error',
+      sqlAliasedBehavior: 'alias',
+      replaceOriginalName: true,
+    });
+    const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+    return new Proxy(
+      new DatabendView({
+        databendConfig: this.config,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: aliasedSelection,
+          query: qb.getSQL().inlineParams(),
+        },
+      }),
+      selectionProxy
+    );
+  }
+}
+
+export class ManualViewBuilder extends DefaultViewBuilderCore {
+  static override readonly [entityKind]: string = 'DatabendManualViewBuilder';
+  columns: any;
+
+  constructor(name: string, columns: any, schema?: string) {
+    super(name, schema);
+    this.columns = getTableColumns(databendTable(name, columns));
+  }
+
+  existing() {
+    return new Proxy(
+      new DatabendView({
+        databendConfig: undefined,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: this.columns,
+          query: undefined,
+        },
+      }),
+      new SelectionProxyHandler({
+        alias: this.name,
+        sqlBehavior: 'error',
+        sqlAliasedBehavior: 'alias',
+        replaceOriginalName: true,
+      })
+    );
+  }
+
+  as(query: any) {
+    return new Proxy(
+      new DatabendView({
+        databendConfig: this.config,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: this.columns,
+          query: query.inlineParams(),
+        },
+      }),
+      new SelectionProxyHandler({
+        alias: this.name,
+        sqlBehavior: 'error',
+        sqlAliasedBehavior: 'alias',
+        replaceOriginalName: true,
+      })
+    );
+  }
+}
+
+export class DatabendView extends DatabendViewBase {
+  static override readonly [entityKind]: string = 'DatabendView';
+  [DatabendViewConfig]: any;
+
+  constructor({ databendConfig, config }: any) {
+    super(config);
+    if (databendConfig) {
+      this[DatabendViewConfig] = {
+        with: databendConfig.with,
+      };
+    }
+  }
+}
+
+function databendViewWithSchema(name: string, selection?: any, schema?: string) {
+  if (selection) {
+    return new ManualViewBuilder(name, selection, schema);
+  }
+  return new ViewBuilder(name, schema);
+}
+
+export function databendView(name: string, columns?: any) {
+  return databendViewWithSchema(name, columns, undefined);
+}
+
+export function isDatabendView(obj: unknown): obj is DatabendView {
+  return is(obj, DatabendView);
+}

package/src/dialect.ts

@@ -1,119 +1,3 @@
-import {
-  type DriverValueEncoder,
-  type QueryTypingsValue,
-  sql,
-} from 'drizzle-orm';
-import { entityKind, is } from 'drizzle-orm/entity';
-import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
-import {
-  PgBigInt53,
-  PgBigInt64,
-  PgDate,
-  PgDateString,
-  PgDialect,
-  PgDoublePrecision,
-  PgInteger,
-  PgNumeric,
-  PgReal,
-  type PgSession,
-  PgSmallInt,
-  PgTime,
-  PgTimestamp,
-  PgTimestampString,
-  PgUUID,
-} from 'drizzle-orm/pg-core';
-
-export class DatabendDialect extends PgDialect {
-  static readonly [entityKind]: string = 'DatabendPgDialect';
-
-  // Databend does not support savepoints
-  areSavepointsUnsupported(): boolean {
-    return true;
-  }
-
-  override async migrate(
-    migrations: MigrationMeta[],
-    session: PgSession,
-    config: MigrationConfig | string
-  ): Promise<void> {
-    const migrationConfig: MigrationConfig =
-      typeof config === 'string' ? { migrationsFolder: config } : config;
-
-    const migrationsSchema = migrationConfig.migrationsSchema ?? 'default';
-    const migrationsTable =
-      migrationConfig.migrationsTable ?? '__drizzle_migrations';
-
-    // Databend has no sequences. Use explicit ID via COALESCE(MAX(id), 0) + 1.
-    const migrationTableCreate = sql`
-      CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(
-        migrationsTable
-      )} (
-        id INT NOT NULL,
-        hash VARCHAR NOT NULL,
-        created_at BIGINT
-      )
-    `;
-
-    await session.execute(migrationTableCreate);
-
-    const dbMigrations = await session.all<{
-      id: number;
-      hash: string;
-      created_at: string;
-    }>(
-      sql`SELECT id, hash, created_at FROM ${sql.identifier(
-        migrationsSchema
-      )}.${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
-    );
-
-    const lastDbMigration = dbMigrations[0];
-
-    await session.transaction(async (tx) => {
-      for await (const migration of migrations) {
-        if (
-          !lastDbMigration ||
-          Number(lastDbMigration.created_at) < migration.folderMillis
-        ) {
-          for (const stmt of migration.sql) {
-            await tx.execute(sql.raw(stmt));
-          }
-
-          await tx.execute(
-            sql`INSERT INTO ${sql.identifier(
-              migrationsSchema
-            )}.${sql.identifier(migrationsTable)} (id, hash, created_at)
-              VALUES (
-                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql.identifier(
-                  migrationsSchema
-                )}.${sql.identifier(migrationsTable)}),
-                ${migration.hash},
-                ${migration.folderMillis}
-              )`
-          );
-        }
-      }
-    });
-  }
-
-  override prepareTyping(
-    encoder: DriverValueEncoder<unknown, unknown>
-  ): QueryTypingsValue {
-    if (
-      is(encoder, PgNumeric) || is(encoder, PgInteger) || is(encoder, PgSmallInt)
-      || is(encoder, PgReal) || is(encoder, PgDoublePrecision)
-      || is(encoder, PgBigInt53) || is(encoder, PgBigInt64)
-    ) {
-      return 'decimal';
-    } else if (is(encoder, PgTime)) {
-      return 'time';
-    } else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
-      return 'timestamp';
-    } else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
-      return 'date';
-    } else if (is(encoder, PgUUID)) {
-      return 'uuid';
-    } else {
-      return 'none';
-    }
-  }
-}
+// Re-export DatabendDialect from the core module.
+// All dialect logic now lives in databend-core/dialect.ts.
+export { DatabendDialect } from './databend-core/dialect.ts';

package/src/driver.ts

@@ -3,7 +3,6 @@ import { Client } from 'databend-driver';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { DefaultLogger } from 'drizzle-orm/logger';
-import { PgDatabase } from 'drizzle-orm/pg-core/db';
 import {
   createTableRelationsHelpers,
   type ExtractTablesWithRelations,
@@ -13,14 +12,14 @@ import {
 } from 'drizzle-orm/relations';
 import type { DrizzleConfig } from 'drizzle-orm/utils';
 import { closeClientConnection, isPool } from './client.ts';
-import { DatabendDialect } from './dialect.ts';
+import { DatabendDatabase as DatabendDatabaseBase } from './databend-core/db.ts';
+import { DatabendDialect } from './databend-core/dialect.ts';
 import {
   createDatabendConnectionPool,
   type DatabendPoolConfig,
 } from './pool.ts';
 import type {
   DatabendClientLike,
-  DatabendQueryResultHKT,
   DatabendTransaction,
 } from './session.ts';
 import { DatabendSession } from './session.ts';
@@ -230,8 +229,8 @@ export class DatabendDatabase<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
   TSchema extends TablesRelationalConfig =
     ExtractTablesWithRelations<TFullSchema>,
-> extends PgDatabase<DatabendQueryResultHKT, TFullSchema, TSchema> {
-  static readonly [entityKind]: string = 'DatabendDatabase';
+> extends DatabendDatabaseBase {
+  static override readonly [entityKind]: string = 'DatabendDatabase';
 
   /** The underlying connection or pool */
   readonly $client: DatabendClientLike;
@@ -240,8 +239,8 @@ export class DatabendDatabase<
   readonly $databendClient?: Client;
 
   constructor(
-    readonly dialect: DatabendDialect,
-    readonly session: DatabendSession<TFullSchema, TSchema>,
+    override readonly dialect: DatabendDialect,
+    override readonly session: DatabendSession<TFullSchema, TSchema>,
     schema: RelationalSchemaConfig<TSchema> | undefined,
     client: DatabendClientLike,
     databendClient?: Client

package/src/index.ts

@@ -1,5 +1,32 @@
 export * from './client.ts';
 export * from './columns.ts';
+export { alias } from './databend-core/alias.ts';
+export { DatabendColumn, DatabendColumnBuilder } from './databend-core/columns/common.ts';
+export {
+  bigint,
+  binary,
+  bitmap,
+  boolean,
+  date,
+  decimal,
+  doublePrecision,
+  float,
+  integer,
+  real,
+  smallint,
+  text,
+  timestamp,
+  tinyint,
+  varchar,
+  variant,
+} from './databend-core/columns/index.ts';
+export { DatabendDialect } from './databend-core/dialect.ts';
+export { index, uniqueIndex } from './databend-core/indexes.ts';
+export { primaryKey } from './databend-core/primary-keys.ts';
+export { databendSchema } from './databend-core/schema.ts';
+export { DatabendTable, databendTable, databendTableCreator } from './databend-core/table.ts';
+export { getTableConfig } from './databend-core/utils.ts';
+export { databendView } from './databend-core/view.ts';
 export * from './driver.ts';
 export * from './migrator.ts';
 export * from './pool.ts';

package/src/migrator.ts

@@ -1,6 +1,5 @@
 import type { MigrationConfig } from 'drizzle-orm/migrator';
 import { readMigrationFiles } from 'drizzle-orm/migrator';
-import type { PgSession } from 'drizzle-orm/pg-core/session';
 import type { DatabendDatabase } from './driver.ts';
 
 export type DatabendMigrationConfig = MigrationConfig | string;
@@ -16,7 +15,7 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 
   await db.dialect.migrate(
     migrations,
-    db.session as unknown as PgSession,
+    db.session,
     migrationConfig
   );
 }

package/src/session.ts

@@ -3,14 +3,6 @@ import { entityKind } from 'drizzle-orm/entity';
 import { TransactionRollbackError } from 'drizzle-orm/errors';
 import type { Logger } from 'drizzle-orm/logger';
 import { NoopLogger } from 'drizzle-orm/logger';
-import { PgTransaction } from 'drizzle-orm/pg-core';
-import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/select.types';
-import type {
-  PgQueryResultHKT,
-  PgTransactionConfig,
-  PreparedQueryConfig,
-} from 'drizzle-orm/pg-core/session';
-import { PgPreparedQuery, PgSession } from 'drizzle-orm/pg-core/session';
 import type {
   RelationalSchemaConfig,
   TablesRelationalConfig,
@@ -27,25 +19,33 @@ import {
   executeOnClient,
   isPool,
 } from './client.ts';
-import type { DatabendDialect } from './dialect.ts';
+import type { DatabendDialect } from './databend-core/dialect.ts';
+import {
+  DatabendPreparedQuery as DatabendPreparedQueryBase,
+  DatabendSession as DatabendSessionBase,
+  DatabendTransaction as DatabendTransactionBase,
+} from './databend-core/session.ts';
 import { mapResultRow } from './sql/result-mapper.ts';
 
 export type { DatabendClientLike, RowData } from './client.ts';
 
-export class DatabendPreparedQuery<
-  T extends PreparedQueryConfig,
-> extends PgPreparedQuery<T> {
-  static readonly [entityKind]: string = 'DatabendPreparedQuery';
+export interface DatabendQueryResultHKT {
+  readonly row: RowData;
+  type: GenericTableData<Assume<this['row'], RowData>>;
+}
+
+export class DatabendPreparedQuery extends DatabendPreparedQueryBase {
+  static override readonly [entityKind]: string = 'DatabendPreparedQuery';
 
   constructor(
     private client: DatabendClientLike,
     private queryString: string,
     private params: unknown[],
     private logger: Logger,
-    private fields: SelectedFieldsOrdered | undefined,
+    private fields: any[] | undefined,
     private _isResponseInArrayMode: boolean,
     private customResultMapper:
-      | ((rows: unknown[][]) => T['execute'])
+      | ((rows: unknown[][]) => any)
       | undefined,
     private typings?: QueryTypingsValue[]
   ) {
@@ -54,7 +54,7 @@ export class DatabendPreparedQuery<
 
   async execute(
     placeholderValues: Record<string, unknown> | undefined = {}
-  ): Promise<T['execute']> {
+  ): Promise<any> {
     const params = fillPlaceholders(this.params, placeholderValues);
     this.logger.logQuery(this.queryString, params);
 
@@ -70,24 +70,24 @@ export class DatabendPreparedQuery<
       );
 
       if (rows.length === 0) {
-        return [] as T['execute'];
+        return [];
       }
 
       return customResultMapper
         ? customResultMapper(rows)
         : rows.map((row) =>
-            mapResultRow<T['execute']>(fields, row, joinsNotNullableMap)
+            mapResultRow(fields, row, joinsNotNullableMap)
           );
     }
 
     const rows = await executeOnClient(this.client, this.queryString, params, typings);
 
-    return rows as T['execute'];
+    return rows;
   }
 
   all(
     placeholderValues: Record<string, unknown> | undefined = {}
-  ): Promise<T['all']> {
+  ): Promise<any> {
     return this.execute(placeholderValues);
   }
 
@@ -103,10 +103,10 @@ export interface DatabendSessionOptions {
 export class DatabendSession<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
   TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends PgSession<DatabendQueryResultHKT, TFullSchema, TSchema> {
-  static readonly [entityKind]: string = 'DatabendSession';
+> extends DatabendSessionBase {
+  static override readonly [entityKind]: string = 'DatabendSession';
 
-  protected override dialect: DatabendDialect;
+  override dialect: DatabendDialect;
   private logger: Logger;
   private rollbackOnly = false;
 
@@ -121,13 +121,13 @@ export class DatabendSession<
     this.logger = options.logger ?? new NoopLogger();
   }
 
-  prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
+  override prepareQuery(
     query: Query,
-    fields: SelectedFieldsOrdered | undefined,
+    fields: any[] | undefined,
     name: string | undefined,
     isResponseInArrayMode: boolean,
-    customResultMapper?: (rows: unknown[][]) => T['execute']
-  ): PgPreparedQuery<T> {
+    customResultMapper?: (rows: unknown[][]) => any
+  ): DatabendPreparedQuery {
     void name;
     return new DatabendPreparedQuery(
       this.client,
@@ -143,7 +143,7 @@ export class DatabendSession<
 
   override async transaction<T>(
     transaction: (tx: DatabendTransaction<TFullSchema, TSchema>) => Promise<T>,
-    config?: PgTransactionConfig
+    config?: DatabendTransactionConfig
   ): Promise<T> {
     let pinnedConnection: Connection | undefined;
     let pool: DatabendConnectionPool | undefined;
@@ -203,19 +203,10 @@ export class DatabendSession<
   }
 }
 
-type DatabendTransactionInternals<
-  TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = Record<string, never>,
-> = {
-  dialect: DatabendDialect;
-  session: DatabendSession<TFullSchema, TSchema>;
-};
-
-type DatabendTransactionWithInternals<
-  TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = Record<string, never>,
-> = DatabendTransactionInternals<TFullSchema, TSchema> &
-  DatabendTransaction<TFullSchema, TSchema>;
+export interface DatabendTransactionConfig {
+  isolationLevel?: string;
+  accessMode?: string;
+}
 
 const VALID_TRANSACTION_ISOLATION_LEVELS = new Set<string>([
   'read uncommitted',
@@ -232,14 +223,16 @@ const VALID_TRANSACTION_ACCESS_MODES = new Set<string>([
 export class DatabendTransaction<
   TFullSchema extends Record<string, unknown>,
   TSchema extends TablesRelationalConfig,
-> extends PgTransaction<DatabendQueryResultHKT, TFullSchema, TSchema> {
-  static readonly [entityKind]: string = 'DatabendTransaction';
+> extends DatabendTransactionBase {
+  static override readonly [entityKind]: string = 'DatabendTransaction';
+
+  declare schema: any;
 
-  rollback(): never {
+  override rollback(): never {
     throw new TransactionRollbackError();
   }
 
-  getTransactionConfigSQL(config: PgTransactionConfig): SQL {
+  getTransactionConfigSQL(config: DatabendTransactionConfig): SQL {
     if (
       config.isolationLevel &&
       !VALID_TRANSACTION_ISOLATION_LEVELS.has(config.isolationLevel)
@@ -272,9 +265,8 @@ export class DatabendTransaction<
     return sql.raw(chunks.join(' '));
   }
 
-  setTransaction(config: PgTransactionConfig): Promise<void> {
-    type Tx = DatabendTransactionWithInternals<TFullSchema, TSchema>;
-    return (this as unknown as Tx).session.execute(
+  setTransaction(config: DatabendTransactionConfig): Promise<void> {
+    return (this as any).session.execute(
       sql`SET TRANSACTION ${this.getTransactionConfigSQL(config)}`
     );
   }
@@ -283,8 +275,7 @@ export class DatabendTransaction<
     transaction: (tx: DatabendTransaction<TFullSchema, TSchema>) => Promise<T>
   ): Promise<T> {
     // Databend does not support savepoints. Use rollback-only fallback.
-    type Tx = DatabendTransactionWithInternals<TFullSchema, TSchema>;
-    const internals = this as unknown as Tx;
+    const internals = this as any;
 
     const nestedTx = new DatabendTransaction<TFullSchema, TSchema>(
       internals.dialect,
@@ -294,9 +285,7 @@ export class DatabendTransaction<
     );
 
     return transaction(nestedTx).catch((error) => {
-      (
-        internals.session as DatabendSession<TFullSchema, TSchema>
-      ).markRollbackOnly();
+      (internals.session as DatabendSession<TFullSchema, TSchema>).markRollbackOnly();
       throw error;
     });
   }
@@ -305,7 +294,3 @@ export class DatabendTransaction<
 export type GenericRowData<T extends RowData = RowData> = T;
 
 export type GenericTableData<T = RowData> = T[];
-
-export interface DatabendQueryResultHKT extends PgQueryResultHKT {
-  type: GenericTableData<Assume<this['row'], RowData>>;
-}

package/src/sql/result-mapper.ts

@@ -7,14 +7,9 @@ import {
   type SelectedFieldsOrdered,
   SQL,
 } from 'drizzle-orm';
-import {
-  PgCustomColumn,
-  PgDate,
-  PgDateString,
-  PgTime,
-  PgTimestamp,
-  PgTimestampString,
-} from 'drizzle-orm/pg-core';
+import { DatabendCustomColumn } from '../databend-core/columns/custom.ts';
+import { DatabendDate } from '../databend-core/columns/date.ts';
+import { DatabendTimestamp } from '../databend-core/columns/timestamp.ts';
 
 type SQLInternal<T = unknown> = SQL<T> & {
   decoder: DriverValueDecoder<T, any>;
@@ -33,25 +28,21 @@ function toDecoderInput<TDecoder extends DriverValueDecoder<unknown, unknown>>(
 
 export function normalizeTimestampString(
   value: unknown,
-  withTimezone: boolean
+  _withTimezone: boolean
 ): string | unknown {
   if (value instanceof Date) {
     const iso = value.toISOString().replace('T', ' ');
-    return withTimezone ? iso.replace('Z', '+00') : iso.replace('Z', '');
+    return iso.replace('Z', '');
   }
   if (typeof value === 'string') {
-    const normalized = value.replace('T', ' ');
-    if (withTimezone) {
-      return normalized.includes('+') ? normalized : `${normalized}+00`;
-    }
-    return normalized.replace(/\+00$/, '');
+    return value.replace('T', ' ');
   }
   return value;
 }
 
 export function normalizeTimestamp(
   value: unknown,
-  withTimezone: boolean
+  _withTimezone: boolean
 ): Date | unknown {
   if (value instanceof Date) {
     return value;
@@ -60,7 +51,7 @@ export function normalizeTimestamp(
     const hasOffset =
       value.endsWith('Z') || /[+-]\d{2}:?\d{2}$/.test(value.trim());
     const spaced = value.replace(' ', 'T');
-    const normalized = withTimezone || hasOffset ? spaced : `${spaced}+00`;
+    const normalized = hasOffset ? spaced : `${spaced}Z`;
     return new Date(normalized);
   }
   return value;
@@ -86,57 +77,24 @@ export function normalizeDateValue(value: unknown): Date | unknown {
   return value;
 }
 
-export function normalizeTime(value: unknown): string | unknown {
-  if (typeof value === 'bigint') {
-    const totalMillis = Number(value) / 1000;
-    const date = new Date(totalMillis);
-    return date.toISOString().split('T')[1]!.replace('Z', '');
-  }
-  if (value instanceof Date) {
-    return value.toISOString().split('T')[1]!.replace('Z', '');
-  }
-  return value;
-}
-
 function mapDriverValue(
   decoder: DriverValueDecoder<unknown, unknown>,
   rawValue: unknown
 ): unknown {
-  if (is(decoder, PgTimestampString)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(
-        decoder,
-        normalizeTimestampString(rawValue, decoder.withTimezone)
-      )
-    );
-  }
-
-  if (is(decoder, PgTimestamp)) {
-    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
+  if (is(decoder, DatabendTimestamp)) {
+    const normalized = normalizeTimestamp(rawValue, false);
     if (normalized instanceof Date) {
       return normalized;
     }
     return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
   }
 
-  if (is(decoder, PgDateString)) {
+  if (is(decoder, DatabendDate)) {
     return decoder.mapFromDriverValue(
       toDecoderInput(decoder, normalizeDateString(rawValue))
     );
   }
 
-  if (is(decoder, PgDate)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(decoder, normalizeDateValue(rawValue))
-    );
-  }
-
-  if (is(decoder, PgTime)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(decoder, normalizeTime(rawValue))
-    );
-  }
-
   return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
 }
 
@@ -157,7 +115,7 @@ export function mapResultRow<TResult>(
       } else {
         const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
 
-        if (is(col, PgCustomColumn)) {
+        if (is(col, DatabendCustomColumn)) {
           decoder = col;
         } else {
           decoder = (field.sql as SQLInternal).decoder;