@effect/sql-clickhouse 0.45.0 → 4.0.0-beta.0

package/src/ClickhouseClient.ts

@@ -2,24 +2,21 @@
  * @since 1.0.0
  */
 import * as Clickhouse from "@clickhouse/client"
-import * as Reactivity from "@effect/experimental/Reactivity"
 import * as NodeStream from "@effect/platform-node/NodeStream"
-import * as Client from "@effect/sql/SqlClient"
-import type { Connection } from "@effect/sql/SqlConnection"
-import { SqlError } from "@effect/sql/SqlError"
-import * as Statement from "@effect/sql/Statement"
-import * as Chunk from "effect/Chunk"
 import * as Config from "effect/Config"
-import type { ConfigError } from "effect/ConfigError"
-import * as Context from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
-import * as FiberRef from "effect/FiberRef"
+import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
-import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
+import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
+import * as Reactivity from "effect/unstable/reactivity/Reactivity"
+import * as Client from "effect/unstable/sql/SqlClient"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
+import { SqlError } from "effect/unstable/sql/SqlError"
+import * as Statement from "effect/unstable/sql/Statement"
 import * as Crypto from "node:crypto"
 import type { Readable } from "node:stream"
 
@@ -30,13 +27,13 @@ const ATTR_DB_NAMESPACE = "db.namespace"
  * @category type ids
  * @since 1.0.0
  */
-export const TypeId: unique symbol = Symbol.for("@effect/sql-clickhouse/ClickhouseClient")
+export const TypeId: TypeId = "~@effect/sql-clickhouse/ClickhouseClient"
 
 /**
  * @category type ids
  * @since 1.0.0
  */
-export type TypeId = typeof TypeId
+export type TypeId = "~@effect/sql-clickhouse/ClickhouseClient"
 
 /**
  * @category models
@@ -71,7 +68,7 @@ export interface ClickhouseClient extends Client.SqlClient {
  * @category tags
  * @since 1.0.0
  */
