add modifyFront and modifyEnd methods. Closes #72

Author: koskimas

src/operation-node/operation-node-transformer.ts

@@ -69,6 +69,7 @@ import { DefaultValueNode } from './default-value-node.js'
 import { freeze } from '../util/object-utils.js'
 import { OnNode } from './on-node.js'
 import { ValuesNode } from './values-node.js'
+import { SelectModifierNode } from './select-modifier-node.js'
 
 export abstract class OperationNodeVisitor {
   protected readonly nodeStack: OperationNode[] = []
@@ -145,6 +146,7 @@ export abstract class OperationNodeVisitor {
     DefaultValueNode: this.visitDefaultValue.bind(this),
     OnNode: this.visitOn.bind(this),
     ValuesNode: this.visitValues.bind(this),
+    SelectModifierNode: this.visitSelectModifier.bind(this),
   })
 
   protected readonly visitNode = (node: OperationNode): void => {
@@ -227,4 +229,5 @@ export abstract class OperationNodeVisitor {
   protected abstract visitDefaultValue(node: DefaultValueNode): void
   protected abstract visitOn(node: OnNode): void
   protected abstract visitValues(node: ValuesNode): void
+  protected abstract visitSelectModifier(node: SelectModifierNode): void
 }

src/operation-node/operation-node-visitor.ts

@@ -65,6 +65,7 @@ export type OperationNodeKind =
   | 'OnNode'
   | 'ValuesNode'
   | 'CommonTableExpressionNameNode'
+  | 'SelectModifierNode'
 
 export interface OperationNode {
   readonly kind: OperationNodeKind

src/operation-node/operation-node.ts

@@ -0,0 +1,41 @@
+import { OperationNode } from './operation-node.js'
+import { freeze } from '../util/object-utils.js'
+import { RawNode } from './raw-node.js'
+
+export type SelectModifier =
+  | 'ForUpdate'
+  | 'ForNoKeyUpdate'
+  | 'ForShare'
+  | 'ForKeyShare'
+  | 'NoWait'
+  | 'SkipLocked'
+  | 'Distinct'
+
+export interface SelectModifierNode extends OperationNode {
+  readonly kind: 'SelectModifierNode'
+  readonly modifier?: SelectModifier
+  readonly rawModifier?: RawNode
+}
+
+/**
+ * @internal
+ */
+export const SelectModifierNode = freeze({
+  is(node: OperationNode): node is SelectModifierNode {
+    return node.kind === 'SelectModifierNode'
+  },
+
+  create(modifier: SelectModifier): SelectModifierNode {
+    return freeze({
+      kind: 'SelectModifierNode',
+      modifier,
+    })
+  },
+
+  createWithRaw(modifier: RawNode): SelectModifierNode {
+    return freeze({
+      kind: 'SelectModifierNode',
+      rawModifier: modifier,
+    })
+  },
+})

src/operation-node/select-modifier-node.ts

@@ -17,26 +17,19 @@ import { SelectionNode } from './selection-node.js'
 import { WhereNode } from './where-node.js'
 import { WithNode } from './with-node.js'
 import { UnionNode } from './union-node.js'
-
-export type SelectModifier =
-  | 'ForUpdate'
-  | 'ForNoKeyUpdate'
-  | 'ForShare'
-  | 'ForKeyShare'
-  | 'NoWait'
-  | 'SkipLocked'
+import { SelectModifierNode } from './select-modifier-node.js'
 
 export interface SelectQueryNode extends OperationNode {
   readonly kind: 'SelectQueryNode'
   readonly from: FromNode
   readonly selections?: ReadonlyArray<SelectionNode>
   readonly distinctOnSelections?: ReadonlyArray<SelectionNode>
-  readonly distinct?: boolean
   readonly joins?: ReadonlyArray<JoinNode>
   readonly groupBy?: GroupByNode
   readonly orderBy?: OrderByNode
   readonly where?: WhereNode
-  readonly modifiers?: ReadonlyArray<SelectModifier>
+  readonly frontModifiers?: ReadonlyArray<SelectModifierNode>
+  readonly endModifiers?: ReadonlyArray<SelectModifierNode>
   readonly limit?: LimitNode
   readonly offset?: OffsetNode
   readonly with?: WithNode
@@ -87,14 +80,26 @@ export const SelectQueryNode = freeze({
     })
   },
 
-  cloneWithModifier(
+  cloneWithFrontModifier(
+    select: SelectQueryNode,
+    modifier: SelectModifierNode
+  ): SelectQueryNode {
+    return freeze({
+      ...select,
+      frontModifiers: select.frontModifiers
+        ? freeze([...select.frontModifiers, modifier])
+        : freeze([modifier]),
+    })
+  },
+
+  cloneWithEndModifier(
     select: SelectQueryNode,
-    modifier: SelectModifier
+    modifier: SelectModifierNode
   ): SelectQueryNode {
     return freeze({
       ...select,
-      modifiers: select.modifiers
-        ? freeze([...select.modifiers, modifier])
+      endModifiers: select.endModifiers
+        ? freeze([...select.endModifiers, modifier])
         : freeze([modifier]),
     })
   },
@@ -167,13 +172,6 @@ export const SelectQueryNode = freeze({
     })
   },
 
-  cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode {
-    return freeze({
-      ...selectNode,
-      distinct: true,
-    })
-  },
-
   cloneWithUnion(
     selectNode: SelectQueryNode,
     union: UnionNode

src/operation-node/select-query-node.ts

@@ -59,6 +59,7 @@ import { NoResultError, NoResultErrorConstructor } from './no-result-error.js'
 import { HavingInterface } from './having-interface.js'
 import { IdentifierNode } from '../operation-node/identifier-node.js'
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js'
+import { SelectModifierNode } from '../operation-node/select-modifier-node.js'
 
 export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   implements
@@ -527,6 +528,68 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     })
   }
 
