@ignisia/sql 0.4.0 → 0.4.2

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

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, W as WhereValue, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, W as WhereValue, i as QueryBuilder, k as QueryTransformerContract, l as QueryConditionContract, G as GroupNode } from '../../index-CY-nPZED.cjs';
 import { Column } from '../../column/index.cjs';
 import { AcceptedOperator } from '../constants.cjs';
 import 'bun';
@@ -21,13 +21,6 @@ declare function or<Alias extends string, TableRef extends Table<string, Record<
 }, 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 on<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, Operator extends typeof AcceptedOperator.EQ | typeof AcceptedOperator.NE>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, columnA: ColName, operator: Operator, columnB: ColName): 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"> & {
@@ -35,7 +28,19 @@ declare function having<Alias extends string, TableRef extends Table<string, Rec
 }, 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, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-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, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+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, on, or, orGroup, where, whereGroup };
+export { having, or, orGroup, where, whereGroup };

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

@@ -25,17 +25,6 @@ function or(column, operator, value) {
     false
   );
 }
-function on(columnA, operator, columnB) {
-  return core.addCondition(
-    this,
-    constants.ConditionClause.WHERE,
-    columnA,
-    operator,
-    columnB,
-    constants.LogicalOperator.ON,
-    false
-  );
-}
 function having(column, operator, value) {
   return core.addCondition(
     this,
@@ -55,7 +44,6 @@ function orGroup(callback) {
 }
 
 exports.having = having;
-exports.on = on;
 exports.or = or;
 exports.orGroup = orGroup;
 exports.where = where;

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

@@ -1,4 +1,4 @@
-export { a as addCondition, b as addGroupCondition } from '../../index-CHxuUiO4.cjs';
+export { a as addCondition, b as addGroupCondition } from '../../index-CY-nPZED.cjs';
 import '../../column/index.cjs';
 import '../constants.cjs';
 import 'bun';

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

@@ -2,53 +2,87 @@
 
 var __ = require('..');
 var constants = require('../constants');
-var utilities = require('../utilities');
 
 function addCondition(query, clause, column, operator, value, logical, negate) {
   if (!query.table.dialect) {
     throw new Error("No DB Dialect defined");
   }
-  const isOn = logical === constants.LogicalOperator.ON;
   const validClause = clause.toLowerCase();
-  let condition = utilities.getCondition(query.table.dialect, column, operator, value);
-  if (isOn) {
-    condition = condition.replace("?", value);
-  }
-  if (!query.definition[validClause]) query.definition[validClause] = [];
-  const logicalPrefix = query.definition[validClause].length > 0 ? isOn ? constants.LogicalOperator.AND : logical : "";
-  const not = negate ? "NOT " : "";
-  query.definition[validClause].push(
-    `${logicalPrefix} ${not}${condition}`.trim()
-  );
-  if (operator === constants.AcceptedOperator.IS_NULL || operator === constants.AcceptedOperator.IS_NOT_NULL) {
-    return query;
+  if (!query.definition[validClause]) {
+    query.definition[validClause] = {
+      type: constants.AstType.GROUP,
+      operator: constants.LogicalOperator.AND,
+      children: []
+    };
   }
-  if (!query.definition.params) query.definition.params = [];
-  if (!isOn) {
-    if (operator === constants.AcceptedOperator.STARTS_WITH) {
-      query.definition.params.push(`${value}%`);
-    } else if (operator === constants.AcceptedOperator.ENDS_WITH) {
-      query.definition.params.push(`%${value}`);
-    } else if (Array.isArray(value)) {
-      query.definition.params.push(...value);
-    } else {
-      query.definition.params.push(value);
+  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 (!subDef.where?.length) return query;
-  const not = negate ? "NOT " : "";
-  const grouped = `${not}(${subDef.where.join(" ")})`;
-  if (!query.definition.where) query.definition.where = [];
-  const logicalPrefix = query.definition.where.length > 0 ? logical : "";
-  query.definition.where.push(`${logicalPrefix} ${grouped}`.trim());
-  if (subDef.params?.length) {
-    if (!query.definition.params) query.definition.params = [];
-    query.definition.params.push(...subDef.params);
+  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;
 }

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

@@ -1,5 +1,5 @@
-export { having, on, or, orGroup, where, whereGroup } from './common.cjs';
-export { a as addCondition, b as addGroupCondition, c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CHxuUiO4.cjs';
+export { having, or, orGroup, where, whereGroup } from './common.cjs';
+export { a as addCondition, b as addGroupCondition } from '../../index-CY-nPZED.cjs';
 export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup } from './not.cjs';
 import '../../column/index.cjs';
 import '../../table/constants.cjs';

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

@@ -3,7 +3,6 @@
 var common = require('./common');
 var core = require('./core');
 var not = require('./not');
-var raw = require('./raw');
 
 
 
@@ -25,9 +24,3 @@ Object.keys(not).forEach(function (k) {
 		get: function () { return not[k]; }
 	});
 });
-Object.keys(raw).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return raw[k]; }
-	});
-});

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

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, W as WhereValue, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, W as WhereValue, i as QueryBuilder, k as QueryTransformerContract, l as QueryConditionContract, G as GroupNode } from '../../index-CY-nPZED.cjs';
 import { Column } from '../../column/index.cjs';
 import { AcceptedOperator } from '../constants.cjs';
 import 'bun';
