envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/bindings/ClickHouse.res.mjs

@@ -2,168 +2,159 @@
 
 import * as Table from "../db/Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Logging from "../Logging.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Persistence from "../Persistence.res.mjs";
 import * as EntityHistory from "../db/EntityHistory.res.mjs";
 import * as InternalTable from "../db/InternalTable.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function getClickHouseFieldType(fieldType, isNullable, isArray) {
-  var baseType;
+  let baseType;
   if (typeof fieldType !== "object") {
     switch (fieldType) {
       case "Boolean" :
-          baseType = "Bool";
-          break;
+        baseType = "Bool";
+        break;
       case "Uint32" :
-          baseType = "UInt32";
-          break;
+        baseType = "UInt32";
+        break;
       case "UInt52" :
       case "UInt64" :
-          baseType = "UInt64";
-          break;
+        baseType = "UInt64";
+        break;
       case "Number" :
-          baseType = "Float64";
-          break;
+        baseType = "Float64";
+        break;
       case "Int32" :
       case "Serial" :
-          baseType = "Int32";
-          break;
+        baseType = "Int32";
+        break;
       case "BigSerial" :
-          baseType = "Int64";
-          break;
+        baseType = "Int64";
+        break;
       case "String" :
       case "Json" :
-          baseType = "String";
-          break;
+        baseType = "String";
+        break;
       case "Date" :
-          baseType = "DateTime64(3, 'UTC')";
-          break;
-      
+        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;
+        let 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;
+        let config = fieldType.config;
+        if (config !== undefined) {
+          let scale = config[1];
+          let 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;
+        let config$1 = fieldType.config;
+        let variantsLength = config$1.variants.length;
+        let enumType = variantsLength <= 127 ? "Enum8" : "Enum16";
+        let enumValues = Belt_Array.map(config$1.variants, variant => `'` + variant + `'`).join(", ");
+        baseType = enumType + `(` + enumValues + `)`;
+        break;
       case "Entity" :
-          baseType = "String";
-          break;
-      
+        baseType = "String";
+        break;
     }
   }
-  var baseType$1 = isArray ? "Array(" + baseType + ")" : baseType;
+  let baseType$1 = isArray ? `Array(` + baseType + `)` : baseType;
   if (isNullable) {
-    return "Nullable(" + baseType$1 + ")";
+    return `Nullable(` + baseType$1 + `)`;
   } else {
     return baseType$1;
   }
 }
 
 function makeClickHouseEntitySchema(table) {
-  return S$RescriptSchema.schema(function (s) {
-              var dict = {};
-              Belt_Array.forEach(table.fields, (function (field) {
-                      if (field.TAG !== "Field") {
-                        return ;
-                      }
-                      var f = field._0;
-                      var fieldName = Table.getDbFieldName(f);
-                      var match = f.fieldType;
-                      var fieldSchema;
-                      if (typeof match !== "object") {
-                        switch (match) {
-                          case "UInt52" :
-                              var uint52Schema = S$RescriptSchema.preprocess(S$RescriptSchema.$$float, (function (param) {
-                                      return {
-                                              p: (function (unknown) {
-                                                  return Number(unknown);
-                                                })
-                                            };
-                                    }));
-                              fieldSchema = f.isNullable ? S$RescriptSchema.$$null(uint52Schema) : (
-                                  f.isArray ? S$RescriptSchema.array(uint52Schema) : uint52Schema
-                                );
-                              break;
-                          case "Date" :
-                              var dateSchema = Utils.Schema.clickHouseDate;
-                              fieldSchema = f.isNullable ? S$RescriptSchema.$$null(dateSchema) : (
-                                  f.isArray ? S$RescriptSchema.array(dateSchema) : dateSchema
-                                );
-                              break;
-                          default:
-                            fieldSchema = f.fieldSchema;
-                        }
-                      } else {
-                        fieldSchema = f.fieldSchema;
-                      }
-                      dict[fieldName] = s.m(fieldSchema);
-                    }));
-              return dict;
-            });
+  return S$RescriptSchema.schema(s => {
+    let dict = {};
+    Belt_Array.forEach(table.fields, field => {
+      if (field.TAG !== "Field") {
+        return;
+      }
+      let f = field._0;
+      let fieldName = Table.getDbFieldName(f);
+      let match = f.fieldType;
+      let fieldSchema;
+      if (typeof match !== "object") {
+        switch (match) {
+          case "UInt52" :
+            let uint52Schema = S$RescriptSchema.preprocess(S$RescriptSchema.float, param => ({
+              p: unknown => parseFloat(unknown)
+            }));
+            fieldSchema = f.isNullable ? S$RescriptSchema.$$null(uint52Schema) : (
+                f.isArray ? S$RescriptSchema.array(uint52Schema) : uint52Schema
+              );
+            break;
+          case "Date" :
+            let dateSchema = Utils.Schema.clickHouseDate;
+            fieldSchema = f.isNullable ? S$RescriptSchema.$$null(dateSchema) : (
+                f.isArray ? S$RescriptSchema.array(dateSchema) : dateSchema
+              );
+            break;
+          default:
+            fieldSchema = f.fieldSchema;
+        }
+      } else {
+        fieldSchema = f.fieldSchema;
+      }
+      dict[fieldName] = s.m(fieldSchema);
+    });
+    return dict;
+  });
 }
 
