@duckdbfan/drizzle-duckdb 0.0.6 → 0.0.7

package/dist/columns.d.ts

@@ -1 +1,52 @@
+type IntColType = 'SMALLINT' | 'INTEGER' | 'BIGINT' | 'HUGEINT' | 'USMALLINT' | 'UINTEGER' | 'UBIGINT' | 'UHUGEINT' | 'INT' | 'INT16' | 'INT32' | 'INT64' | 'INT128' | 'LONG' | 'VARINT';
+type FloatColType = 'FLOAT' | 'DOUBLE';
+type StringColType = 'STRING' | 'VARCHAR' | 'TEXT';
+type BoolColType = 'BOOLEAN' | 'BOOL';
+type BlobColType = 'BLOB' | 'BYTEA' | 'VARBINARY';
+type DateColType = 'DATE' | 'TIME' | 'TIMETZ' | 'TIMESTAMP' | 'DATETIME' | 'TIMESTAMPTZ' | 'TIMESTAMP_MS' | 'TIMESTAMP_S';
+type AnyColType = IntColType | FloatColType | StringColType | BoolColType | DateColType | BlobColType;
+type ListColType = `${AnyColType}[]`;
+type ArrayColType = `${AnyColType}[${number}]`;
+export declare const duckDbMap: <TData extends Record<string, any>>(name: string, valueType: AnyColType | ListColType | ArrayColType) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: TData;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare const duckDbStruct: <TData extends Record<string, any>>(name: string, schema: Record<string, AnyColType | ListColType | ArrayColType>) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: TData;
+    driverParam: string;
+    enumValues: undefined;
+}>;
+export declare const duckDbBlob: {
+    (): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer;
+        driverParam: unknown;
+        enumValues: undefined;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer;
+        driverParam: unknown;
+        enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig?: unknown): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: TName;
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Buffer;
+        driverParam: unknown;
+        enumValues: undefined;
+    }>;
+};
 export {};

package/dist/index.mjs

@@ -25,6 +25,9 @@ import {
   getTableName,
   sql
 } from "drizzle-orm";
+import {
+  PgCustomColumn
+} from "drizzle-orm/pg-core";
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce((result2, { path, field }, columnIndex) => {
@@ -34,7 +37,12 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
     } else if (is(field, SQL)) {
       decoder = field.decoder;
     } else {
-      decoder = field.sql.decoder;
+      const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+      if (is(col, PgCustomColumn)) {
+        decoder = col;
+      } else {
+        decoder = field.sql.decoder;
+      }
     }
     let node = result2;
     for (const [pathChunkIndex, pathChunk] of path.entries()) {
@@ -418,6 +426,70 @@ class DuckDBSelectBuilder extends PgSelectBuilder {
     });
   }
 }
