envio 2.32.2 → 3.0.0-alpha-main-clickhouse-sink

package/src/bindings/ClickHouse.res

@@ -0,0 +1,387 @@
+// ClickHouse client bindings for @clickhouse/client
+
+type client
+
+type clientConfig = {
+  url?: string,
+  database?: string,
+  username?: string,
+  password?: string,
+}
+
+type execParams = {query: string}
+
+@module("@clickhouse/client")
+external createClient: clientConfig => client = "createClient"
+
+@send
+external exec: (client, execParams) => promise<unit> = "exec"
+
+@send
+external close: client => promise<unit> = "close"
+
+type insertParams<'a> = {
+  table: string,
+  values: array<'a>,
+  format: string,
+}
+
+@send
+external insert: (client, insertParams<'a>) => promise<unit> = "insert"
+
+type queryParams = {query: string}
+type queryResult<'a>
+
+@send
+external query: (client, queryParams) => promise<queryResult<'a>> = "query"
+
+@send
+external json: queryResult<'a> => promise<'a> = "json"
+
+let getClickHouseFieldType = (
+  ~fieldType: Table.fieldType,
+  ~isNullable: bool,
+  ~isArray: bool,
+): string => {
+  let baseType = switch fieldType {
+  | Int32 => "Int32"
+  | Uint32 => "UInt32"
+  | Serial => "Int32"
+  | BigInt({?precision}) =>
+    switch precision {
+    | None => "String" // Fallback for unbounded BigInt
+    | Some(precision) =>
+      if precision > 38 {
+        "String"
+      } else {
+        `Decimal(${precision->Js.Int.toString},0)`
+      }
+    }
+  | BigDecimal({?config}) =>
+    switch config {
+    | None => "String" // Fallback for unbounded BigDecimal
+    | Some((precision, scale)) =>
+      if precision > 38 || scale > precision {
+        "String"
+      } else {
+        `Decimal(${precision->Js.Int.toString},${scale->Js.Int.toString})`
+      }
+    }
+  | Boolean => "Bool"
+  | Number => "Float64"
+  | String => "String"
+  | Json => "String"
+  | Date => "DateTime64(3, 'UTC')"
+  | Enum({config}) => {
+      let variantsLength = config.variants->Belt.Array.length
+      // Theoretically we can store 256 variants in Enum8,
+      // but it'd require to explicitly start with a negative index (probably)
+      let enumType = variantsLength <= 127 ? "Enum8" : "Enum16"
+      let enumValues =
+        config.variants
+        ->Belt.Array.map(variant => {
+          let variantStr = variant->(Utils.magic: 'a => string)
+          `'${variantStr}'`
+        })
+        ->Js.Array2.joinWith(", ")
+      `${enumType}(${enumValues})`
+    }
+  | Entity(_) => "String"
+  }
+
+  let baseType = if isArray {
+    `Array(${baseType})`
+  } else {
+    baseType
+  }
+
+  isNullable ? `Nullable(${baseType})` : baseType
+}
+
+let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) => {
+  let checkpointsCount = batch.checkpointIds->Array.length
+  if checkpointsCount === 0 {
+    ()
+  } else {
+    // Convert columnar data to row format for JSONCompactEachRow
+    let checkpointRows = []
+    for idx in 0 to checkpointsCount - 1 {
+      checkpointRows
+      ->Js.Array2.push((
+        batch.checkpointIds->Belt.Array.getUnsafe(idx),
+        batch.checkpointChainIds->Belt.Array.getUnsafe(idx),
+        batch.checkpointBlockNumbers->Belt.Array.getUnsafe(idx),
+        batch.checkpointBlockHashes->Belt.Array.getUnsafe(idx),
+        batch.checkpointEventsProcessed->Belt.Array.getUnsafe(idx),
+      ))
+      ->ignore
+    }
+
+    try {
+      await client->insert({
+        table: `${database}.\`${InternalTable.Checkpoints.table.tableName}\``,
+        values: checkpointRows,
+        format: "JSONCompactEachRow",
+      })
+    } catch {
+    | exn =>
+      raise(
+        Persistence.StorageError({
+          message: `Failed to insert checkpoints into ClickHouse table "${InternalTable.Checkpoints.table.tableName}"`,
+          reason: exn->Utils.prettifyExn,
+        }),
+      )
+    }
+  }
+}
+
+let setUpdatesOrThrow = async (
+  client,
+  ~updates: array<Internal.inMemoryStoreEntityUpdate<Internal.entity>>,
+  ~entityConfig: Internal.entityConfig,
+  ~database: string,
+) => {
+  if updates->Array.length === 0 {
+    ()
+  } else {
+    let {convertOrThrow, tableName} = switch entityConfig.clickHouseSetUpdatesCache {
+    | Some(cache) => cache
+    | None =>
+      let cache: Internal.clickHouseSetUpdatesCache = {
+        tableName: `${database}.\`${EntityHistory.historyTableName(
+            ~entityName=entityConfig.name,
+            ~entityIndex=entityConfig.index,
+          )}\``,
+        convertOrThrow: S.compile(
+          S.union([
+            EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+            S.object(s => {
+              s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
+              Change.Delete({
+                entityId: s.field(Table.idFieldName, S.string),
+                checkpointId: s.field(
+                  EntityHistory.checkpointIdFieldName,
+                  EntityHistory.unsafeCheckpointIdSchema,
+                ),
+              })
+            }),
+          ]),
+          ~input=Value,
+          ~output=Json,
+          ~typeValidation=false,
+          ~mode=Sync,
+        ),
+      }
+
+      entityConfig.clickHouseSetUpdatesCache = Some(cache)
+      cache
+    }
+
+    try {
+      // Convert entity updates to ClickHouse row format
+      let values = updates->Js.Array2.map(update => {
+        update.latestChange->convertOrThrow
+      })
+
+      await client->insert({
+        table: tableName,
+        values,
+        format: "JSONEachRow",
+      })
+    } catch {
+    | exn =>
+      raise(
+        Persistence.StorageError({
+          message: `Failed to insert items into ClickHouse table "${tableName}"`,
+          reason: exn->Utils.prettifyExn,
+        }),
+      )
+    }
+  }
+}
+
+// Generate CREATE TABLE query for entity history table
+let makeCreateHistoryTableQuery = (~entityConfig: Internal.entityConfig, ~database: string) => {
+  let fieldDefinitions = entityConfig.table.fields->Belt.Array.keepMap(field => {
+    switch field {
+    | Field(field) =>
+      Some({
+        let fieldName = field->Table.getDbFieldName
+        let clickHouseType = getClickHouseFieldType(
+          ~fieldType=field.fieldType,
+          ~isNullable=field.isNullable,
+          ~isArray=field.isArray,
+        )
+        `\`${fieldName}\` ${clickHouseType}`
+      })
+    | DerivedFrom(_) => None
+    }
+  })
+
+  `CREATE TABLE IF NOT EXISTS ${database}.\`${EntityHistory.historyTableName(
+      ~entityName=entityConfig.name,
+      ~entityIndex=entityConfig.index,
+    )}\` (
+  ${fieldDefinitions->Js.Array2.joinWith(",\n  ")},
+  \`${EntityHistory.checkpointIdFieldName}\` ${getClickHouseFieldType(
+      ~fieldType=Uint32,
+      ~isNullable=false,
+      ~isArray=false,
+    )},
+  \`${EntityHistory.changeFieldName}\` ${getClickHouseFieldType(
+      ~fieldType=Enum({config: EntityHistory.RowAction.config->Table.fromGenericEnumConfig}),
+      ~isNullable=false,
+      ~isArray=false,
+    )}
+)
+ENGINE = MergeTree()
+ORDER BY (${Table.idFieldName}, ${EntityHistory.checkpointIdFieldName})`
+}
+
+// Generate CREATE TABLE query for checkpoints
+let makeCreateCheckpointsTableQuery = (~database: string) => {
+  let idField = (#id: InternalTable.Checkpoints.field :> string)
+  let chainIdField = (#chain_id: InternalTable.Checkpoints.field :> string)
+  let blockNumberField = (#block_number: InternalTable.Checkpoints.field :> string)
+  let blockHashField = (#block_hash: InternalTable.Checkpoints.field :> string)
+  let eventsProcessedField = (#events_processed: InternalTable.Checkpoints.field :> string)
+
+  `CREATE TABLE IF NOT EXISTS ${database}.\`${InternalTable.Checkpoints.table.tableName}\` (
+  \`${idField}\` ${getClickHouseFieldType(~fieldType=Int32, ~isNullable=false, ~isArray=false)},
+  \`${chainIdField}\` ${getClickHouseFieldType(
+      ~fieldType=Int32,
+      ~isNullable=false,
+      ~isArray=false,
+    )},
+  \`${blockNumberField}\` ${getClickHouseFieldType(
+      ~fieldType=Int32,
+      ~isNullable=false,
+      ~isArray=false,
+    )},
+  \`${blockHashField}\` ${getClickHouseFieldType(
+      ~fieldType=String,
+      ~isNullable=true,
+      ~isArray=false,
+    )},
+  \`${eventsProcessedField}\` ${getClickHouseFieldType(
+      ~fieldType=Int32,
+      ~isNullable=false,
+      ~isArray=false,
+    )}
+)
+ENGINE = MergeTree()
+ORDER BY (${idField})`
+}
+
+// Generate CREATE VIEW query for entity current state
+let makeCreateViewQuery = (~entityConfig: Internal.entityConfig, ~database: string) => {
+  let historyTableName = EntityHistory.historyTableName(
+    ~entityName=entityConfig.name,
+    ~entityIndex=entityConfig.index,
+  )
+
+  let checkpointsTableName = InternalTable.Checkpoints.table.tableName
+  let checkpointIdField = (#id: InternalTable.Checkpoints.field :> string)
+
+  let entityFields =
+    entityConfig.table.fields
+    ->Belt.Array.keepMap(field => {
+      switch field {
+      | Field(field) => {
+          let fieldName = field->Table.getDbFieldName
+          Some(`\`${fieldName}\``)
+        }
+      | DerivedFrom(_) => None
+      }
+    })
+    ->Js.Array2.joinWith(", ")
+
+  `CREATE VIEW IF NOT EXISTS ${database}.\`${entityConfig.name}\` AS
+SELECT ${entityFields}
+FROM (
+  SELECT ${entityFields}, \`${EntityHistory.changeFieldName}\`
+  FROM ${database}.\`${historyTableName}\`
+  WHERE \`${EntityHistory.checkpointIdFieldName}\` <= (SELECT max(${checkpointIdField}) FROM ${database}.\`${checkpointsTableName}\`)
+  ORDER BY \`${EntityHistory.checkpointIdFieldName}\` DESC
+  LIMIT 1 BY \`${Table.idFieldName}\`
+)
+WHERE \`${EntityHistory.changeFieldName}\` = '${(EntityHistory.RowAction.SET :> string)}'`
+}
+
+// Initialize ClickHouse tables for entities
+let initialize = async (
+  client,
+  ~database: string,
+  ~entities: array<Internal.entityConfig>,
+  ~enums as _: array<Table.enumConfig<Table.enum>>,
+) => {
+  try {
+    await client->exec({query: `DROP DATABASE IF EXISTS ${database}`})
+    await client->exec({query: `CREATE DATABASE ${database}`})
+    await client->exec({query: `USE ${database}`})
+
+    await Promise.all(
+      entities->Belt.Array.map(entityConfig =>
+        client->exec({query: makeCreateHistoryTableQuery(~entityConfig, ~database)})
+      ),
+    )->Promise.ignoreValue
+    await client->exec({query: makeCreateCheckpointsTableQuery(~database)})
+
+    await Promise.all(
+      entities->Belt.Array.map(entityConfig =>
+        client->exec({query: makeCreateViewQuery(~entityConfig, ~database)})
+      ),
+    )->Promise.ignoreValue
+
+    Logging.trace("ClickHouse sink initialization completed successfully")
+  } catch {
+  | exn => {
+      Logging.errorWithExn(exn, "Failed to initialize ClickHouse sink")
+      Js.Exn.raiseError("ClickHouse initialization failed")
+    }
+  }
+}
+
+// Resume ClickHouse sink after reorg by deleting rows with checkpoint IDs higher than target
+let resume = async (client, ~database: string, ~checkpointId: float) => {
+  try {
+    // Try to use the database - will throw if it doesn't exist
+    try {
+      await client->exec({query: `USE ${database}`})
+    } catch {
+    | exn =>
+      Logging.errorWithExn(
+        exn,
+        `ClickHouse sink database "${database}" not found. Please run 'envio start -r' to reinitialize the indexer (it'll also drop Postgres database).`,
+      )
+      Js.Exn.raiseError("ClickHouse resume failed")
+    }
+
+    // Get all history tables
+    let tablesResult = await client->query({
+      query: `SHOW TABLES FROM ${database} LIKE '${EntityHistory.historyTablePrefix}%'`,
+    })
+    let tables: array<{"name": string}> = await tablesResult->json
+
+    // Delete rows with checkpoint IDs higher than the target for each history table
+    await Promise.all(
+      tables->Belt.Array.map(table => {
+        let tableName = table["name"]
+        client->exec({
+          query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->Belt.Float.toString}`,
+        })
+      }),
+    )->Promise.ignoreValue
+
+    // Delete stale checkpoints
+    await client->exec({
+      query: `DELETE FROM ${database}.\`${InternalTable.Checkpoints.table.tableName}\` WHERE \`${Table.idFieldName}\` > ${checkpointId->Belt.Float.toString}`,
+    })
+  } catch {
+  | Persistence.StorageError(_) as exn => raise(exn)
+  | exn => {
+      Logging.errorWithExn(exn, "Failed to resume ClickHouse sink")
+      Js.Exn.raiseError("ClickHouse resume failed")
+    }
+  }
+}

package/src/bindings/ClickHouse.res.js

@@ -0,0 +1,274 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Table = require("../db/Table.res.js");
+var Utils = require("../Utils.res.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Logging = require("../Logging.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Persistence = require("../Persistence.res.js");
+var EntityHistory = require("../db/EntityHistory.res.js");
+var InternalTable = require("../db/InternalTable.res.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+function getClickHouseFieldType(fieldType, isNullable, isArray) {
+  var baseType;
+  if (typeof fieldType !== "object") {
+    switch (fieldType) {
+      case "Boolean" :
+          baseType = "Bool";
+          break;
+      case "Uint32" :
+          baseType = "UInt32";
+          break;
+      case "Number" :
+          baseType = "Float64";
+          break;
+      case "Int32" :
+      case "Serial" :
+          baseType = "Int32";
+          break;
+      case "String" :
+      case "Json" :
+          baseType = "String";
+          break;
+      case "Date" :
+          baseType = "DateTime64(3, 'UTC')";
+          break;
+      
+    }
+  } else {
+    switch (fieldType.type) {
+      case "BigInt" :
+          var precision = fieldType.precision;
+          baseType = precision !== undefined && precision <= 38 ? "Decimal(" + precision.toString() + ",0)" : "String";
+          break;
+      case "BigDecimal" :
+          var config = fieldType.config;
+          if (config !== undefined) {
+            var scale = config[1];
+            var precision$1 = config[0];
+            baseType = precision$1 > 38 || scale > precision$1 ? "String" : "Decimal(" + precision$1.toString() + "," + scale.toString() + ")";
+          } else {
+            baseType = "String";
+          }
+          break;
+      case "Enum" :
+          var config$1 = fieldType.config;
+          var variantsLength = config$1.variants.length;
+          var enumType = variantsLength <= 127 ? "Enum8" : "Enum16";
+          var enumValues = Belt_Array.map(config$1.variants, (function (variant) {
+                    return "'" + variant + "'";
+                  })).join(", ");
+          baseType = enumType + "(" + enumValues + ")";
+          break;
+      case "Entity" :
+          baseType = "String";
+          break;
+      
+    }
+  }
+  var baseType$1 = isArray ? "Array(" + baseType + ")" : baseType;
+  if (isNullable) {
+    return "Nullable(" + baseType$1 + ")";
+  } else {
+    return baseType$1;
+  }
+}
+
+async function setCheckpointsOrThrow(client, batch, database) {
+  var checkpointsCount = batch.checkpointIds.length;
+  if (checkpointsCount === 0) {
+    return ;
+  }
+  var checkpointRows = [];
+  for(var idx = 0; idx < checkpointsCount; ++idx){
+    checkpointRows.push([
+          batch.checkpointIds[idx],
+          batch.checkpointChainIds[idx],
+          batch.checkpointBlockNumbers[idx],
+          batch.checkpointBlockHashes[idx],
+          batch.checkpointEventsProcessed[idx]
+        ]);
+  }
+  try {
+    return await client.insert({
+                table: database + ".\`" + InternalTable.Checkpoints.table.tableName + "\`",
+                values: checkpointRows,
+                format: "JSONCompactEachRow"
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    throw {
+          RE_EXN_ID: Persistence.StorageError,
+          message: "Failed to insert checkpoints into ClickHouse table \"" + InternalTable.Checkpoints.table.tableName + "\"",
+          reason: Utils.prettifyExn(exn),
+          Error: new Error()
+        };
+  }
+}
+
+async function setUpdatesOrThrow(client, updates, entityConfig, database) {
+  if (updates.length === 0) {
+    return ;
+  }
+  var cache = entityConfig.clickHouseSetUpdatesCache;
+  var match;
+  if (cache !== undefined) {
+    match = cache;
+  } else {
+    var cache_tableName = database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\`";
+    var cache_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
+              EntityHistory.makeSetUpdateSchema(entityConfig.schema),
+              S$RescriptSchema.object(function (s) {
+                    s.tag(EntityHistory.changeFieldName, "DELETE");
+                    return {
+                            type: "DELETE",
+                            entityId: s.f(Table.idFieldName, S$RescriptSchema.string),
+                            checkpointId: s.f(EntityHistory.checkpointIdFieldName, EntityHistory.unsafeCheckpointIdSchema)
+                          };
+                  })
+            ]), "Output", "Json", "Sync", false);
+    var cache$1 = {
+      tableName: cache_tableName,
+      convertOrThrow: cache_convertOrThrow
+    };
+    entityConfig.clickHouseSetUpdatesCache = cache$1;
+    match = cache$1;
+  }
+  var convertOrThrow = match.convertOrThrow;
+  var tableName = match.tableName;
+  try {
+    var values = updates.map(function (update) {
+          return convertOrThrow(update.latestChange);
+        });
+    return await client.insert({
+                table: tableName,
+                values: values,
+                format: "JSONEachRow"
+              });
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    throw {
+          RE_EXN_ID: Persistence.StorageError,
+          message: "Failed to insert items into ClickHouse table \"" + tableName + "\"",
+          reason: Utils.prettifyExn(exn),
+          Error: new Error()
+        };
+  }
+}
+
+function makeCreateHistoryTableQuery(entityConfig, database) {
+  var fieldDefinitions = Belt_Array.keepMap(entityConfig.table.fields, (function (field) {
+          if (field.TAG !== "Field") {
+            return ;
+          }
+          var field$1 = field._0;
+          var fieldName = Table.getDbFieldName(field$1);
+          var clickHouseType = getClickHouseFieldType(field$1.fieldType, field$1.isNullable, field$1.isArray);
+          return "\`" + fieldName + "\` " + clickHouseType;
+        }));
+  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\` (\n  " + fieldDefinitions.join(",\n  ") + ",\n  \`" + EntityHistory.checkpointIdFieldName + "\` " + getClickHouseFieldType("Uint32", false, false) + ",\n  \`" + EntityHistory.changeFieldName + "\` " + getClickHouseFieldType({
+              type: "Enum",
+              config: EntityHistory.RowAction.config
+            }, false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + Table.idFieldName + ", " + EntityHistory.checkpointIdFieldName + ")";
+}
+
+function makeCreateCheckpointsTableQuery(database) {
+  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` (\n  \`" + "id" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "chain_id" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_number" + "\` " + getClickHouseFieldType("Int32", false, false) + ",\n  \`" + "block_hash" + "\` " + getClickHouseFieldType("String", true, false) + ",\n  \`" + "events_processed" + "\` " + getClickHouseFieldType("Int32", false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + "id" + ")";
+}
+
+function makeCreateViewQuery(entityConfig, database) {
+  var historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  var checkpointsTableName = InternalTable.Checkpoints.table.tableName;
+  var entityFields = Belt_Array.keepMap(entityConfig.table.fields, (function (field) {
+            if (field.TAG !== "Field") {
+              return ;
+            }
+            var fieldName = Table.getDbFieldName(field._0);
+            return "\`" + fieldName + "\`";
+          })).join(", ");
+  return "CREATE VIEW IF NOT EXISTS " + database + ".\`" + entityConfig.name + "\` AS\nSELECT " + entityFields + "\nFROM (\n  SELECT " + entityFields + ", \`" + EntityHistory.changeFieldName + "\`\n  FROM " + database + ".\`" + historyTableName + "\`\n  WHERE \`" + EntityHistory.checkpointIdFieldName + "\` <= (SELECT max(" + "id" + ") FROM " + database + ".\`" + checkpointsTableName + "\`)\n  ORDER BY \`" + EntityHistory.checkpointIdFieldName + "\` DESC\n  LIMIT 1 BY \`" + Table.idFieldName + "\`\n)\nWHERE \`" + EntityHistory.changeFieldName + "\` = '" + "SET" + "'";
+}
+
+async function initialize(client, database, entities, param) {
+  try {
+    await client.exec({
+          query: "DROP DATABASE IF EXISTS " + database
+        });
+    await client.exec({
+          query: "CREATE DATABASE " + database
+        });
+    await client.exec({
+          query: "USE " + database
+        });
+    await Promise.all(Belt_Array.map(entities, (function (entityConfig) {
+                return client.exec({
+                            query: makeCreateHistoryTableQuery(entityConfig, database)
+                          });
+              })));
+    await client.exec({
+          query: makeCreateCheckpointsTableQuery(database)
+        });
+    await Promise.all(Belt_Array.map(entities, (function (entityConfig) {
+                return client.exec({
+                            query: makeCreateViewQuery(entityConfig, database)
+                          });
+              })));
+    return Logging.trace("ClickHouse sink initialization completed successfully");
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    Logging.errorWithExn(exn, "Failed to initialize ClickHouse sink");
+    return Js_exn.raiseError("ClickHouse initialization failed");
+  }
+}
+
+async function resume(client, database, checkpointId) {
+  try {
+    try {
+      await client.exec({
+            query: "USE " + database
+          });
+    }
+    catch (raw_exn){
+      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      Logging.errorWithExn(exn, "ClickHouse sink database \"" + database + "\" not found. Please run 'envio start -r' to reinitialize the indexer (it'll also drop Postgres database).");
+      Js_exn.raiseError("ClickHouse resume failed");
+    }
+    var tablesResult = await client.query({
+          query: "SHOW TABLES FROM " + database + " LIKE '" + EntityHistory.historyTablePrefix + "%'"
+        });
+    var tables = await tablesResult.json();
+    await Promise.all(Belt_Array.map(tables, (function (table) {
+                var tableName = table.name;
+                return client.exec({
+                            query: "ALTER TABLE " + database + ".\`" + tableName + "\` DELETE WHERE \`" + EntityHistory.checkpointIdFieldName + "\` > " + String(checkpointId)
+                          });
+              })));
+    return await client.exec({
+                query: "DELETE FROM " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` WHERE \`" + Table.idFieldName + "\` > " + String(checkpointId)
+              });
+  }
+  catch (raw_exn$1){
+    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+    if (exn$1.RE_EXN_ID === Persistence.StorageError) {
+      throw exn$1;
+    }
+    Logging.errorWithExn(exn$1, "Failed to resume ClickHouse sink");
+    return Js_exn.raiseError("ClickHouse resume failed");
+  }
+}
+
+exports.getClickHouseFieldType = getClickHouseFieldType;
+exports.setCheckpointsOrThrow = setCheckpointsOrThrow;
+exports.setUpdatesOrThrow = setUpdatesOrThrow;
+exports.makeCreateHistoryTableQuery = makeCreateHistoryTableQuery;
+exports.makeCreateCheckpointsTableQuery = makeCreateCheckpointsTableQuery;
+exports.makeCreateViewQuery = makeCreateViewQuery;
+exports.initialize = initialize;
+exports.resume = resume;
+/* Table Not a pure module */

package/src/bindings/Postgres.res

@@ -99,3 +99,18 @@ external makeSql: (~config: poolConfig) => sql = "postgres"
 @send
 external preparedUnsafe: (sql, string, unknown, @as(json`{prepare: true}`) _) => promise<'a> =
   "unsafe"
+
+@unboxed
+type columnType =
+  | @as("INTEGER") Integer
+  | @as("BIGINT") BigInt
+  | @as("BOOLEAN") Boolean
+  | @as("NUMERIC") Numeric
+  | @as("DOUBLE PRECISION") DoublePrecision
+  | @as("TEXT") Text
+  | @as("SERIAL") Serial
+  | @as("JSONB") JsonB
+  | @as("TIMESTAMP WITH TIME ZONE") TimestampWithTimezone
+  | @as("TIMESTAMP WITH TIME ZONE NULL") TimestampWithTimezoneNull
+  | @as("TIMESTAMP") TimestampWithoutTimezone
+  | Custom(string)