@ignisia/sql 0.3.0 → 0.4.1

package/dist/cjs/query/compiler.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var constants$1 = require('../table/constants');
+var constants = require('./constants');
+
+function compileComparison(dialect, node, params) {
+  const column = node.column;
+  if (node.operator === constants.AcceptedOperator.BETWEEN || node.operator === constants.AcceptedOperator.IN) {
+    params.push(...node.values);
+  } else if (node.operator !== constants.AcceptedOperator.IS_NULL && "value" in node) {
+    params.push(node.value);
+  }
+  switch (node.operator) {
+    case constants.AcceptedOperator.EQ:
+      return `${column} = ?`;
+    case constants.AcceptedOperator.NE:
+      return `${column} != ?`;
+    case constants.AcceptedOperator.GT:
+      return `${column} > ?`;
+    case constants.AcceptedOperator.LT:
+      return `${column} < ?`;
+    case constants.AcceptedOperator.GTE:
+      return `${column} >= ?`;
+    case constants.AcceptedOperator.LTE:
+      return `${column} <= ?`;
+    case constants.AcceptedOperator.IN:
+      return `${column} IN (${node.values.map(() => "?").join(", ")})`;
+    case constants.AcceptedOperator.LIKE:
+      return `${column} LIKE ?`;
+    case constants.AcceptedOperator.ILIKE:
+      if (dialect === constants$1.Dialect.POSTGRES) {
+        return `${column} ILIKE ?`;
+      }
+      return `LOWER(${column}) LIKE LOWER(?)`;
+    case constants.AcceptedOperator.IS_NULL:
+      return `${column} IS NULL`;
+    case constants.AcceptedOperator.BETWEEN:
+      return `${column} BETWEEN ? AND ?`;
+    case constants.AcceptedOperator.STARTS_WITH:
+      return `${column} LIKE ?`;
+    case constants.AcceptedOperator.ENDS_WITH:
+      return `${column} LIKE ?`;
+    case constants.AcceptedOperator.REG_EXP: {
+      switch (dialect) {
+        case constants$1.Dialect.POSTGRES:
+          return `${column} ~ ?`;
+        case constants$1.Dialect.MYSQL:
+          return `${column} REGEXP ?`;
+        case constants$1.Dialect.SQLITE:
+          return `${column} GLOB ?`;
+        default:
+          throw new Error("Operator not supported");
+      }
+    }
+    case constants.AcceptedOperator.RLIKE: {
+      switch (dialect) {
+        case constants$1.Dialect.POSTGRES:
+          return `${column} ~* ?`;
+        case constants$1.Dialect.MYSQL:
+          return `${column} RLIKE ?`;
+        case constants$1.Dialect.SQLITE:
+          return `${column} GLOB ?`;
+        default:
+          throw new Error("Operator not supported");
+      }
+    }
+    default:
+      throw new Error("Invalid operator");
+  }
+}
+function compileNot(dialect, node, params) {
+  const inner = compileAst(dialect, node.child, params);
+  return `NOT (${inner})`;
+}
+function compileGroup(dialect, node, params) {
+  if (!node.children.length) {
+    return "";
+  }
+  const compiled = node.children.map(
+    (child) => compileAst(dialect, child, params)
+  );
+  return `(${compiled.join(` ${node.operator} `)})`;
+}
+function compileAst(dialect, node, params) {
+  switch (node.type) {
+    case constants.AstType.COMPARISON:
+      return compileComparison(dialect, node, params);
+    case constants.AstType.GROUP:
+      return compileGroup(dialect, node, params);
+    case constants.AstType.NOT:
+      return compileNot(dialect, node, params);
+    default:
+      throw new Error(`Unknown AST node type`);
+  }
+}
+function compileJoin(dialect, join, params) {
+  const table = join.table.name;
+  const alias = join.alias;
+  if (join.join === constants.AcceptedJoin.CROSS || join.join === constants.AcceptedJoin.NATURAL) {
+    return `${join.join} JOIN ${table} AS ${alias}`;
+  }
+  if (!join.on) {
+    throw new Error(`${join.join} join requires ON condition`);
+  }
+  const onSql = compileAst(
+    dialect,
+    join.on,
+    params
+  );
+  return `${join.join} JOIN ${table} AS ${alias} ON ${onSql}`;
+}
+
+exports.compileAst = compileAst;
+exports.compileJoin = compileJoin;