+// src/columns.ts
+import { sql as sql5 } from "drizzle-orm";
+import { customType } from "drizzle-orm/pg-core";
+var duckDbMap = (name, valueType) => customType({
+  dataType() {
+    console.log("dataType");
+    return `MAP (STRING, ${valueType})`;
+  },
+  toDriver(value) {
+    console.log("toDriver");
+    const valueFormatter = (value2) => {
+      if (["STRING", "TEXT", "VARCHAR"].includes(valueType)) {
+        return `'${value2}'`;
+      }
+      return JSON.stringify(value2);
+    };
+    const values = Object.entries(value).map(([key, value2]) => {
+      return sql5.raw(`'${key}': ${valueFormatter(value2)}`);
+    });
+    const sqlChunks = [];
+    for (const value2 of values) {
+      sqlChunks.push(value2);
+    }
+    return sql5`MAP {${sql5.join(sqlChunks, sql5.raw(", "))}}`;
+  },
+  fromDriver(value) {
+    console.log("fromDriver");
+    const replacedValue = value.replaceAll(/(?:^{)?([^=]+?)=(.+)(?:}$)?/g, '"$1":"$2"');
+    const formattedValue = `{${replacedValue}}`;
+    const valueObj = JSON.parse(formattedValue);
+    return Object.fromEntries(Object.entries(valueObj).map(([key, value2]) => {
+      return [key, JSON.parse(value2)];
+    }));
+  }
+})(name);
+var duckDbStruct = (name, schema) => customType({
+  dataType() {
+    const fields = Object.entries(schema).map(([key, type]) => `${key} ${type}`);
+    return `STRUCT (${fields.join(", ")})`;
+  },
+  toDriver(value) {
+    const valueFormatter = (value2) => JSON.stringify(value2).replaceAll(/(?<!\\)"/g, "'");
+    const values = Object.entries(value).map(([key, value2]) => {
+      return sql5.raw(`'${key}': ${valueFormatter(value2)}`);
+    });
+    const sqlChunks = [];
+    for (const value2 of values) {
+      sqlChunks.push(value2);
+    }
+    return sql5`(SELECT {${sql5.join(sqlChunks, sql5.raw(", "))}})`;
+  },
+  fromDriver(value) {
+    return value;
+  }
+})(name);
+var duckDbBlob = customType({
+  dataType() {
+    return "BLOB";
+  },
+  toDriver(value) {
+    const hexString = value.toString("hex");
+    return sql5`from_hex(${hexString})`;
+  }
+});
 // src/migrator.ts
 import { readMigrationFiles } from "drizzle-orm/migrator";
 async function migrate(db, config) {
@@ -426,6 +498,9 @@ async function migrate(db, config) {
 }
 export {
   migrate,
+  duckDbStruct,
+  duckDbMap,
+  duckDbBlob,
   drizzle,
   DuckDBTransaction,
   DuckDBSession,

package/package.json

@@ -3,7 +3,7 @@
   "module": "index.ts",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "A drizzle ORM client for use with DuckDB. Based on drizzle's Postgres client.",
   "type": "module",
   "scripts": {

package/src/columns.ts

@@ -1 +1,155 @@
-export {}
+import { sql, type SQL } from 'drizzle-orm';
+import { customType } from 'drizzle-orm/pg-core';
+
+type IntColType =
+  | 'SMALLINT'
+  | 'INTEGER'
+  | 'BIGINT'
+  | 'HUGEINT'
+  | 'USMALLINT'
+  | 'UINTEGER'
+  | 'UBIGINT'
+  | 'UHUGEINT'
+  | 'INT'
+  | 'INT16'
+  | 'INT32'
+  | 'INT64'
+  | 'INT128'
+  | 'LONG'
+  | 'VARINT';
+
+type FloatColType = 'FLOAT' | 'DOUBLE';
+
+type StringColType = 'STRING' | 'VARCHAR' | 'TEXT';
+
+type BoolColType = 'BOOLEAN' | 'BOOL';
+
+type BlobColType = 'BLOB' | 'BYTEA' | 'VARBINARY';
+
+type DateColType =
+  | 'DATE'
+  | 'TIME'
+  | 'TIMETZ'
+  | 'TIMESTAMP'
+  | 'DATETIME'
+  | 'TIMESTAMPTZ'
+  | 'TIMESTAMP_MS'
+  | 'TIMESTAMP_S';
+
+type AnyColType =
+  | IntColType
+  | FloatColType
+  | StringColType
+  | BoolColType
+  | DateColType
+  | BlobColType;
+
+type ListColType = `${AnyColType}[]`;
+type ArrayColType = `${AnyColType}[${number}]`;
+/**
+ * @example
+ * const structColType: StructColType = 'STRUCT (name: STRING, age: INT)';
+ */
+type StructColType = `STRUCT (${string})`;
+
+export const duckDbMap = <TData extends Record<string, any>>(
+  name: string,
+  valueType: AnyColType | ListColType | ArrayColType
+) =>
+  customType<{ data: TData; driverData: string }>({
+    dataType() {
+      console.log('dataType');
+      return `MAP (STRING, ${valueType})`;
+    },
+    toDriver(value: TData) {
+      console.log('toDriver');
+      // todo: more sophisticated encoding based on data type
+      const valueFormatter = (value: any) => {
+        if (['STRING', 'TEXT', 'VARCHAR'].includes(valueType)) {
+          return `'${value}'`;
+        }
+
+        return JSON.stringify(value);
+      };
+
+      const values = Object.entries(value).map(([key, value]) => {
+        return sql.raw(`'${key}': ${valueFormatter(value)}`);
+      });
+
+      const sqlChunks: SQL[] = [];
+
+      for (const value of values) {
+        sqlChunks.push(value);
+      }
+
+      return sql`MAP {${sql.join(sqlChunks, sql.raw(', '))}}`;
+    },
+    // ! this won't actually ever work because of how map values are returned
+    fromDriver(value: string): TData {
+      console.log('fromDriver');
+      // todo: more sophisticated decoding based on data type
+
+      const replacedValue = value.replaceAll(
+        /(?:^{)?([^=]+?)=(.+)(?:}$)?/g,
+        '"$1":"$2"'
+      );
+      const formattedValue = `{${replacedValue}}`;
+
+      const valueObj = JSON.parse(formattedValue);
+
+      return Object.fromEntries(
+        Object.entries(valueObj).map(([key, value]) => {
+          return [key, JSON.parse(value as string)];
+        })
+      ) as TData;
+    },
+  })(name);
+
+export const duckDbStruct = <TData extends Record<string, any>>(
+  name: string,
+  schema: Record<string, AnyColType | ListColType | ArrayColType>
+) =>
+  customType<{ data: TData; driverData: string }>({
+    dataType() {
+      const fields = Object.entries(schema).map(
+        ([key, type]) => `${key} ${type}`
+      );
+
+      return `STRUCT (${fields.join(', ')})`;
+    },
+    toDriver(value: TData) {
+      // todo: more sophisticated encoding based on data type
+      const valueFormatter = (value: any) =>
+        JSON.stringify(value).replaceAll(/(?<!\\)"/g, "'");
+
+      const values = Object.entries(value).map(([key, value]) => {
+        return sql.raw(`'${key}': ${valueFormatter(value)}`);
+      });
+
+      const sqlChunks: SQL[] = [];
+
+      for (const value of values) {
+        sqlChunks.push(value);
+      }
+
+      return sql`(SELECT {${sql.join(sqlChunks, sql.raw(', '))}})`;
+    },
+    fromDriver(value: string): TData {
+      return value as unknown as TData;
+    },
+  })(name);
+
+export const duckDbBlob = customType<{
+  data: Buffer;
+  default: false;
+}>({
+  dataType() {
+    return 'BLOB';
+  },
+  toDriver(value: Buffer) {
+    const hexString = value.toString('hex');
+    return sql`from_hex(${hexString})`;
+  },
+});
+
+// todo: date/time types

package/src/utils.ts

@@ -9,7 +9,7 @@ import {
   getTableName,
   sql,
 } from 'drizzle-orm';
-import { PgColumn, type SelectedFields } from 'drizzle-orm/pg-core';
+import { PgCustomColumn, type SelectedFields } from 'drizzle-orm/pg-core';
 
 // Need to get around "decoder" property being marked as internal
 type SQLInternal<T = unknown> = SQL<T> & {
@@ -32,7 +32,13 @@ export function mapResultRow<TResult>(
       } else if (is(field, SQL)) {
         decoder = (field as SQLInternal).decoder;
       } else {
-        decoder = (field.sql as SQLInternal).decoder;
+        const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+
+        if (is(col, PgCustomColumn)) {
+          decoder = col;
+        } else {
+          decoder = (field.sql as SQLInternal).decoder;
+        }
       }
       let node = result;
       for (const [pathChunkIndex, pathChunk] of path.entries()) {