-var logger = Logging.createChild({
-      context: "ClickHouse"
-    });
+let logger = Logging.createChild({
+  context: "ClickHouse"
+});
 
 async function insertWithRetry(client, table, values, format, retriesOpt) {
-  var retries = retriesOpt !== undefined ? retriesOpt : 8;
+  let retries = retriesOpt !== undefined ? retriesOpt : 8;
   try {
     return await client.insert({
-                table: table,
-                values: values,
-                format: format
-              });
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      table: table,
+      values: values,
+      format: format
+    });
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     if (retries > 0) {
-      var delayMs = Math.min(1000, 100 + (Math.imul(900, 8 - retries | 0) / 7 | 0) | 0);
+      let delayMs = Math.min(1000, 100 + ((900 * (8 - retries | 0) | 0) / 7 | 0) | 0);
       if (values.length > 1) {
         Logging.childWarn(logger, {
-              msg: "ClickHouse insert failed, splitting batch in half and retrying",
-              table: table,
-              batchSize: values.length,
-              retriesLeft: retries,
-              err: Utils.prettifyExn(exn)
-            });
+          msg: "ClickHouse insert failed, splitting batch in half and retrying",
+          table: table,
+          batchSize: values.length,
+          retriesLeft: retries,
+          err: Utils.prettifyExn(exn)
+        });
         await Utils.delay(delayMs);
-        var mid = (values.length >> 1);
-        var first = values.slice(0, mid);
-        var second = values.slice(mid);
+        let mid = (values.length >> 1);
+        let first = values.slice(0, mid);
+        let second = values.slice(mid);
         await insertWithRetry(client, table, first, format, retries - 1 | 0);
         return await insertWithRetry(client, table, second, format, retries - 1 | 0);
       }
       Logging.childWarn(logger, {
-            msg: "ClickHouse insert failed, retrying after delay",
-            table: table,
-            retriesLeft: retries,
-            err: Utils.prettifyExn(exn)
-          });
+        msg: "ClickHouse insert failed, retrying after delay",
+        table: table,
+        retriesLeft: retries,
+        err: Utils.prettifyExn(exn)
+      });
       await Utils.delay(delayMs);
       return await insertWithRetry(client, table, values, format, retries - 1 | 0);
     }