-export const ClickhouseClient = Context.GenericTag<ClickhouseClient>("@effect/sql-clickhouse/ClickhouseClient")
+export const ClickhouseClient = ServiceMap.Service<ClickhouseClient>("@effect/sql-clickhouse/ClickhouseClient")
 
 /**
  * @category constructors
@@ -105,29 +102,34 @@ export const make = (
       }),
       () => Effect.promise(() => client.close())
     ).pipe(
-      Effect.timeoutFail({
+      Effect.timeoutOrElse({
         duration: Duration.seconds(5),
         onTimeout: () =>
-          new SqlError({
-            message: "ClickhouseClient: Connection timeout",
-            cause: new Error("connection timeout")
-          })
+          Effect.fail(
+            new SqlError({
+              message: "ClickhouseClient: Connection timeout",
+              cause: new Error("connection timeout")
+            })
+          )
       })
     )
 
     class ConnectionImpl implements Connection {
-      constructor(private readonly conn: Clickhouse.ClickHouseClient) {}
+      private conn: Clickhouse.ClickHouseClient
+      constructor(conn: Clickhouse.ClickHouseClient) {
+        this.conn = conn
+      }
 
       private runRaw(sql: string, params: ReadonlyArray<unknown>, format: Clickhouse.DataFormat = "JSON") {
         const paramsObj: Record<string, unknown> = {}
         for (let i = 0; i < params.length; i++) {
           paramsObj[`p${i + 1}`] = params[i]
         }
-        return Effect.withFiberRuntime<Clickhouse.ResultSet<"JSON"> | Clickhouse.CommandResult, SqlError>((fiber) => {
-          const method = fiber.getFiberRef(currentClientMethod)
-          return Effect.async<Clickhouse.ResultSet<"JSON"> | Clickhouse.CommandResult, SqlError>((resume) => {
-            const queryId = fiber.getFiberRef(currentQueryId) ?? Crypto.randomUUID()
-            const settings = fiber.getFiberRef(currentClickhouseSettings) ?? {}
+        return Effect.withFiber<Clickhouse.ResultSet<"JSON"> | Clickhouse.CommandResult, SqlError>((fiber) => {
+          const method = fiber.getRef(ClientMethod)
+          return Effect.callback<Clickhouse.ResultSet<"JSON"> | Clickhouse.CommandResult, SqlError>((resume) => {
+            const queryId = fiber.getRef(QueryId) ?? Crypto.randomUUID()
+            const settings = fiber.getRef(ClickhouseSettings)
             const controller = new AbortController()
             if (method === "command") {
               this.conn.command({
@@ -205,10 +207,10 @@ export const make = (
             if (!("stream" in result)) {
               return Stream.empty
             }
-            return NodeStream.fromReadable<SqlError, ReadonlyArray<Clickhouse.Row<any, "JSONEachRow">>>(
-              () => result.stream() as any,
-              (cause) => new SqlError({ cause, message: "Failed to execute stream" })
-            )
+            return NodeStream.fromReadable<ReadonlyArray<Clickhouse.Row<any, "JSONEachRow">>, SqlError>({
+              evaluate: () => result.stream() as any,
+              onError: (cause) => new SqlError({ cause, message: "Failed to execute stream" })
+            })
           }),
           Stream.unwrap,
           Stream.chunks,
@@ -220,12 +222,11 @@ export const make = (
               }
             }
             return Effect.tryPromise({
-              try: () =>
-                Promise.all(promises).then((rows) => Chunk.unsafeFromArray(transformRows ? transformRows(rows) : rows)),
+              try: () => Promise.all(promises).then((rows) => transformRows ? transformRows(rows) : rows),
               catch: (cause) => new SqlError({ cause, message: "Failed to parse row" })
             })
           }),
-          Stream.flattenChunks
+          Stream.flattenIterable
         )
       }
     }
@@ -248,94 +249,96 @@ export const make = (
         [TypeId]: TypeId as TypeId,
         config: options,
         param(dataType: string, value: unknown) {
-          return clickhouseParam(dataType, value)
+          return Statement.fragment([clickhouseParam(dataType, value)])
         },
         asCommand<A, E, R>(effect: Effect.Effect<A, E, R>) {
-          return Effect.locally(effect, currentClientMethod, "command")
+          return Effect.provideService(effect, ClientMethod, "command")
         },
         insertQuery<T = unknown>(options: {
           readonly table: string
           readonly values: Clickhouse.InsertValues<Readable, T>
           readonly format?: Clickhouse.DataFormat
         }) {
-          return Effect.withFiberRuntime<Clickhouse.InsertResult, SqlError>((fiber) =>
-            Effect.async((resume) => {
-              const queryId = fiber.getFiberRef(currentQueryId) ?? Crypto.randomUUID()
-              const settings = fiber.getFiberRef(currentClickhouseSettings)
-              const controller = new AbortController()
-              client.insert({
-                format: "JSONEachRow",
-                ...options,
-                abort_signal: controller.signal,
-                query_id: queryId,
-                clickhouse_settings: settings
-              }).then(
-                (result) => resume(Effect.succeed(result)),
-                (cause) => resume(Effect.fail(new SqlError({ cause, message: "Failed to insert data" })))
-              )
-              return Effect.suspend(() => {
-                controller.abort()
-                return Effect.promise(() => client.command({ query: `KILL QUERY WHERE query_id = '${queryId}'` }))
-              })
+          return Effect.callback<Clickhouse.InsertResult, SqlError>((resume) => {
+            const fiber = Fiber.getCurrent()!
+            const queryId = fiber.getRef(QueryId) ?? Crypto.randomUUID()
+            const settings = fiber.getRef(ClickhouseSettings)
+            const controller = new AbortController()
+            client.insert({
+              format: "JSONEachRow",
+              ...options,
+              abort_signal: controller.signal,
+              query_id: queryId,
+              clickhouse_settings: settings
+            }).then(
+              (result) => resume(Effect.succeed(result)),
+              (cause) => resume(Effect.fail(new SqlError({ cause, message: "Failed to insert data" })))
+            )
+            return Effect.suspend(() => {
+              controller.abort()
+              return Effect.promise(() => client.command({ query: `KILL QUERY WHERE query_id = '${queryId}'` }))
             })
-          )
+          })
         },
         withQueryId: dual(2, <A, E, R>(effect: Effect.Effect<A, E, R>, queryId: string) =>
-          Effect.locally(effect, currentQueryId, queryId)),
+          Effect.provideService(effect, QueryId, queryId)),
         withClickhouseSettings: dual(
           2,
           <A, E, R>(
             effect: Effect.Effect<A, E, R>,
             settings: NonNullable<Clickhouse.BaseQueryParams["clickhouse_settings"]>
           ) =>
-            Effect.locally(effect, currentClickhouseSettings, settings)
+            Effect.provideService(effect, ClickhouseSettings, settings)
         )
       }
     )
   })
 
 /**
- * @category fiber refs
+ * @category References
  * @since 1.0.0
  */