package/dist/cjs/query/condition/common.d.cts

@@ -0,0 +1,46 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, W as WhereValue, c as QueryBuilder, e as QueryTransformerContract, f as QueryConditionContract, G as GroupNode } from '../../index-K07efKgt.cjs';
+import { Column } from '../../column/index.cjs';
+import { AcceptedOperator } from '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';
+
+declare function where<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function or<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function having<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function whereGroup<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function orGroup<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+
+export { having, or, orGroup, where, whereGroup };

package/dist/cjs/query/condition/common.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var constants = require('../constants');
+var core = require('./core');
+
+function where(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.AND,
+    false
+  );
+}
+function or(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.OR,
+    false
+  );
+}
+function having(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    constants.LogicalOperator.AND,
+    false
+  );
+}
+function whereGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.AND, callback, false);
+}
+function orGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.OR, callback, false);
+}
+
+exports.having = having;
+exports.or = or;
+exports.orGroup = orGroup;
+exports.where = where;
+exports.whereGroup = whereGroup;

package/dist/cjs/query/condition/core.d.cts

@@ -0,0 +1,8 @@
+export { a as addCondition, b as addGroupCondition } from '../../index-K07efKgt.cjs';
+import '../../column/index.cjs';
+import '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';

package/dist/cjs/query/condition/core.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var __ = require('..');
+var constants = require('../constants');
+
+function addCondition(query, clause, column, operator, value, logical, negate) {
+  if (!query.table.dialect) {
+    throw new Error("No DB Dialect defined");
+  }
+  const validClause = clause.toLowerCase();
+  if (!query.definition[validClause]) {
+    query.definition[validClause] = {
+      type: constants.AstType.GROUP,
+      operator: constants.LogicalOperator.AND,
+      children: []
+    };
+  }
+  const root = query.definition[validClause];
+  let node = {
+    type: constants.AstType.COMPARISON,
+    column,
+    operator,
+    value,
+    values: value
+  };
+  if (node.type === constants.AstType.COMPARISON) {
+    if (node.operator === constants.AcceptedOperator.IS_NULL && "value" in node) {
+      delete node.value;
+    }
+    if (node.operator === constants.AcceptedOperator.STARTS_WITH) {
+      node.value = "%" + node.value;
+    }
+    if (node.operator === constants.AcceptedOperator.ENDS_WITH) {
+      node.value = node.value + "%";
+    }
+  }
+  if (negate) {
+    node = {
+      type: constants.AstType.NOT,
+      child: node
+    };
+  }
+  if (operator === constants.AcceptedOperator.IS_NULL) {
+    return query;
+  }
+  if (root.operator === logical) {
+    root.children.push(node);
+  } else {
+    query.definition.where = {
+      type: constants.AstType.GROUP,
+      operator: logical,
+      children: [root, node]
+    };
+  }
+  return query;
+}
+function addGroupCondition(query, logical, callback, negate) {
+  const sub = callback(new __.QueryBuilder(query.table));
+  const subDef = sub.definition;
+  if (!query.definition.where) {
+    query.definition.where = {
+      type: constants.AstType.GROUP,
+      operator: constants.LogicalOperator.AND,
+      children: []
+    };
+  }
+  if (!subDef.where || subDef.where.children.length === 0) {
+    return query;
+  }
+  const root = query.definition.where;
+  let groupNode = subDef.where;
+  if (negate) {
+    groupNode = {
+      type: constants.AstType.NOT,
+      child: groupNode
+    };
+  }
+  if (root.operator === logical) {
+    root.children.push(groupNode);
+  } else {
+    query.definition.where = {
+      type: constants.AstType.GROUP,
+      operator: logical,
+      children: [root, groupNode]
+    };
+  }
+  return query;
+}
+
+exports.addCondition = addCondition;
+exports.addGroupCondition = addGroupCondition;