@@ -172,144 +163,158 @@ async function insertWithRetry(client, table, values, format, retriesOpt) {
 }
 
 async function setCheckpointsOrThrow(client, batch, database) {
-  var checkpointsCount = batch.checkpointIds.length;
+  let checkpointsCount = batch.checkpointIds.length;
   if (checkpointsCount === 0) {
-    return ;
+    return;
   }
-  var checkpointRows = [];
-  for(var idx = 0; idx < checkpointsCount; ++idx){
+  let checkpointRows = [];
+  for (let idx = 0; idx < checkpointsCount; ++idx) {
     checkpointRows.push([
-          batch.checkpointIds[idx].toString(),
-          batch.checkpointChainIds[idx],
-          batch.checkpointBlockNumbers[idx],
-          batch.checkpointBlockHashes[idx],
-          batch.checkpointEventsProcessed[idx]
-        ]);
+      batch.checkpointIds[idx].toString(),
+      batch.checkpointChainIds[idx],
+      batch.checkpointBlockNumbers[idx],
+      batch.checkpointBlockHashes[idx],
+      batch.checkpointEventsProcessed[idx]
+    ]);
   }
   try {
-    return await insertWithRetry(client, database + ".\`" + InternalTable.Checkpoints.table.tableName + "\`", checkpointRows, "JSONCompactEachRow", undefined);
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return await insertWithRetry(client, database + `.\`` + InternalTable.Checkpoints.table.tableName + `\``, checkpointRows, "JSONCompactEachRow", undefined);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(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()
-        };
+      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, cache, updates, entityConfig, database) {
   if (updates.length === 0) {
-    return ;
+    return;
   }
-  var cached = cache.get(entityConfig);
-  var match;
+  let cached = cache.get(entityConfig);
+  let match;
   if (cached !== undefined) {
     match = cached;
   } else {
-    var cached_tableName = database + ".\`" + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + "\`";
-    var cached_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
-              EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
-              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 cached$1 = {
+    let cached_tableName = database + `.\`` + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + `\``;
+    let cached_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
+      EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
+      S$RescriptSchema.object(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);
+    let cached$1 = {
       tableName: cached_tableName,
       convertOrThrow: cached_convertOrThrow
     };
     cache.set(entityConfig, cached$1);
     match = cached$1;
   }
-  var convertOrThrow = match.convertOrThrow;
-  var tableName = match.tableName;
+  let convertOrThrow = match.convertOrThrow;
+  let tableName = match.tableName;
   try {
-    var values = updates.map(function (update) {
-          return convertOrThrow(update.latestChange);
-        });
+    let values = updates.map(update => convertOrThrow(update.latestChange));
     return await insertWithRetry(client, tableName, values, "JSONEachRow", undefined);
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
-          RE_EXN_ID: Persistence.StorageError,
-          message: "Failed to insert items into ClickHouse table \"" + tableName + "\"",
-          reason: Utils.prettifyExn(exn),
-          Error: new Error()
-        };
+      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("UInt64", false, false) + ",\n  \`" + EntityHistory.changeFieldName + "\` " + getClickHouseFieldType({
-              type: "Enum",
-              config: EntityHistory.RowAction.config
-            }, false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + Table.idFieldName + ", " + EntityHistory.checkpointIdFieldName + ")";
+  let fieldDefinitions = Belt_Array.keepMap(entityConfig.table.fields, field => {
+    if (field.TAG !== "Field") {
+      return;
+    }
+    let field$1 = field._0;
+    let fieldName = Table.getDbFieldName(field$1);
+    let 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) + `\` (
+  ` + fieldDefinitions.join(",\n  ") + `,
+  \`` + EntityHistory.checkpointIdFieldName + `\` ` + getClickHouseFieldType("UInt64", false, false) + `,
+  \`` + EntityHistory.changeFieldName + `\` ` + getClickHouseFieldType({
+    type: "Enum",
+    config: EntityHistory.RowAction.config
+  }, false, false) + `
+)
+ENGINE = MergeTree()
+ORDER BY (` + Table.idFieldName + `, ` + EntityHistory.checkpointIdFieldName + `)`;
 }
 
 function makeCreateCheckpointsTableQuery(database) {
-  return "CREATE TABLE IF NOT EXISTS " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` (\n  \`" + "id" + "\` " + getClickHouseFieldType("UInt64", 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("UInt64", false, false) + "\n)\nENGINE = MergeTree()\nORDER BY (" + "id" + ")";
+  return `CREATE TABLE IF NOT EXISTS ` + database + `.\`` + InternalTable.Checkpoints.table.tableName + `\` (
+  \`` + "id" + `\` ` + getClickHouseFieldType("UInt64", false, false) + `,
+  \`` + "chain_id" + `\` ` + getClickHouseFieldType("Int32", false, false) + `,
+  \`` + "block_number" + `\` ` + getClickHouseFieldType("Int32", false, false) + `,
+  \`` + "block_hash" + `\` ` + getClickHouseFieldType("String", true, false) + `,
+  \`` + "events_processed" + `\` ` + getClickHouseFieldType("UInt64", false, false) + `
+)
+ENGINE = MergeTree()
+ORDER 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" + "'";
+  let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
+  let checkpointsTableName = InternalTable.Checkpoints.table.tableName;
+  let entityFields = Belt_Array.keepMap(entityConfig.table.fields, field => {
+    if (field.TAG !== "Field") {
+      return;
+    }
+    let fieldName = Table.getDbFieldName(field._0);
+    return `\`` + fieldName + `\``;
+  }).join(", ");
+  return `CREATE VIEW IF NOT EXISTS ` + database + `.\`` + entityConfig.name + `\` AS
+SELECT ` + entityFields + `
+FROM (
+  SELECT ` + entityFields + `, \`` + EntityHistory.changeFieldName + `\`
+  FROM ` + database + `.\`` + historyTableName + `\`
+  WHERE \`` + EntityHistory.checkpointIdFieldName + `\` <= (SELECT max(` + "id" + `) FROM ` + database + `.\`` + checkpointsTableName + `\`)
+  ORDER BY \`` + EntityHistory.checkpointIdFieldName + `\` DESC
+  LIMIT 1 BY \`` + Table.idFieldName + `\`
+)
+WHERE \`` + EntityHistory.changeFieldName + `\` = '` + "SET" + `'`;
 }
 
 async function initialize(client, database, entities, param) {
   try {
     await client.exec({
-          query: "TRUNCATE DATABASE IF EXISTS " + database
-        });
+      query: `TRUNCATE DATABASE IF EXISTS ` + database
+    });
     await client.exec({
-          query: "CREATE DATABASE IF NOT EXISTS " + database
-        });
+      query: `CREATE DATABASE IF NOT EXISTS ` + database
+    });
     await client.exec({
-          query: "USE " + database
-        });
-    await Promise.all(Belt_Array.map(entities, (function (entityConfig) {
-                return client.exec({
-                            query: makeCreateHistoryTableQuery(entityConfig, database)
-                          });
-              })));
+      query: `USE ` + database
+    });
+    await Promise.all(Belt_Array.map(entities, entityConfig => 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)
-                          });
-              })));
+      query: makeCreateCheckpointsTableQuery(database)
+    });
+    await Promise.all(Belt_Array.map(entities, entityConfig => 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);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     Logging.errorWithExn(exn, "Failed to initialize ClickHouse sink");
-    return Js_exn.raiseError("ClickHouse initialization failed");
+    return Stdlib_JsError.throwWithMessage("ClickHouse initialization failed");
   }
 }
 