+  /**
+   * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.selectFrom('person')
+   *   .modifyFront(sql`sql_no_cache`)
+   *   .select('first_name')
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * select sql_no_cache `first_name`
+   * from `person`
+   * ```
+   */
+  modifyFront(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilder({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithFrontModifier(
+        this.#props.queryNode,
+        SelectModifierNode.createWithRaw(modifier.toOperationNode())
+      ),
+    })
+  }
+
+  /**
+   * This can be used to add any additional SQL to the end of the query.
+   *
+   * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
+   * {@link skipLocked} and  {@link noWait}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.selectFrom('person')
+   *   .select('first_name')
+   *   .modifyEnd(sql`for update`)
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * select "first_name"
+   * from "person"
+   * for update
+   * ```
+   */
+  modifyEnd(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilder({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.createWithRaw(modifier.toOperationNode())
+      ),
+    })
+  }
+
   /**
    * Makes the selection distinct.
    *
@@ -548,84 +611,87 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   distinct(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
+      queryNode: SelectQueryNode.cloneWithFrontModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('Distinct')
+      ),
     })
   }
 
   /**
-   * Adds the `for update` option to a select query on supported databases.
+   * Adds the `for update` modifier to a select query on supported databases.
    */
   forUpdate(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'ForUpdate'
+        SelectModifierNode.create('ForUpdate')
       ),
     })
   }
 
   /**
-   * Adds the `for share` option to a select query on supported databases.
+   * Adds the `for share` modifier to a select query on supported databases.
    */
   forShare(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'ForShare'
+        SelectModifierNode.create('ForShare')
       ),
     })
   }
 
   /**
-   * Adds the `for key share` option to a select query on supported databases.
+   * Adds the `for key share` modifier to a select query on supported databases.
    */
   forKeyShare(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'ForKeyShare'
+        SelectModifierNode.create('ForKeyShare')
       ),
     })
   }
 
   /**
-   * Adds the `for no key update` option to a select query on supported databases.
+   * Adds the `for no key update` modifier to a select query on supported databases.
    */
   forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'ForNoKeyUpdate'
+        SelectModifierNode.create('ForNoKeyUpdate')
       ),
     })
   }
 
   /**
-   * Adds the `skip locked` option to a select query on supported databases.
+   * Adds the `skip locked` modifier to a select query on supported databases.
    */
   skipLocked(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'SkipLocked'
+        SelectModifierNode.create('SkipLocked')
       ),
     })
   }
 
   /**
-   * Adds the `nowait` option to a select query on supported databases.
+   * Adds the `nowait` modifier to a select query on supported databases.
    */
   noWait(): SelectQueryBuilder<DB, TB, O> {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithModifier(
+      queryNode: SelectQueryNode.cloneWithEndModifier(
         this.#props.queryNode,
-        'NoWait'
+        SelectModifierNode.create('NoWait')
       ),
     })
   }