squel 6.2.0 → 6.3.0

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "squel",
-  version: "6.2.0",
+  version: "6.3.0",
   description: "SQL query string builder",
   keywords: [
     "sql",
@@ -107,7 +107,7 @@ function _clone(src) {
   if (_isPlainObject(src) || _isArray(src)) {
     const ret = new anySrc.constructor;
     for (const key of Object.getOwnPropertyNames(src)) {
-      if (typeof anySrc[key] !== "function") {
+      if (typeof anySrc[key] !== "function" && key !== "_queryBuilder") {
         ret[key] = _clone(anySrc[key]);
       }
     }
@@ -530,6 +530,178 @@ function _buildSquel(flavour = null) {
       return { text: totalStr, values: totalValues };
     }
   };
+  cls.Over = class extends cls.BaseBuilder {
+    _funcExpr;
+    _funcParams;
+    _partitionFields;
+    _orderFields;
+    _rows;
+    _range;
+    constructor(funcExpr, funcParams = [], options) {
+      super(options);
+      this._funcExpr = funcExpr;
+      this._funcParams = funcParams || [];
+      this._partitionFields = [];
+      this._orderFields = [];
+      this._rows = null;
+      this._range = null;
+    }
+    partitionBy(...fields) {
+      let flatFields = [];
+      for (const field of fields) {
+        if (_isArray(field)) {
+          flatFields = flatFields.concat(field);
+        } else {
+          flatFields.push(field);
+        }
+      }
+      for (const field of flatFields) {
+        this._partitionFields.push(this._sanitizeField(field));
+      }
+      return this;
+    }
+    orderBy(field, dir, ...values) {
+      field = this._sanitizeField(field);
+      let direction;
+      if (typeof dir === "string") {
+        direction = dir;
+      } else if (dir === undefined) {
+        direction = "ASC";
+      } else if (dir === null) {
+        direction = null;
+      } else {
+        direction = dir ? "ASC" : "DESC";
+      }
+      this._orderFields.push({ field, dir: direction, values: values || [] });
+      return this;
+    }
+    rowsBetween(start, end) {
+      if (end === undefined) {
+        this._rows = `ROWS BETWEEN ${start}`;
+      } else {
+        this._rows = `ROWS BETWEEN ${start} AND ${end}`;
+      }
+      this._range = null;
+      return this;
+    }
+    rangeBetween(start, end) {
+      if (end === undefined) {
+        this._range = `RANGE BETWEEN ${start}`;
+      } else {
+        this._range = `RANGE BETWEEN ${start} AND ${end}`;
+      }
+      this._rows = null;
+      return this;
+    }
+    _toParamString(options = {}) {
+      const values = [];
+      let funcRet;
+      if (cls.isSquelBuilder(this._funcExpr)) {
+        funcRet = this._funcExpr._toParamString({
+          buildParameterized: options.buildParameterized
+        });
+      } else {
+        funcRet = this._buildString(this._funcExpr, this._funcParams, {
+          buildParameterized: options.buildParameterized
+        });
+      }
+      funcRet.values.forEach((v) => values.push(v));
+      let overPartsStr = "";
+      if (this._partitionFields.length > 0) {
+        let partitionStr = "";
+        for (const field of this._partitionFields) {
+          partitionStr = _pad(partitionStr, ", ");
+          if (cls.isSquelBuilder(field)) {
+            const ret = field._toParamString({
+              buildParameterized: options.buildParameterized
+            });
+            partitionStr += ret.text;
+            ret.values.forEach((v) => values.push(v));
+          } else {
+            partitionStr += this._formatFieldName(field);
+          }
+        }
+        overPartsStr = `PARTITION BY ${partitionStr}`;
+      }
+      if (this._orderFields.length > 0) {
+        let orderStr = "";
+        for (const { field, dir, values: orderVals } of this._orderFields) {
+          orderStr = _pad(orderStr, ", ");
+          let ret;
+          if (cls.isSquelBuilder(field)) {
+            ret = field._toParamString({
+              buildParameterized: options.buildParameterized
+            });
+          } else {
+            ret = this._buildString(field, orderVals, {
+              buildParameterized: options.buildParameterized
+            });
+          }
+          orderStr += ret.text;
+          ret.values.forEach((v) => values.push(v));
+          if (dir !== null) {
+            orderStr += ` ${dir}`;
+          }
+        }
+        overPartsStr = _pad(overPartsStr, " ") + `ORDER BY ${orderStr}`;
+      }
+      const frameClause = this._rows || this._range;
+      if (frameClause) {
+        overPartsStr = _pad(overPartsStr, " ") + frameClause;
+      }
+      return {
+        text: `${funcRet.text} OVER (${overPartsStr})`,
+        values
+      };
+    }
+  };
+  cls.JsonExtract = class extends cls.BaseBuilder {
+    _field;
+    _path;
+    constructor(field, path, options) {
+      super(options);
+      this._field = field;
+      this._path = path;
+    }
+    _toParamString(options = {}) {
+      const values = [];
+      let fieldStr = "";
+      if (cls.isSquelBuilder(this._field)) {
+        const ret = this._field._toParamString({
+          buildParameterized: options.buildParameterized
+        });
+        fieldStr = ret.text;
+        ret.values.forEach((v) => values.push(v));
+      } else {
+        fieldStr = this._formatFieldName(this._field);
+      }
+      let cleanPath = this._path;
+      if (cleanPath.startsWith("$")) {
+        cleanPath = cleanPath.slice(1);
+      }
+      if (cleanPath.startsWith(".")) {
+        cleanPath = cleanPath.slice(1);
+      }
+      const parts = cleanPath.split(".").filter(Boolean);
+      let sql = "";
+      if (flavour === "postgres") {
+        if (parts.length === 0) {
+          sql = fieldStr;
+        } else {
+          sql = fieldStr;
+          for (let i = 0;i < parts.length; i++) {
+            const op = i === parts.length - 1 ? "->>" : "->";
+            sql += `${op}'${parts[i]}'`;
+          }
+        }
+      } else if (flavour === "mssql") {
+        sql = `JSON_VALUE(${fieldStr}, '${this._path}')`;
+      } else {
+        sql = `json_extract(${fieldStr}, '${this._path}')`;
+      }
+      return { text: sql, values };
+    }
+  };
   cls.Block = class extends cls.BaseBuilder {
     constructor(options) {
       super(options);
@@ -1043,7 +1215,7 @@ function _buildSquel(flavour = null) {
     _toParamString(options = {}) {
       let totalStr = "";
       const totalValues = [];
-      for (const { type, table, alias, condition } of this._joins) {
+      for (const { type, table, alias, condition, isApply } of this._joins) {
         totalStr = _pad(totalStr, this.options.separator);
         let tableStr;
         if (cls.isSquelBuilder(table)) {
@@ -1056,7 +1228,11 @@ function _buildSquel(flavour = null) {
         } else {
           tableStr = this._formatTableName(table);
         }
-        totalStr += `${type} JOIN ${tableStr}`;
+        if (isApply) {
+          totalStr += `${type} ${tableStr}`;
+        } else {
+          totalStr += `${type} JOIN ${tableStr}`;
+        }
         if (alias)
           totalStr += ` ${this._formatTableAlias(alias)}`;
         if (condition) {
@@ -1129,12 +1305,93 @@ function _buildSquel(flavour = null) {
       };
     }
   };
+  cls.WithBlock = class extends cls.Block {
+    _tables;
+    constructor(options) {
+      super(options);
+      this._tables = [];
+    }
+    with(alias, table) {
+      this._tables.push({ alias, table, recursive: false });
+    }
+    withRecursive(alias, table) {
+      this._tables.push({ alias, table, recursive: true });
+    }
+    _toParamString(options = {}) {
+      const parts = [];
+      const values = [];
+      let anyRecursive = false;
+      for (const { alias, table, recursive } of this._tables) {
+        if (recursive) {
+          anyRecursive = true;
+        }
+        const ret = table._toParamString({
+          buildParameterized: options.buildParameterized,
+          nested: true
+        });
+        parts.push(`${alias} AS ${ret.text}`);
+        ret.values.forEach((v) => values.push(v));
+      }
+      if (!parts.length) {
+        return { text: "", values: [] };
+      }
+      const isMssql = this.options.useRecursiveKeyword === false;
+      const prefix = anyRecursive && !isMssql ? "WITH RECURSIVE" : "WITH";
+      return {
+        text: `${prefix} ${parts.join(", ")}`,
+        values
+      };
+    }
+  };
+  cls.ReturningBlock = class extends cls.Block {
+    _fields;
+    constructor(options) {
+      super(options);
+      this._fields = [];
+    }
+    returning(field, alias = null, options = {}) {
+      alias = alias ? this._sanitizeFieldAlias(alias) : alias;
+      field = this._sanitizeField(field);
+      const existingField = this._fields.filter((f) => f.name === field && f.alias === alias);
+      if (existingField.length)
+        return this;
+      this._fields.push({ name: field, alias, options });
+    }
+    _toParamString(options = {}) {
+      const { buildParameterized } = options;
+      let totalStr = "";
+      const totalValues = [];
+      for (const field of this._fields) {
+        totalStr = _pad(totalStr, ", ");
+        const { name, alias, options: fieldOptions } = field;
+        if (typeof name === "string") {
+          totalStr += this._formatFieldName(name, fieldOptions);
+        } else {
+          const ret = name._toParamString({ nested: true, buildParameterized });
+          totalStr += ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+        if (alias)
+          totalStr += ` AS ${this._formatFieldAlias(alias)}`;
+      }
+      return {
+        text: totalStr.length > 0 ? `RETURNING ${totalStr}` : "",
+        values: totalValues
+      };
+    }
+  };
   cls.QueryBuilder = class extends cls.BaseBuilder {
     blocks;
     constructor(options, blocks) {
       super(options);
       this.blocks = blocks || [];
       for (const block of this.blocks) {
+        Object.defineProperty(block, "_queryBuilder", {
+          value: this,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        });
         const exposedMethods = block.exposedMethods();
         for (const methodName in exposedMethods) {
           const methodBody = exposedMethods[methodName];
@@ -1143,7 +1400,10 @@ function _buildSquel(flavour = null) {
           }
           ((b, name, body) => {
             this[name] = (...args) => {
-              body.call(b, ...args);
+              const ret = body.call(b, ...args);
+              if (ret !== undefined && ret !== b) {
+                return ret;
+              }
               return this;
             };
           })(block, methodName, methodBody);
@@ -1199,6 +1459,7 @@ function _buildSquel(flavour = null) {
   cls.Select = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "SELECT"),
         new cls.FunctionBlock(options),
         new cls.DistinctBlock(options),
@@ -1220,12 +1481,14 @@ function _buildSquel(flavour = null) {
   cls.Update = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "UPDATE"),
         new cls.UpdateTableBlock(options),
         new cls.SetFieldBlock(options),
         new cls.WhereBlock(options),
         new cls.OrderByBlock(options),
-        new cls.LimitBlock(options)
+        new cls.LimitBlock(options),
+        new cls.ReturningBlock(options)
       ];
       super(options, blocks);
     }
@@ -1233,13 +1496,15 @@ function _buildSquel(flavour = null) {
   cls.Delete = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "DELETE"),
         new cls.TargetTableBlock(options),
         new cls.FromTableBlock(_extend({}, options, { singleTable: true })),
         new cls.JoinBlock(options),
         new cls.WhereBlock(options),
         new cls.OrderByBlock(options),
-        new cls.LimitBlock(options)
+        new cls.LimitBlock(options),
+        new cls.ReturningBlock(options)
       ];
       super(options, blocks);
     }
@@ -1247,10 +1512,12 @@ function _buildSquel(flavour = null) {
   cls.Insert = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "INSERT"),
         new cls.IntoTableBlock(options),
         new cls.InsertFieldValueBlock(options),
-        new cls.InsertFieldsFromQueryBlock(options)
+        new cls.InsertFieldsFromQueryBlock(options),
+        new cls.ReturningBlock(options)
       ];
       super(options, blocks);
     }
@@ -1274,6 +1541,8 @@ function _buildSquel(flavour = null) {
       inst.function(...args);
       return inst;
     },
+    over: (funcExpr, ...funcParams) => new cls.Over(funcExpr, funcParams),
+    jsonExtract: (field, path) => new cls.JsonExtract(field, path),
     registerValueHandler: cls.registerValueHandler
   };
   _squel.remove = _squel.delete;
@@ -1299,10 +1568,40 @@ var core_default = squel;
 // src/mysql.ts
 squel.flavours.mysql = (_squel) => {
   const cls = _squel.cls;
+
+  class MysqlOnDuplicateKeyUpdateHelper {
+    builder;
+    block;
+    constructor(builder, block) {
+      this.builder = builder;
+      this.block = block;
+    }
+  }
   cls.MysqlOnDuplicateKeyUpdateBlock = class extends cls.AbstractSetFieldBlock {
     onDupUpdate(field, value, options) {
       this._set(field, value, options);
     }
+    onDuplicateKeyUpdate() {
+      const helper = new MysqlOnDuplicateKeyUpdateHelper(this._queryBuilder, this);
+      return new Proxy(helper, {
+        get(target, prop, receiver) {
+          if (prop === "set") {
+            return (field, value, options) => {
+              target.block._set(field, value, options);
+              return receiver;
+            };
+          }
+          const val = target.builder[prop];
+          if (typeof val === "function") {
+            return (...args) => {
+              const ret = val.apply(target.builder, args);
+              return ret === target.builder ? receiver : ret;
+            };
+          }
+          return val;
+        }
+      });
+    }
     _toParamString(options = {}) {
       let totalStr = "";
       const totalValues = [];
@@ -1331,6 +1630,7 @@ squel.flavours.mysql = (_squel) => {
   cls.Insert = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "INSERT"),
         new cls.IntoTableBlock(options),
         new cls.InsertFieldValueBlock(options),
@@ -1343,6 +1643,7 @@ squel.flavours.mysql = (_squel) => {
   cls.Replace = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "REPLACE"),
         new cls.IntoTableBlock(options),
         new cls.InsertFieldValueBlock(options),
@@ -1361,6 +1662,15 @@ squel.flavours.postgres = (_squel) => {
   cls.DefaultQueryBuilderOptions.numberedParametersStartAt = 1;
   cls.DefaultQueryBuilderOptions.autoQuoteAliasNames = false;
   cls.DefaultQueryBuilderOptions.useAsForTableAliasNames = true;
+
+  class PostgresOnConflictUpdateHelper {
+    builder;
+    block;
+    constructor(builder, block) {
+      this.builder = builder;
+      this.block = block;
+    }
+  }
   cls.PostgresOnConflictKeyUpdateBlock = class extends cls.AbstractSetFieldBlock {
     _onConflict;
     _dupFields;
@@ -1371,17 +1681,46 @@ squel.flavours.postgres = (_squel) => {
     }
     onConflict(conflictFields, fields) {
       this._onConflict = true;
-      if (!conflictFields)
-        return;
-      if (!_isArray(conflictFields)) {
-        conflictFields = [conflictFields];
+      if (conflictFields) {
+        if (!_isArray(conflictFields)) {
+          conflictFields = [conflictFields];
+        }
+        this._dupFields = conflictFields.map(this._sanitizeField.bind(this));
       }
-      this._dupFields = conflictFields.map(this._sanitizeField.bind(this));
       if (fields) {
         Object.keys(fields).forEach((key) => {
           this._set(key, fields[key]);
         });
       }
+      return this._queryBuilder;
+    }
+    doUpdate() {
+      const helper = new PostgresOnConflictUpdateHelper(this._queryBuilder, this);
+      return new Proxy(helper, {
+        get(target, prop, receiver) {
+          if (prop === "set") {
+            return (field, value, options) => {
+              target.block._set(field, value, options);
+              return receiver;
+            };
+          }
+          const val = target.builder[prop];
+          if (typeof val === "function") {
+            return (...args) => {
+              const ret = val.apply(target.builder, args);
+              return ret === target.builder ? receiver : ret;
+            };
+          }
+          return val;
+        }
+      });
+    }
+    doNothing() {
+      this._onConflict = true;
+      this._fields = [];
+      this._values = [[]];
+      this._valueOptions = [[]];
+      return this._queryBuilder;
     }
     _toParamString(options = {}) {
       let totalStr = "";
@@ -1411,69 +1750,6 @@ squel.flavours.postgres = (_squel) => {
       return returned;
     }
   };
-  cls.ReturningBlock = class extends cls.Block {
-    _fields;
-    constructor(options) {
-      super(options);
-      this._fields = [];
-    }
-    returning(field, alias = null, options = {}) {
-      alias = alias ? this._sanitizeFieldAlias(alias) : alias;
-      field = this._sanitizeField(field);
-      const existingField = this._fields.filter((f) => f.name === field && f.alias === alias);
-      if (existingField.length)
-        return this;
-      this._fields.push({ name: field, alias, options });
-    }
-    _toParamString(options = {}) {
-      const { buildParameterized } = options;
-      let totalStr = "";
-      const totalValues = [];
-      for (const field of this._fields) {
-        totalStr = _pad(totalStr, ", ");
-        const { name, alias, options: fieldOptions } = field;
-        if (typeof name === "string") {
-          totalStr += this._formatFieldName(name, fieldOptions);
-        } else {
-          const ret = name._toParamString({ nested: true, buildParameterized });
-          totalStr += ret.text;
-          ret.values.forEach((v) => totalValues.push(v));
-        }
-        if (alias)
-          totalStr += ` AS ${this._formatFieldAlias(alias)}`;
-      }
-      return {
-        text: totalStr.length > 0 ? `RETURNING ${totalStr}` : "",
-        values: totalValues
-      };
-    }
-  };
-  cls.WithBlock = class extends cls.Block {
-    _tables;
-    constructor(options) {
-      super(options);
-      this._tables = [];
-    }
-    with(alias, table) {
-      this._tables.push({ alias, table });
-    }
-    _toParamString(options = {}) {
-      const parts = [];
-      const values = [];
-      for (const { alias, table } of this._tables) {
-        const ret = table._toParamString({
-          buildParameterized: options.buildParameterized,
-          nested: true
-        });
-        parts.push(`${alias} AS ${ret.text}`);
-        ret.values.forEach((v) => values.push(v));
-      }
-      return {
-        text: parts.length ? `WITH ${parts.join(", ")}` : "",
-        values
-      };
-    }
-  };
   cls.UsingBlock = class extends cls.AbstractTableBlock {
     constructor(options) {
       super({ ...options, prefix: "USING" });
@@ -1587,6 +1863,7 @@ squel.flavours.mssql = (_squel) => {
   cls.DefaultQueryBuilderOptions.replaceSingleQuotes = true;
   cls.DefaultQueryBuilderOptions.autoQuoteAliasNames = false;
   cls.DefaultQueryBuilderOptions.numberedParametersPrefix = "@";
+  cls.DefaultQueryBuilderOptions.useRecursiveKeyword = false;
   _squel.registerValueHandler(Date, (value) => {
     const date = value;
     return `'${date.getUTCFullYear()}-${date.getUTCMonth() + 1}-${date.getUTCDate()} ${date.getUTCHours()}:${date.getUTCMinutes()}:${date.getUTCSeconds()}'`;
@@ -1686,19 +1963,36 @@ squel.flavours.mssql = (_squel) => {
       super(options);
       this._outputs = [];
     }
-    output(fields) {
-      if (typeof fields === "string") {
-        this._outputs.push(`INSERTED.${this._sanitizeField(fields)}`);
-      } else {
-        fields.forEach((f) => {
-          this._outputs.push(`INSERTED.${this._sanitizeField(f)}`);
+    outputs(outputs) {
+      for (const output in outputs) {
+        this.output(output, outputs[output]);
+      }
+    }
+    output(output, alias = null) {
+      if (typeof output === "string") {
+        output = this._sanitizeField(output);
+        alias = alias ? this._sanitizeFieldAlias(alias) : alias;
+        this._outputs.push({
+          name: `INSERTED.${output}`,
+          alias
+        });
+      } else if (Array.isArray(output)) {
+        output.forEach((f) => {
+          this.output(f);
         });
       }
     }
     _toParamString(options) {
       const ret = super._toParamString(options);
       if (ret.text.length && this._outputs.length > 0) {
-        const innerStr = `OUTPUT ${this._outputs.join(", ")} `;
+        const parts = this._outputs.map((o) => {
+          let str = o.name;
+          if (o.alias) {
+            str += ` AS ${this._formatFieldAlias(o.alias)}`;
+          }
+          return str;
+        });
+        const innerStr = `OUTPUT ${parts.join(", ")} `;
         const valuesPos = ret.text.indexOf("VALUES");
         ret.text = ret.text.substring(0, valuesPos) + innerStr + ret.text.substring(valuesPos);
       }
@@ -1739,16 +2033,40 @@ squel.flavours.mssql = (_squel) => {
       return { text: totalStr, values: [] };
     }
   };
+  cls.MssqlJoinBlock = class extends cls.JoinBlock {
+    apply(table, alias = null, type = "CROSS") {
+      table = this._sanitizeTable(table, true);
+      alias = alias ? this._sanitizeTableAlias(alias) : alias;
+      let applyType = type.toUpperCase();
+      if (!applyType.endsWith("APPLY")) {
+        applyType = `${applyType} APPLY`;
+      }
+      this._joins.push({
+        type: applyType,
+        table,
+        alias,
+        condition: null,
+        isApply: true
+      });
+    }
+    cross_apply(table, alias = null) {
+      this.apply(table, alias, "CROSS");
+    }
+    outer_apply(table, alias = null) {
+      this.apply(table, alias, "OUTER");
+    }
+  };
   cls.Select = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       const limitOffsetTopBlock = new cls.MssqlLimitOffsetTopBlock(options);
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "SELECT"),
         new cls.DistinctBlock(options),
         limitOffsetTopBlock.TOP(),
         new cls.GetFieldBlock(options),
         new cls.FromTableBlock(options),
-        new cls.JoinBlock(options),
+        new cls.MssqlJoinBlock(options),
         new cls.WhereBlock(options),
         new cls.GroupByBlock(options),
         new cls.HavingBlock(options),
@@ -1763,6 +2081,7 @@ squel.flavours.mssql = (_squel) => {
   cls.Update = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "UPDATE"),
         new cls.MssqlUpdateTopBlock(options),
         new cls.UpdateTableBlock(options),
@@ -1776,6 +2095,7 @@ squel.flavours.mssql = (_squel) => {
   cls.Delete = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "DELETE"),
         new cls.TargetTableBlock(options),
         new cls.FromTableBlock(_extend({}, options, { singleTable: true })),
@@ -1791,6 +2111,7 @@ squel.flavours.mssql = (_squel) => {
   cls.Insert = class extends cls.QueryBuilder {
     constructor(options, blocks = null) {
       blocks = blocks || [
+        new cls.WithBlock(options),
         new cls.StringBlock(options, "INSERT"),
         new cls.IntoTableBlock(options),
         new cls.MssqlInsertFieldValueBlock(options),
@@ -1799,6 +2120,199 @@ squel.flavours.mssql = (_squel) => {
       super(options, blocks);
     }
   };
+  cls.MergeIntoBlock = class extends cls.Block {
+    _table = null;
+    _alias = null;
+    into(table, alias = null) {
+      this._table = this._sanitizeTable(table);
+      this._alias = alias ? this._sanitizeTableAlias(alias) : null;
+    }
+    _toParamString() {
+      if (!this._table)
+        throw new Error("into() needs to be called");
+      let str = this._formatTableName(this._table);
+      if (this._alias) {
+        str += ` AS ${this._formatTableAlias(this._alias)}`;
+      }
+      return { text: str, values: [] };
+    }
+  };
+  cls.MergeUsingBlock = class extends cls.Block {
+    _source = null;
+    _alias = null;
+    _condition = null;
+    using(source, alias = null, condition = null) {
+      this._source = typeof source === "string" ? this._sanitizeTable(source) : this._sanitizeBaseBuilder(source);
+      this._alias = alias ? this._sanitizeTableAlias(alias) : null;
+      this._condition = condition ? this._sanitizeExpression(condition) : null;
+    }
+    _toParamString(options = {}) {
+      if (!this._source)
+        throw new Error("using() needs to be called");
+      let sourceStr = "";
+      const values = [];
+      if (typeof this._source === "string") {
+        sourceStr = this._formatTableName(this._source);
+      } else {
+        const ret = this._source._toParamString({
+          buildParameterized: options.buildParameterized,
+          nested: true
+        });
+        sourceStr = ret.text;
+        ret.values.forEach((v) => values.push(v));
+      }
+      if (this._alias) {
+        sourceStr += ` AS ${this._formatTableAlias(this._alias)}`;
+      }
+      let conditionStr = "";
+      if (this._condition) {
+        let ret;
+        if (typeof this._condition === "string") {
+          ret = this._buildString(this._condition, [], {
+            buildParameterized: options.buildParameterized
+          });
+        } else {
+          ret = this._condition._toParamString({
+            buildParameterized: options.buildParameterized
+          });
+        }
+        conditionStr = ` ON ${this._applyNestingFormatting(ret.text)}`;
+        ret.values.forEach((v) => values.push(v));
+      }
+      return {
+        text: `USING ${sourceStr}${conditionStr}`,
+        values
+      };
+    }
+  };
+
+  class MergeMatchedClauseHelper {
+    builder;
+    clause;
+    constructor(builder, clause) {
+      this.builder = builder;
+      this.clause = clause;
+    }
+    update(fields) {
+      this.clause.action = { type: "UPDATE", fields };
+      return this.builder;
+    }
+    delete() {
+      this.clause.action = { type: "DELETE" };
+      return this.builder;
+    }
+  }
+
+  class MergeNotMatchedClauseHelper {
+    builder;
+    clause;
+    constructor(builder, clause) {
+      this.builder = builder;
+      this.clause = clause;
+    }
+    insert(fields) {
+      this.clause.action = { type: "INSERT", fields };
+      return this.builder;
+    }
+  }
+  cls.MergeWhenBlock = class extends cls.Block {
+    _clauses;
+    constructor(options) {
+      super(options);
+      this._clauses = [];
+    }
+    whenMatched(condition = null) {
+      const clause = { type: "MATCHED", condition, action: null };
+      this._clauses.push(clause);
+      return new MergeMatchedClauseHelper(this._queryBuilder, clause);
+    }
+    whenNotMatched(condition = null) {
+      const clause = { type: "NOT_MATCHED", condition, action: null };
+      this._clauses.push(clause);
+      return new MergeNotMatchedClauseHelper(this._queryBuilder, clause);
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (const clause of this._clauses) {
+        if (!clause.action)
+          continue;
+        totalStr = _pad(totalStr, " ");
+        let condStr = "";
+        if (clause.condition) {
+          const ret = this._buildString(clause.condition, [], {
+            buildParameterized: options.buildParameterized
+          });
+          condStr = ` AND ${ret.text}`;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+        let actionStr = "";
+        if (clause.action.type === "UPDATE") {
+          let setStr = "";
+          for (const key of Object.keys(clause.action.fields)) {
+            setStr = _pad(setStr, ", ");
+            const val = clause.action.fields[key];
+            if (val && typeof val._toParamString === "function") {
+              const ret = val._toParamString({
+                buildParameterized: options.buildParameterized
+              });
+              setStr += `${this._formatFieldName(key)} = ${ret.text}`;
+              ret.values.forEach((v) => totalValues.push(v));
+            } else {
+              const ret = this._buildString(`${this._formatFieldName(key)} = ${this.options.parameterCharacter}`, [val], {
+                buildParameterized: options.buildParameterized
+              });
+              setStr += ret.text;
+              ret.values.forEach((v) => totalValues.push(v));
+            }
+          }
+          actionStr = `THEN UPDATE SET ${setStr}`;
+        } else if (clause.action.type === "DELETE") {
+          actionStr = "THEN DELETE";
+        } else if (clause.action.type === "INSERT") {
+          const cols = Object.keys(clause.action.fields).map((c) => this._formatFieldName(c)).join(", ");
+          let valsStr = "";
+          for (const key of Object.keys(clause.action.fields)) {
+            valsStr = _pad(valsStr, ", ");
+            const val = clause.action.fields[key];
+            if (val && typeof val._toParamString === "function") {
+              const ret = val._toParamString({
+                buildParameterized: options.buildParameterized
+              });
+              valsStr += ret.text;
+              ret.values.forEach((v) => totalValues.push(v));
+            } else {
+              const ret = this._buildString(this.options.parameterCharacter, [val], {
+                buildParameterized: options.buildParameterized
+              });
+              valsStr += ret.text;
+              ret.values.forEach((v) => totalValues.push(v));
+            }
+          }
+          actionStr = `THEN INSERT (${cols}) VALUES (${valsStr})`;
+        }
+        const whenWord = clause.type === "MATCHED" ? "WHEN MATCHED" : "WHEN NOT MATCHED";
+        totalStr += `${whenWord}${condStr} ${actionStr}`;
+      }
+      return {
+        text: totalStr.length ? `${totalStr};` : "",
+        values: totalValues
+      };
+    }
+  };
+  cls.Merge = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.WithBlock(options),
+        new cls.StringBlock(options, "MERGE INTO"),
+        new cls.MergeIntoBlock(options),
+        new cls.MergeUsingBlock(options),
+        new cls.MergeWhenBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  _squel.merge = (options, blocks) => new cls.Merge(options, blocks);
 };
 
 // src/index.ts
@@ -1808,4 +2322,4 @@ export {
   src_default as default
 };
 
-//# debugId=F51DFA53E8AD876F64756E2164756E21
+//# debugId=C3B9A8DC1888720164756E2164756E21