@@ -317,49 +322,47 @@ 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");
+        query: `USE ` + database
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(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).`);
+      Stdlib_JsError.throwWithMessage("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 + "\` > " + checkpointId.toString()
-                          });
-              })));
+    let tablesResult = await client.query({
+      query: `SHOW TABLES FROM ` + database + ` LIKE '` + EntityHistory.historyTablePrefix + `%'`
+    });
+    let tables = await tablesResult.json();
+    await Promise.all(Belt_Array.map(tables, table => {
+      let tableName = table.name;
+      return client.exec({
+        query: `ALTER TABLE ` + database + `.\`` + tableName + `\` DELETE WHERE \`` + EntityHistory.checkpointIdFieldName + `\` > ` + checkpointId.toString()
+      });
+    }));
     return await client.exec({
-                query: "DELETE FROM " + database + ".\`" + InternalTable.Checkpoints.table.tableName + "\` WHERE \`" + Table.idFieldName + "\` > " + checkpointId.toString()
-              });
-  }
-  catch (raw_exn$1){
-    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+      query: `DELETE FROM ` + database + `.\`` + InternalTable.Checkpoints.table.tableName + `\` WHERE \`` + Table.idFieldName + `\` > ` + checkpointId.toString()
+    });
+  } catch (raw_exn$1) {
+    let exn$1 = Primitive_exceptions.internalToException(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");
+    return Stdlib_JsError.throwWithMessage("ClickHouse resume failed");
   }
 }
 
 export {
-  getClickHouseFieldType ,
-  makeClickHouseEntitySchema ,
-  logger ,
-  insertWithRetry ,
-  setCheckpointsOrThrow ,
-  setUpdatesOrThrow ,
-  makeCreateHistoryTableQuery ,
-  makeCreateCheckpointsTableQuery ,
-  makeCreateViewQuery ,
-  initialize ,
-  resume ,
+  getClickHouseFieldType,
+  makeClickHouseEntitySchema,
+  logger,
+  insertWithRetry,
+  setCheckpointsOrThrow,
+  setUpdatesOrThrow,
+  makeCreateHistoryTableQuery,
+  makeCreateCheckpointsTableQuery,
+  makeCreateViewQuery,
+  initialize,
+  resume,
 }
 /* logger Not a pure module */