-export const currentClientMethod: FiberRef.FiberRef<"query" | "command" | "insert"> = globalValue(
-  "@effect/sql-clickhouse/ClickhouseClient/currentClientMethod",
-  () => FiberRef.unsafeMake<"query" | "command" | "insert">("query")
+export const ClientMethod = ServiceMap.Reference<"query" | "command" | "insert">(
+  "@effect/sql-clickhouse/ClickhouseClient/ClientMethod",
+  {
+    defaultValue: () => "query"
+  }
 )
 
 /**
- * @category fiber refs
+ * @category References
  * @since 1.0.0
  */
-export const currentQueryId: FiberRef.FiberRef<string | undefined> = globalValue(
-  "@effect/sql-clickhouse/ClickhouseClient/currentQueryId",
-  () => FiberRef.unsafeMake<string | undefined>(undefined)
+export const QueryId = ServiceMap.Reference<string | undefined>(
+  "@effect/sql-clickhouse/ClickhouseClient/QueryId",
+  { defaultValue: () => undefined }
 )
 
 /**
- * @category fiber refs
+ * @category References
  * @since 1.0.0
  */
-export const currentClickhouseSettings: FiberRef.FiberRef<
+export const ClickhouseSettings: ServiceMap.Reference<
   NonNullable<Clickhouse.BaseQueryParams["clickhouse_settings"]>
-> = globalValue(
-  "@effect/sql-clickhouse/ClickhouseClient/currentClickhouseSettings",
-  () => FiberRef.unsafeMake({})
-)
+> = ServiceMap.Reference("@effect/sql-clickhouse/ClickhouseClient/ClickhouseSettings", {
+  defaultValue: () => ({})
+})
 
 /**
  * @category layers
  * @since 1.0.0
  */
-export const layerConfig = (
-  config: Config.Config.Wrap<ClickhouseClientConfig>
-): Layer.Layer<ClickhouseClient | Client.SqlClient, ConfigError | SqlError> =>
-  Layer.scopedContext(
-    Config.unwrap(config).pipe(
+export const layerConfig: (
+  config: Config.Wrap<ClickhouseClientConfig>
+) => Layer.Layer<ClickhouseClient | Client.SqlClient, Config.ConfigError | SqlError> = (
+  config: Config.Wrap<ClickhouseClientConfig>
+): Layer.Layer<ClickhouseClient | Client.SqlClient, Config.ConfigError | SqlError> =>
+  Layer.effectServices(
+    Config.unwrap(config).asEffect().pipe(
       Effect.flatMap(make),
       Effect.map((client) =>
-        Context.make(ClickhouseClient, client).pipe(
-          Context.add(Client.SqlClient, client)
+        ServiceMap.make(ClickhouseClient, client).pipe(
+          ServiceMap.add(Client.SqlClient, client)
         )
       )
     )
@@ -347,11 +350,11 @@ export const layerConfig = (
  */
 export const layer = (
   config: ClickhouseClientConfig
-): Layer.Layer<ClickhouseClient | Client.SqlClient, ConfigError | SqlError> =>
-  Layer.scopedContext(
+): Layer.Layer<ClickhouseClient | Client.SqlClient, Config.ConfigError | SqlError> =>
+  Layer.effectServices(
     Effect.map(make(config), (client) =>
-      Context.make(ClickhouseClient, client).pipe(
-        Context.add(Client.SqlClient, client)
+      ServiceMap.make(ClickhouseClient, client).pipe(
+        ServiceMap.add(Client.SqlClient, client)
       ))
   ).pipe(Layer.provide(Reactivity.layer))
 
@@ -359,7 +362,7 @@ const typeFromUnknown = (value: unknown): string => {
   if (Statement.isFragment(value)) {
     return typeFromUnknown(value.segments[0])
   } else if (isClickhouseParam(value)) {
-    return value.i0
+    return value.paramA
   } else if (Array.isArray(value)) {
     return `Array(${typeFromUnknown(value[0])})`
   }
@@ -399,7 +402,7 @@ export const makeCompiler = (transform?: (_: string) => string) =>
       return ["", []]
     },
     onCustom(type, placeholder) {
-      return [placeholder(type), [type.i1]]
+      return [placeholder(type), [type.paramB]]
     }
   })
 

package/src/ClickhouseMigrator.ts

@@ -1,21 +1,16 @@
 /**
  * @since 1.0.0
  */
-import * as Migrator from "@effect/sql/Migrator"
-import type * as Client from "@effect/sql/SqlClient"
-import type { SqlError } from "@effect/sql/SqlError"
 import type * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as Migrator from "effect/unstable/sql/Migrator"
+import type * as Client from "effect/unstable/sql/SqlClient"
+import type { SqlError } from "effect/unstable/sql/SqlError"
 
 /**
  * @since 1.0.0
  */
-export * from "@effect/sql/Migrator"
-
-/**
- * @since 1.0.0
- */
-export * from "@effect/sql/Migrator/FileSystem"
+export * from "effect/unstable/sql/Migrator"
 
 /**
  * @category constructor

package/src/index.ts

@@ -1,9 +1,15 @@
 /**
  * @since 1.0.0
  */
-export * as ClickhouseClient from "./ClickhouseClient.js"
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 1.0.0
+ */
+export * as ClickhouseClient from "./ClickhouseClient.ts"
 
 /**
  * @since 1.0.0
  */
-export * as ClickhouseMigrator from "./ClickhouseMigrator.js"
+export * as ClickhouseMigrator from "./ClickhouseMigrator.ts"

package/ClickhouseClient/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/ClickhouseClient.js",
-  "module": "../dist/esm/ClickhouseClient.js",
-  "types": "../dist/dts/ClickhouseClient.d.ts"
-}

package/ClickhouseMigrator/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/ClickhouseMigrator.js",
-  "module": "../dist/esm/ClickhouseMigrator.js",
-  "types": "../dist/dts/ClickhouseMigrator.d.ts"
-}

package/dist/cjs/ClickhouseClient.js

@@ -1,278 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeCompiler = exports.make = exports.layerConfig = exports.layer = exports.currentQueryId = exports.currentClientMethod = exports.currentClickhouseSettings = exports.TypeId = exports.ClickhouseClient = void 0;
-var Clickhouse = _interopRequireWildcard(require("@clickhouse/client"));
-var Reactivity = _interopRequireWildcard(require("@effect/experimental/Reactivity"));
-var NodeStream = _interopRequireWildcard(require("@effect/platform-node/NodeStream"));
-var Client = _interopRequireWildcard(require("@effect/sql/SqlClient"));
-var _SqlError = require("@effect/sql/SqlError");
-var Statement = _interopRequireWildcard(require("@effect/sql/Statement"));
-var Chunk = _interopRequireWildcard(require("effect/Chunk"));
-var Config = _interopRequireWildcard(require("effect/Config"));
-var Context = _interopRequireWildcard(require("effect/Context"));
-var Duration = _interopRequireWildcard(require("effect/Duration"));
-var Effect = _interopRequireWildcard(require("effect/Effect"));
-var FiberRef = _interopRequireWildcard(require("effect/FiberRef"));
-var _Function = require("effect/Function");
-var _GlobalValue = require("effect/GlobalValue");
-var Layer = _interopRequireWildcard(require("effect/Layer"));
-var Stream = _interopRequireWildcard(require("effect/Stream"));
-var Crypto = _interopRequireWildcard(require("node:crypto"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-/**
- * @since 1.0.0
- */
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name";
-const ATTR_DB_NAMESPACE = "db.namespace";
-/**
- * @category type ids
- * @since 1.0.0
- */
-const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("@effect/sql-clickhouse/ClickhouseClient");
-/**
- * @category tags
- * @since 1.0.0
- */
-const ClickhouseClient = exports.ClickhouseClient = /*#__PURE__*/Context.GenericTag("@effect/sql-clickhouse/ClickhouseClient");
-/**
- * @category constructors
- * @since 1.0.0
- */
-const make = options => Effect.gen(function* () {
-  const compiler = makeCompiler(options.transformQueryNames);
-  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
-  const client = Clickhouse.createClient(options);
-  yield* Effect.acquireRelease(Effect.tryPromise({
-    try: () => client.exec({
-      query: "SELECT 1"
-    }),
-    catch: cause => new _SqlError.SqlError({
-      cause,
-      message: "ClickhouseClient: Failed to connect"
-    })
-  }), () => Effect.promise(() => client.close())).pipe(Effect.timeoutFail({
-    duration: Duration.seconds(5),
-    onTimeout: () => new _SqlError.SqlError({
-      message: "ClickhouseClient: Connection timeout",
-      cause: new Error("connection timeout")
-    })
-  }));
-  class ConnectionImpl {
-    conn;
-    constructor(conn) {
-      this.conn = conn;
-    }
-    runRaw(sql, params, format = "JSON") {
-      const paramsObj = {};
-      for (let i = 0; i < params.length; i++) {
-        paramsObj[`p${i + 1}`] = params[i];
-      }
-      return Effect.withFiberRuntime(fiber => {
-        const method = fiber.getFiberRef(currentClientMethod);
-        return Effect.async(resume => {
-          const queryId = fiber.getFiberRef(currentQueryId) ?? Crypto.randomUUID();
-          const settings = fiber.getFiberRef(currentClickhouseSettings) ?? {};
-          const controller = new AbortController();
-          if (method === "command") {
-            this.conn.command({
-              query: sql,
-              query_params: paramsObj,
-              abort_signal: controller.signal,
-              query_id: queryId,
-              clickhouse_settings: settings
-            }).then(result => resume(Effect.succeed(result)), cause => resume(Effect.fail(new _SqlError.SqlError({
-              cause,
-              message: "Failed to execute statement"
-            }))));
-          } else {
-            this.conn.query({
-              query: sql,
-              query_params: paramsObj,
-              abort_signal: controller.signal,
-              query_id: queryId,
-              clickhouse_settings: settings,
-              format
-            }).then(result => resume(Effect.succeed(result)), cause => resume(Effect.fail(new _SqlError.SqlError({
-              cause,
-              message: "Failed to execute statement"
-            }))));
-          }
-          return Effect.suspend(() => {
-            controller.abort();
-            return Effect.promise(() => this.conn.command({
-              query: `KILL QUERY WHERE query_id = '${queryId}'`
-            }));
-          });
-        });
-      });
-    }
-    run(sql, params, format) {
-      return this.runRaw(sql, params, format).pipe(Effect.flatMap(result => {
-        if ("json" in result) {
-          return Effect.promise(() => result.json().then(result => "data" in result ? result.data : result, () => []));
-        }
-        return Effect.succeed([]);
-      }));
-    }
-    execute(sql, params, transformRows) {
-      return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
-    }
-    executeRaw(sql, params) {
-      return this.runRaw(sql, params);
-    }
-    executeValues(sql, params) {
-      return this.run(sql, params, "JSONCompact");
-    }
-    executeUnprepared(sql, params, transformRows) {
-      return this.execute(sql, params, transformRows);
-    }
-    executeStream(sql, params, transformRows) {
-      return this.runRaw(sql, params, "JSONEachRow").pipe(Effect.map(result => {
-        if (!("stream" in result)) {
-          return Stream.empty;
-        }
-        return NodeStream.fromReadable(() => result.stream(), cause => new _SqlError.SqlError({
-          cause,
-          message: "Failed to execute stream"
-        }));
-      }), Stream.unwrap, Stream.chunks, Stream.mapEffect(chunk => {
-        const promises = [];
-        for (const rows of chunk) {
-          for (const row of rows) {
-            promises.push(row.json());
-          }
-        }
-        return Effect.tryPromise({
-          try: () => Promise.all(promises).then(rows => Chunk.unsafeFromArray(transformRows ? transformRows(rows) : rows)),
-          catch: cause => new _SqlError.SqlError({
-            cause,
-            message: "Failed to parse row"
-          })
-        });
-      }), Stream.flattenChunks);
-    }
-  }
-  const connection = new ConnectionImpl(client);
-  return Object.assign(yield* Client.make({
-    acquirer: Effect.succeed(connection),
-    compiler,
-    spanAttributes: [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "clickhouse"], [ATTR_DB_NAMESPACE, options.database ?? "default"]],
-    beginTransaction: "BEGIN TRANSACTION",
-    transformRows
-  }), {
-    [TypeId]: TypeId,
-    config: options,
-    param(dataType, value) {
-      return clickhouseParam(dataType, value);
-    },
-    asCommand(effect) {
-      return Effect.locally(effect, currentClientMethod, "command");
-    },
-    insertQuery(options) {
-      return Effect.withFiberRuntime(fiber => Effect.async(resume => {
-        const queryId = fiber.getFiberRef(currentQueryId) ?? Crypto.randomUUID();
-        const settings = fiber.getFiberRef(currentClickhouseSettings);
-        const controller = new AbortController();
-        client.insert({
-          format: "JSONEachRow",
-          ...options,
-          abort_signal: controller.signal,
-          query_id: queryId,
-          clickhouse_settings: settings
-        }).then(result => resume(Effect.succeed(result)), cause => resume(Effect.fail(new _SqlError.SqlError({
-          cause,
-          message: "Failed to insert data"
-        }))));
-        return Effect.suspend(() => {
-          controller.abort();
-          return Effect.promise(() => client.command({
-            query: `KILL QUERY WHERE query_id = '${queryId}'`
-          }));
-        });
-      }));
-    },
-    withQueryId: (0, _Function.dual)(2, (effect, queryId) => Effect.locally(effect, currentQueryId, queryId)),
-    withClickhouseSettings: (0, _Function.dual)(2, (effect, settings) => Effect.locally(effect, currentClickhouseSettings, settings))
-  });
-});
-/**
- * @category fiber refs
- * @since 1.0.0
- */
-exports.make = make;
-const currentClientMethod = exports.currentClientMethod = /*#__PURE__*/(0, _GlobalValue.globalValue)("@effect/sql-clickhouse/ClickhouseClient/currentClientMethod", () => FiberRef.unsafeMake("query"));
-/**
- * @category fiber refs
- * @since 1.0.0
- */
-const currentQueryId = exports.currentQueryId = /*#__PURE__*/(0, _GlobalValue.globalValue)("@effect/sql-clickhouse/ClickhouseClient/currentQueryId", () => FiberRef.unsafeMake(undefined));
-/**
- * @category fiber refs
- * @since 1.0.0
- */
-const currentClickhouseSettings = exports.currentClickhouseSettings = /*#__PURE__*/(0, _GlobalValue.globalValue)("@effect/sql-clickhouse/ClickhouseClient/currentClickhouseSettings", () => FiberRef.unsafeMake({}));
-/**
- * @category layers
- * @since 1.0.0
- */
-const layerConfig = config => Layer.scopedContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map(client => Context.make(ClickhouseClient, client).pipe(Context.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
-/**
- * @category layers
- * @since 1.0.0
- */
-exports.layerConfig = layerConfig;
-const layer = config => Layer.scopedContext(Effect.map(make(config), client => Context.make(ClickhouseClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
-exports.layer = layer;
-const typeFromUnknown = value => {
-  if (Statement.isFragment(value)) {
-    return typeFromUnknown(value.segments[0]);
-  } else if (isClickhouseParam(value)) {
-    return value.i0;
-  } else if (Array.isArray(value)) {
-    return `Array(${typeFromUnknown(value[0])})`;
-  }
-  switch (typeof value) {
-    case "number":
-      return "Decimal";
-    case "bigint":
-      return "Int64";
-    case "boolean":
-      return "Bool";
-    case "object":
-      if (value instanceof Date) {
-        return "DateTime()";
-      }
-      return "String";
-    default:
-      return "String";
-  }
-};
-/**
- * @category compiler
- * @since 1.0.0
- */
-const makeCompiler = transform => Statement.makeCompiler({
-  dialect: "sqlite",
-  placeholder(i, u) {
-    return `{p${i}: ${typeFromUnknown(u)}}`;
-  },
-  onIdentifier: transform ? function (value, withoutTransform) {
-    return withoutTransform ? escape(value) : escape(transform(value));
-  } : escape,
-  onRecordUpdate() {
-    return ["", []];
-  },
-  onCustom(type, placeholder) {
-    return [placeholder(type), [type.i1]];
-  }
-});
-// compiler helpers
-exports.makeCompiler = makeCompiler;
-const escape = /*#__PURE__*/Statement.defaultEscape("\"");
-const clickhouseParam = /*#__PURE__*/Statement.custom("ClickhouseParam");
-const isClickhouseParam = /*#__PURE__*/Statement.isCustom("ClickhouseParam");
-//# sourceMappingURL=ClickhouseClient.js.map