package/dist/cjs/query/condition/index.d.cts

@@ -0,0 +1,10 @@
+export { having, or, orGroup, where, whereGroup } from './common.cjs';
+export { a as addCondition, b as addGroupCondition } from '../../index-K07efKgt.cjs';
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup } from './not.cjs';
+import '../../column/index.cjs';
+import '../../table/constants.cjs';
+import '../../column/constants.cjs';
+import '../../column/types.cjs';
+import '../constants.cjs';
+import 'bun';
+import '../../types.cjs';

package/dist/cjs/query/condition/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var common = require('./common');
+var core = require('./core');
+var not = require('./not');
+
+
+
+Object.keys(common).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return common[k]; }
+	});
+});
+Object.keys(core).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return core[k]; }
+	});
+});
+Object.keys(not).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return not[k]; }
+	});
+});

package/dist/cjs/query/condition/not.d.cts

@@ -0,0 +1,46 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, W as WhereValue, c as QueryBuilder, e as QueryTransformerContract, f as QueryConditionContract, G as GroupNode } from '../../index-K07efKgt.cjs';
+import { Column } from '../../column/index.cjs';
+import { AcceptedOperator } from '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';
+
+declare function whereNot<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function havingNot<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function orNot<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function whereNotGroup<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function orNotGroup<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup };

package/dist/cjs/query/condition/not.js

@@ -0,0 +1,51 @@
+'use strict';
+
+require('..');
+var constants = require('../constants');
+var core = require('./core');
+
+function whereNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.AND,
+    true
+  );
+}
+function havingNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    constants.LogicalOperator.AND,
+    true
+  );
+}
+function orNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.OR,
+    true
+  );
+}
+function whereNotGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.AND, callback, true);
+}
+function orNotGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.OR, callback, true);
+}
+
+exports.havingNot = havingNot;
+exports.orNot = orNot;
+exports.orNotGroup = orNotGroup;
+exports.whereNot = whereNot;
+exports.whereNotGroup = whereNotGroup;

package/dist/cjs/query/constants.d.cts

