@ignisia/sql 0.4.0 → 0.4.2

package/dist/esm/query/condition/common.d.ts

@@ -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-CjurLJdK.js';
+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-CsVPGz2o.js';
 import { Column } from '../../column/index.js';
 import { AcceptedOperator } from '../constants.js';
 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/esm/query/condition/common.js

@@ -24,17 +24,6 @@ function or(column, operator, value) {
     false
   );
 }
-function on(columnA, operator, columnB) {
-  return addCondition(
-    this,
-    ConditionClause.WHERE,
-    columnA,
-    operator,
-    columnB,
-    LogicalOperator.ON,
-    false
-  );
-}
 function having(column, operator, value) {
   return addCondition(
     this,
@@ -53,4 +42,4 @@ function orGroup(callback) {
   return addGroupCondition(this, LogicalOperator.OR, callback, false);
 }
 
-export { having, on, or, orGroup, where, whereGroup };
+export { having, or, orGroup, where, whereGroup };

package/dist/esm/query/condition/core.d.ts

@@ -1,4 +1,4 @@
-export { a as addCondition, b as addGroupCondition } from '../../index-CjurLJdK.js';
+export { a as addCondition, b as addGroupCondition } from '../../index-CsVPGz2o.js';
 import '../../column/index.js';
 import '../constants.js';
 import 'bun';

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

@@ -1,53 +1,87 @@
 import { QueryBuilder } from '../index.js';
-import { LogicalOperator, AcceptedOperator } from '../constants.js';
-import { getCondition } from '../utilities.js';
+import { LogicalOperator, AstType, AcceptedOperator } from '../constants.js';
 
 // src/query/condition/core.ts
 function addCondition(query, clause, column, operator, value, logical, negate) {
   if (!query.table.dialect) {
     throw new Error("No DB Dialect defined");
   }
-  const isOn = logical === LogicalOperator.ON;
   const validClause = clause.toLowerCase();
-  let condition = 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 ? LogicalOperator.AND : logical : "";
-  const not = negate ? "NOT " : "";
-  query.definition[validClause].push(
-    `${logicalPrefix} ${not}${condition}`.trim()
-  );
-  if (operator === AcceptedOperator.IS_NULL || operator === AcceptedOperator.IS_NOT_NULL) {
-    return query;
+  if (!query.definition[validClause]) {
+    query.definition[validClause] = {
+      type: AstType.GROUP,
+      operator: LogicalOperator.AND,
+      children: []
+    };
   }
-  if (!query.definition.params) query.definition.params = [];
-  if (!isOn) {
-    if (operator === AcceptedOperator.STARTS_WITH) {
-      query.definition.params.push(`${value}%`);
-    } else if (operator === 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: AstType.COMPARISON,
+    column,
+    operator,
+    value,
+    values: value
+  };
+  if (node.type === AstType.COMPARISON) {
+    if (node.operator === AcceptedOperator.IS_NULL && "value" in node) {
+      delete node.value;
+    }
+    if (node.operator === AcceptedOperator.STARTS_WITH) {
+      node.value = "%" + node.value;
+    }
+    if (node.operator === AcceptedOperator.ENDS_WITH) {
+      node.value = node.value + "%";
     }
   }
+  if (negate) {
+    node = {
+      type: AstType.NOT,
+      child: node
+    };
+  }
+  if (operator === AcceptedOperator.IS_NULL) {
+    return query;
+  }
+  if (root.operator === logical) {
+    root.children.push(node);
+  } else {
+    query.definition.where = {
+      type: 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: AstType.GROUP,
+      operator: 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: AstType.NOT,
+      child: groupNode
+    };
+  }
+  if (root.operator === logical) {
+    root.children.push(groupNode);
+  } else {
+    query.definition.where = {
+      type: AstType.GROUP,
+      operator: logical,
+      children: [root, groupNode]
+    };
   }
   return query;
 }

package/dist/esm/query/condition/index.d.ts

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

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

@@ -1,4 +1,3 @@
 export * from './common.js';
 export * from './core.js';
 export * from './not.js';
-export * from './raw.js';

package/dist/esm/query/condition/not.d.ts

@@ -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-CjurLJdK.js';
+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-CsVPGz2o.js';
 import { Column } from '../../column/index.js';
 import { AcceptedOperator } from '../constants.js';
 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/esm/query/constants.d.ts

@@ -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/esm/query/constants.js

@@ -1,8 +1,13 @@
 // src/query/constants.ts
 var LogicalOperator = {
   AND: "AND",
-  OR: "OR",
-  ON: "ON"
+  OR: "OR"
+};
+var AstType = {
+  GROUP: "GROUP",
+  COMPARISON: "COMPARISON",
+  NOT: "NOT",
+  JOIN: "JOIN"
 };
 var ConditionClause = {
   WHERE: "WHERE",
@@ -16,21 +21,14 @@ var 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"
 };
 var QueryType = {
   SELECT: "SELECT",
@@ -77,4 +75,4 @@ var ExplainClause = {
   TIMING: "TIMING"
 };
 
-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/esm/query/contract.d.ts

@@ -1,5 +1,5 @@
 import 'bun';
-export { o as QueryConditionContract, n as QueryTransformerContract } from '../index-CjurLJdK.js';
+export { f as QueryConditionContract, e as QueryTransformerContract } from '../index-CsVPGz2o.js';
 import '../column/index.js';
 import '../table/constants.js';
 import './constants.js';

package/dist/esm/query/explain.d.ts

@@ -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-CjurLJdK.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder, E as ExplainOptions } from '../index-CsVPGz2o.js';
 import { Column } from '../column/index.js';
 import 'bun';
 import '../types.js';

package/dist/esm/query/explain.js

@@ -40,7 +40,7 @@ function buildMySqlExplainQuery(options) {
     clauses.push(`${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/esm/query/helper.d.ts

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

package/dist/esm/query/helper.js

@@ -11,9 +11,6 @@ function clone() {
   Object.assign(query.definition, cloneDefinition(this.definition));
   return query;
 }
-function rawCol(column) {
-  return column;
-}
 function col(column, alias2) {
   return {
     column,
@@ -28,4 +25,4 @@ function aggregateCol(fn, column, alias2) {
   };
 }
 
-export { aggregateCol, alias, clone, col, rawCol };
+export { aggregateCol, alias, clone, col };

package/dist/esm/query/index.d.ts

@@ -1,8 +1,8 @@
+export { c as QueryBuilder } from '../index-CsVPGz2o.js';
 import '../column/index.js';
-export { l as QueryBuilder } from '../index-CjurLJdK.js';
 import '../types.js';
 import './constants.js';
-import '../table/constants.js';
+import 'bun';
 import '../column/constants.js';
+import '../table/constants.js';
 import '../column/types.js';
-import 'bun';

package/dist/esm/query/index.js

@@ -1,5 +1,5 @@
 import { quoteIdentifier } from '../utilities.js';
-import { rawWhere, rawHaving, rawOr, where, having, or, on, whereGroup, orGroup, orNotGroup, whereNotGroup, orNot, havingNot, whereNot } from './condition/index.js';
+import { where, having, or, whereGroup, orGroup, orNotGroup, whereNotGroup, orNot, havingNot, whereNot } from './condition/index.js';
 import { AcceptedJoin, QueryType } from './constants.js';
 import { alias, clone, aggregateCol, col } from './helper.js';
 import { prepareJoin, addNoOnJoin } from './join.js';
@@ -19,14 +19,9 @@ var QueryBuilder = class {
   toDebugString;
   explain;
   exec;
-  rawWhere;
-  rawAnd;
-  rawOr;
-  rawHaving;
   where;
   and;
   or;
-  on;
   having;
   whereGroup;
   orGroup;
@@ -44,15 +39,10 @@ var QueryBuilder = class {
     this.toDebugString = toDebugString.bind(this);
     this.explain = explain.bind(this);
     this.exec = exec.bind(this);
-    this.rawWhere = rawWhere.bind(this);
-    this.rawHaving = rawHaving.bind(this);
-    this.rawAnd = this.rawWhere;
-    this.rawOr = rawOr.bind(this);
     this.where = where.bind(this);
     this.having = having.bind(this);
     this.and = this.where;
     this.or = or.bind(this);
-    this.on = on.bind(this);
     this.whereGroup = whereGroup.bind(this);
     this.orGroup = orGroup.bind(this);
     this.not = {
@@ -81,7 +71,7 @@ var QueryBuilder = class {
     return addNoOnJoin(this, AcceptedJoin.CROSS, joinTable, alias2);
   }
   naturalJoin(joinTable, alias2) {
-    return prepareJoin(this, AcceptedJoin.NATURAL, joinTable, alias2);
+    return addNoOnJoin(this, AcceptedJoin.NATURAL, joinTable, alias2);
   }
   distinct() {
     this.definition.distinct = true;

package/dist/esm/query/join.d.ts

@@ -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-CjurLJdK.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder, J as JoinNode, e as QueryTransformerContract, f as QueryConditionContract } from '../index-CsVPGz2o.js';
 import { Column } from '../column/index.js';
 import { AcceptedJoin } from './constants.js';
 import 'bun';
@@ -10,18 +10,18 @@ import '../column/types.js';
 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>>>;
 };

package/dist/esm/query/join.js

@@ -1,9 +1,15 @@
 import { QueryBuilder } from './index.js';
+import { AstType } from './constants.js';
 
 // src/query/join.ts
 function addNoOnJoin(query, joinType, joinTable, alias) {
   if (!query.definition.joins) query.definition.joins = [];
-  query.definition.joins.push(`${joinType} JOIN ${joinTable.name} AS ${alias}`);
+  query.definition.joins.push({
+    type: AstType.JOIN,
+    alias,
+    join: joinType,
+    table: joinTable
+  });
   if (!query.definition.joinedTables) {
     query.definition.joinedTables = {};
   }
@@ -15,21 +21,23 @@ function prepareJoin(query, joinType, joinTable, alias) {
     on(callback) {
       const sub = callback(new QueryBuilder(query.table));
       const subDef = sub.definition;
-      if (!subDef.where?.length) {
+      if (!subDef.where) {
         return query;
       }
-      const grouped = `(${subDef.where.join(" ")})`;
-      if (!query.definition.joins) query.definition.joins = [];
-      query.definition.joins.push(
-        `${joinType} JOIN ${joinTable.name} AS ${alias} ON ${grouped}`
-      );
+      if (!query.definition.joins) {
+        query.definition.joins = [];
+      }
+      const on = subDef.where;
+      query.definition.joins.push({
+        type: AstType.JOIN,
+        alias,
+        join: joinType,
+        table: joinTable,
+        on
+      });
       if (subDef.joins?.length) {
         query.definition.joins.push(...subDef.joins);
       }
-      if (subDef.params?.length) {
-        if (!query.definition.params) query.definition.params = [];
-        query.definition.params.push(...subDef.params);
-      }
       if (!query.definition.joinedTables) {
         query.definition.joinedTables = {};
       }

package/dist/esm/query/sql.d.ts

@@ -1,5 +1,5 @@
 import { TransactionSQL } from 'bun';
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, E as ExplainOptions } from '../index-CjurLJdK.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder, E as ExplainOptions } from '../index-CsVPGz2o.js';
 import { Column } from '../column/index.js';
 import { Dialect } from '../table/constants.js';
 import '../types.js';
@@ -10,7 +10,7 @@ import '../column/types.js';
 declare function buildQuery(query: string): string;
 declare function toQuery<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query, dialect?: Dialect | null): {
     query: string;
-    params: unknown[] | null | undefined;
+    params: unknown[];
 };
 declare function toString<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;
 declare function toDebugString<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>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;