@@ -28,7 +28,19 @@ declare function orNot<Alias extends string, TableRef extends Table<string, Reco
 }, 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, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-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, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+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/constants.d.cts

@@ -1,9 +1,15 @@
 declare const LogicalOperator: {
     readonly AND: "AND";
     readonly OR: "OR";
-    readonly ON: "ON";
 };
 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";
@@ -17,21 +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 NOT_REG_EXP: "notRegExp";
     readonly RLIKE: "rlike";
-    readonly NOT_RLIKE: "notRlike";
 };
 type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
 declare const QueryType: {
@@ -86,4 +85,4 @@ declare const ExplainClause: {
 };
 type ExplainClause = (typeof ExplainClause)[keyof typeof ExplainClause];
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, AstType, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/cjs/query/constants.js

@@ -2,8 +2,13 @@
 
 const LogicalOperator = {
   AND: "AND",
-  OR: "OR",
-  ON: "ON"
+  OR: "OR"
+};
+const AstType = {
+  GROUP: "GROUP",
+  COMPARISON: "COMPARISON",
+  NOT: "NOT",
+  JOIN: "JOIN"
 };
 const ConditionClause = {
   WHERE: "WHERE",
@@ -17,21 +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",
-  NOT_REG_EXP: "notRegExp",
-  RLIKE: "rlike",
-  NOT_RLIKE: "notRlike"
+  RLIKE: "rlike"
 };
 const QueryType = {
   SELECT: "SELECT",
@@ -81,6 +79,7 @@ const ExplainClause = {
 exports.AcceptedJoin = AcceptedJoin;
 exports.AcceptedOperator = AcceptedOperator;
 exports.AggregationFunction = AggregationFunction;
+exports.AstType = AstType;
 exports.ConditionClause = ConditionClause;
 exports.ExplainClause = ExplainClause;
 exports.ExplainFormat = ExplainFormat;

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

@@ -1,5 +1,5 @@
 import 'bun';
-export { o as QueryConditionContract, n as QueryTransformerContract } from '../index-CHxuUiO4.cjs';
+export { l as QueryConditionContract, k as QueryTransformerContract } from '../index-CY-nPZED.cjs';
 import '../column/index.cjs';
 import '../table/constants.cjs';
 import './constants.cjs';

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

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, E as ExplainOptions } from '../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, E as ExplainOptions } from '../index-CY-nPZED.cjs';
 import { Column } from '../column/index.cjs';
 import 'bun';
 import '../types.cjs';

package/dist/cjs/query/explain.js

@@ -41,7 +41,7 @@ function buildMySqlExplainQuery(options) {
     clauses.push(`${constants$1.ExplainClause.FORMAT}=${options.format}`);
   }
   if (clauses.length > 1) {
-    throw new Error("Only one explain clause is allowed");
+    throw new Error("MySQL EXPLAIN only support one clauses at a time");
   }
   return `EXPLAIN ${clauses.join(" ")}`;
 }

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

@@ -1,4 +1,4 @@
-export { I as aggregateCol, B as alias, F as clone, H as col, G as rawCol } from '../index-CHxuUiO4.cjs';
+export { a1 as aggregateCol, _ as alias, $ as clone, a0 as col } from '../index-CY-nPZED.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
 import 'bun';

package/dist/cjs/query/helper.js

@@ -12,9 +12,6 @@ function clone() {
   Object.assign(query.definition, utilities.cloneDefinition(this.definition));
   return query;
 }
-function rawCol(column) {
-  return column;
-}
 function col(column, alias2) {
   return {
     column,
@@ -33,4 +30,3 @@ exports.aggregateCol = aggregateCol;
 exports.alias = alias;
 exports.clone = clone;
 exports.col = col;
-exports.rawCol = rawCol;

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

@@ -1,8 +1,8 @@
+export { i as QueryBuilder } from '../index-CY-nPZED.cjs';
 import '../column/index.cjs';
-export { l as QueryBuilder } from '../index-CHxuUiO4.cjs';
 import '../types.cjs';
 import './constants.cjs';
-import '../table/constants.cjs';
+import 'bun';
 import '../column/constants.cjs';
+import '../table/constants.cjs';
 import '../column/types.cjs';
-import 'bun';

package/dist/cjs/query/index.js

@@ -20,14 +20,9 @@ class QueryBuilder {
   toDebugString;
   explain;
   exec;
-  rawWhere;
-  rawAnd;
-  rawOr;
-  rawHaving;
   where;
   and;
   or;
-  on;
   having;
   whereGroup;
   orGroup;
@@ -45,15 +40,10 @@ class QueryBuilder {
     this.toDebugString = sql.toDebugString.bind(this);
     this.explain = sql.explain.bind(this);
     this.exec = sql.exec.bind(this);
-    this.rawWhere = condition.rawWhere.bind(this);
-    this.rawHaving = condition.rawHaving.bind(this);
-    this.rawAnd = this.rawWhere;
-    this.rawOr = condition.rawOr.bind(this);
     this.where = condition.where.bind(this);
     this.having = condition.having.bind(this);
     this.and = this.where;
     this.or = condition.or.bind(this);
-    this.on = condition.on.bind(this);
     this.whereGroup = condition.whereGroup.bind(this);
     this.orGroup = condition.orGroup.bind(this);
     this.not = {
@@ -82,7 +72,7 @@ class QueryBuilder {
     return join.addNoOnJoin(this, constants.AcceptedJoin.CROSS, joinTable, alias2);
   }
   naturalJoin(joinTable, alias2) {
-    return join.prepareJoin(this, constants.AcceptedJoin.NATURAL, joinTable, alias2);
+    return join.addNoOnJoin(this, constants.AcceptedJoin.NATURAL, joinTable, alias2);
   }
   distinct() {
     this.definition.distinct = true;

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

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, J as JoinNode, k as QueryTransformerContract, l as QueryConditionContract } from '../index-CY-nPZED.cjs';
 import { Column } from '../column/index.cjs';
 import { AcceptedJoin } from './constants.cjs';
 import 'bun';
@@ -10,18 +10,18 @@ import '../column/types.cjs';
 declare function addNoOnJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, FinalJoinedTables extends JoinedTables & {
     [K in JoinAlias]: JoinTable;
 }>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, joinTable: JoinTable, alias: JoinAlias): QueryBuilder<Alias, TableRef, FinalJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-    joins: string[];
+    joins: JoinNode[];
     joinedTables: FinalJoinedTables;
 }>;
 declare function prepareJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, joinTable: JoinTable, alias: JoinAlias): {
     on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
         joinedTables: ReturnedJoinedTables;
     }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
         joinedTables: ReturnedJoinedTables;
     }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
         joinedTables: ReturnedJoinedTables;
     }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
 };