@@ -3,6 +3,13 @@ declare const LogicalOperator: {
     readonly OR: "OR";
 };
 type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+declare const AstType: {
+    readonly GROUP: "GROUP";
+    readonly COMPARISON: "COMPARISON";
+    readonly NOT: "NOT";
+    readonly JOIN: "JOIN";
+};
+type AstType = (typeof AstType)[keyof typeof AstType];
 declare const ConditionClause: {
     readonly WHERE: "WHERE";
     readonly HAVING: "HAVING";
@@ -16,15 +23,14 @@ declare const AcceptedOperator: {
     readonly GTE: "gte";
     readonly LTE: "lte";
     readonly IN: "in";
-    readonly NOT_IN: "notIn";
     readonly LIKE: "like";
-    readonly NOT_LIKE: "notLike";
     readonly ILIKE: "ilike";
-    readonly NOT_ILIKE: "notILike";
     readonly IS_NULL: "isNull";
-    readonly IS_NOT_NULL: "isNotNull";
     readonly BETWEEN: "between";
-    readonly NOT_BETWEEN: "notBetween";
+    readonly STARTS_WITH: "startsWith";
+    readonly ENDS_WITH: "endsWith";
+    readonly REG_EXP: "regExp";
+    readonly RLIKE: "rlike";
 };
 type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
 declare const QueryType: {
@@ -51,6 +57,8 @@ declare const AcceptedJoin: {
     readonly INNER: "INNER";
     readonly LEFT: "LEFT";
     readonly RIGHT: "RIGHT";
+    readonly FULL: "FULL OUTER";
+    readonly CROSS: "CROSS";
     readonly NATURAL: "NATURAL";
 };
 type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
@@ -59,5 +67,22 @@ declare const QueryHooksType: {
     readonly BEFORE: "before";
 };
 type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
+declare const ExplainFormat: {
+    readonly JSON: "JSON";
+    readonly TEXT: "TEXT";
+    readonly YAML: "YAML";
+    readonly XML: "XML";
+};
+type ExplainFormat = (typeof ExplainFormat)[keyof typeof ExplainFormat];
+declare const ExplainClause: {
+    readonly FORMAT: "FORMAT";
+    readonly ANALYZE: "ANALYZE";
+    readonly VERBOSE: "VERBOSE";
+    readonly COSTS: "COSTS";
+    readonly BUFFERS: "BUFFERS";
+    readonly SUMMARY: "SUMMARY";
+    readonly TIMING: "TIMING";
+};
+type ExplainClause = (typeof ExplainClause)[keyof typeof ExplainClause];
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, AstType, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/cjs/query/constants.js

@@ -4,6 +4,12 @@ const LogicalOperator = {
   AND: "AND",
   OR: "OR"
 };
+const AstType = {
+  GROUP: "GROUP",
+  COMPARISON: "COMPARISON",
+  NOT: "NOT",
+  JOIN: "JOIN"
+};
 const ConditionClause = {
   WHERE: "WHERE",
   HAVING: "HAVING"
@@ -16,15 +22,14 @@ const AcceptedOperator = {
   GTE: "gte",
   LTE: "lte",
   IN: "in",
-  NOT_IN: "notIn",
   LIKE: "like",
-  NOT_LIKE: "notLike",
   ILIKE: "ilike",
-  NOT_ILIKE: "notILike",
   IS_NULL: "isNull",
-  IS_NOT_NULL: "isNotNull",
   BETWEEN: "between",
-  NOT_BETWEEN: "notBetween"
+  STARTS_WITH: "startsWith",
+  ENDS_WITH: "endsWith",
+  REG_EXP: "regExp",
+  RLIKE: "rlike"
 };
 const QueryType = {
   SELECT: "SELECT",
@@ -47,17 +52,37 @@ const AcceptedJoin = {
   INNER: "INNER",
   LEFT: "LEFT",
   RIGHT: "RIGHT",
+  FULL: "FULL OUTER",
+  CROSS: "CROSS",
   NATURAL: "NATURAL"
 };
 const QueryHooksType = {
   AFTER: "after",
   BEFORE: "before"
 };
+const ExplainFormat = {
+  JSON: "JSON",
+  TEXT: "TEXT",
+  YAML: "YAML",
+  XML: "XML"
+};
+const ExplainClause = {
+  FORMAT: "FORMAT",
+  ANALYZE: "ANALYZE",
+  VERBOSE: "VERBOSE",
+  COSTS: "COSTS",
+  BUFFERS: "BUFFERS",
+  SUMMARY: "SUMMARY",
+  TIMING: "TIMING"
+};
 
 exports.AcceptedJoin = AcceptedJoin;
 exports.AcceptedOperator = AcceptedOperator;
 exports.AggregationFunction = AggregationFunction;
+exports.AstType = AstType;
 exports.ConditionClause = ConditionClause;
+exports.ExplainClause = ExplainClause;
+exports.ExplainFormat = ExplainFormat;
 exports.LogicalOperator = LogicalOperator;
 exports.OrderBy = OrderBy;
 exports.QueryHooksType = QueryHooksType;

package/dist/cjs/query/contract.d.cts

@@ -1,8 +1,8 @@
 import 'bun';
-export { Y as QueryConditionContract, X as QueryTransformerContract } from '../index-CnQVnCEI.cjs';
+export { f as QueryConditionContract, e as QueryTransformerContract } from '../index-K07efKgt.cjs';
 import '../column/index.cjs';
 import '../table/constants.cjs';
 import './constants.cjs';
-import '../column/constants.cjs';
 import '../types.cjs';
+import '../column/constants.cjs';
 import '../column/types.cjs';

package/dist/cjs/query/explain.d.cts

@@ -0,0 +1,12 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder, E as ExplainOptions } from '../index-K07efKgt.cjs';
+import { Column } from '../column/index.cjs';
+import 'bun';
+import '../types.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+
+declare function buildExplainQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, options: Partial<ExplainOptions>): string;
+
+export { buildExplainQuery };