objection 3.7.0 → 3.9.0

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -6,7 +6,7 @@ const { createNotModelError } = require('../../model/graph/ModelGraphBuilder');
 const { GraphFetcher } = require('../graph/GraphFetcher');
 const { GraphInsert } = require('./insert/GraphInsert');
 const { GraphPatch } = require('./patch/GraphPatch');
-const { GraphDelete } = require('./delete/GraphDelete');
+const { GraphDelete, GraphDereferencedBelongsToOneDelete } = require('./delete/GraphDelete');
 const { GraphRecursiveUpsert } = require('./recursiveUpsert/GraphRecursiveUpsert');
 const { GraphOptions, OPTION_NAMES } = require('./GraphOptions');
 const { ValidationErrorType } = require('../../model/ValidationError');
@@ -14,16 +14,17 @@ const { RelationExpression } = require('../RelationExpression');
 const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
 const { GraphData } = require('./GraphData');
 const { uniqBy, asArray, isObject } = require('../../utils/objectUtils');
-const { deprecate } = require('../../utils/deprecate');
+const { warnOnce } = require('../../utils/warnings');
 
 class GraphUpsert {
-  constructor({ rootModelClass, objects, upsertOptions }) {
+  constructor({ rootModelClass, objects, upsertOptions, insertOnly = false }) {
     checkCanBeConvertedToModels(rootModelClass, objects);
     warnOnUnknownOptions(upsertOptions);
 
     this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
     this.isArray = Array.isArray(objects);
     this.upsertOpt = upsertOptions;
+    this.insertOnly = insertOnly;
   }
 
   static get modelOptions() {
@@ -36,10 +37,10 @@ class GraphUpsert {
   // by `ignore()` aren't returned, which leaves the root models without ids,
   // so that related rows would be inserted with missing or wrong foreign keys.
   // The clause is ignored, and a warning is logged once per method.
-  // TODO: Throw an error instead in objection 4.0.
+  // TODO: Throw an error instead in objection 4.0 (#53).
   static warnOnConflict(builder, method) {
     if (builder.has(isOnConflictOperation)) {
-      deprecate(
+      warnOnce(
         `onConflict(), ignore() and merge() are not supported by ${method}(). ` +
           'Insert the conflicting rows with a separate insert() query instead. ' +
           'This will throw in objection 4.0.',
@@ -49,7 +50,7 @@ class GraphUpsert {
 
   run(builder) {
     const modelClass = builder.modelClass();
-    const graphOptions = new GraphOptions(this.upsertOpt);
+    const graphOptions = new GraphOptions(this.upsertOpt, [], this.insertOnly);
 
     const graph = ModelGraph.create(modelClass, this.objects);
     assignDbRefsAsRelateProps(graph);
@@ -59,13 +60,14 @@ class GraphUpsert {
       .then(pruneGraphs())
       .then(checkForJoinTableRelatedTableErrors(builder))
       .then(executeOperations(builder))
+      .then(removeReferenceProps(graph.nodes))
       .then(returnResult(this.objects, this.isArray));
   }
 }
 
 // Misspelled options are silently ignored, so the operation runs with the
 // default behaviour instead (#84). A warning is logged once per option.
-// TODO: Throw an error instead in objection 4.0.
+// TODO: Throw an error instead in objection 4.0 (#53).
 function warnOnUnknownOptions(upsertOptions) {
   // Recursive upserts pass on the already checked options of their parent.
   if (upsertOptions instanceof GraphOptions) {
@@ -74,7 +76,7 @@ function warnOnUnknownOptions(upsertOptions) {
 
   for (const name of Object.keys(upsertOptions)) {
     if (!OPTION_NAMES.includes(name)) {
-      deprecate(
+      warnOnce(
         `Unknown graph option "${name}" is ignored. ` +
           `Valid options are: ${OPTION_NAMES.join(', ')}. This will throw in objection 4.0.`,
       );
@@ -127,6 +129,7 @@ function fetchCurrentGraph(builder, graphOptions, graph) {
 function pruneGraphs() {
   return (graphData) => {
     pruneRelatedBranches(graphData);
+    pruneSkippedBranches(graphData);
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
@@ -148,6 +151,31 @@ function pruneRelatedBranches(graphData) {
   removeBranchesFromGraph(findRoots(relateNodes), graphData.graph);
 }
 
+// Nothing is written below nodes that `noInsert` skips, as their descendants
+// would be orphans (#215). Branches that references from outside point into
+// are kept, since the references need their models.
+function pruneSkippedBranches(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const skippedNodes = graph.nodes.filter((node) => {
+    return (
+      graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
+      !graphOptions.shouldInsert(node, graphData) &&
+      !isReferencedFromOutside(node.descendantRelationNodes)
+    );
+  });
+
+  removeBranchesFromGraph(findRoots(skippedNodes), graph);
+}
+
+function isReferencedFromOutside(nodes) {
+  const nodeSet = new Set(nodes);
+
+  return nodes.some((node) =>
+    node.refEdges.some((edge) => edge.isRelatedNode(node) && !nodeSet.has(edge.ownerNode)),
+  );
+}
+
 function pruneDeletedBranches(graphData) {
   const { graph, currentGraph } = graphData;
 
@@ -245,11 +273,14 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
-    checkForUnallowedMarkerErrors(graphData, builder);
+    // Root models can't be marked even with `allowMarkers`, so report that
+    // first instead of pointing to the option.
     checkForRootUnrelateOrDeleteErrors(graphData, builder);
+    checkForUnallowedMarkerErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
+      warnOnInsertBelowRelate(graphData);
     }
 
     return graphData;
@@ -287,12 +318,19 @@ function checkForJoinTableRelatedTableErrors(builder) {
 
 function checkForNotFoundErrors(graphData, builder) {
   const { graphOptions, currentGraph, graph } = graphData;
+  // The branches below related nodes are upserted and checked by nested
+  // `upsertGraph` calls, against the current graphs of the related nodes:
+  const nestedNodes = new Set(
+    graph.nodes
+      .filter((node) => graphOptions.shouldRelate(node, graphData))
+      .flatMap((node) => node.descendantRelationNodes),
+  );
 
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
-      !node.toBeUnrelated &&
-      !node.toBeDeleted &&
+      !nestedNodes.has(node) &&
+      !node.toBeUnrelatedOrDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
       !currentGraph.nodeForNode(node)
@@ -347,10 +385,12 @@ function checkForUnallowedReferenceErrors(graphData, builder) {
 
 // `#unrelate` and `#delete` markers come from the graph data, which may be
 // untrusted input. Like `#ref`, they have to be allowed explicitly (#2410).
+// An insert has nothing to unrelate or delete, so `insertGraph` rejects them.
 function checkForUnallowedMarkerErrors(graphData, builder) {
   const { graph, graphOptions } = graphData;
+  const isInsertOnly = graphOptions.isInsertOnly();
 
-  if (graphOptions.allowMarkers()) {
+  if (graphOptions.allowMarkers() && !isInsertOnly) {
     return;
   }
 
@@ -361,7 +401,9 @@ function checkForUnallowedMarkerErrors(graphData, builder) {
 
     throw builder.modelClass().createValidationError({
       type: ValidationErrorType.InvalidGraph,
-      message: `${graphUnrelateProp} and ${graphDeleteProp} markers are not allowed in a graph by default. see the allowMarkers insert/upsert graph option`,
+      message: isInsertOnly
+        ? `${graphUnrelateProp} and ${graphDeleteProp} can only be used in upsertGraph, not in insertGraph`
+        : `${graphUnrelateProp} and ${graphDeleteProp} markers are not allowed in a graph by default. see the allowMarkers upsertGraph option`,
     });
   }
 }
@@ -394,11 +436,41 @@ function checkForHasManyRelateErrors(graphData) {
   }
 }
 
+// `upsertGraph` upserts the branches below related models recursively, but
+// `insertGraph` prunes them, which drops the models that would be inserted
+// there (#217). A warning is logged once.
+// TODO: Throw an error instead in objection 4.0 (#53).
+function warnOnInsertBelowRelate(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const hasInsertBelowRelate = graph.nodes.some(
+    (node) =>
+      graphOptions.shouldRelate(node, graphData) &&
+      node.descendantRelationNodes.some((descendantNode) =>
+        graphOptions.shouldInsert(descendantNode, graphData),
+      ),
+  );
+
+  if (hasInsertBelowRelate) {
+    warnOnce(
+      'insertGraph() ignores new models below related models. ' +
+        'Insert them with a separate query or use upsertGraph() instead. ' +
+        'This will throw in objection 4.0.',
+    );
+  }
+}
+
 function executeOperations(builder) {
   return (graphData) => {
     const operations = graphData.graphOptions.isInsertOnly()
       ? [GraphInsert]
-      : [GraphDelete, GraphInsert, GraphPatch, GraphRecursiveUpsert];
+      : [
+          GraphDelete,
+          GraphInsert,
+          GraphPatch,
+          GraphDereferencedBelongsToOneDelete,
+          GraphRecursiveUpsert,
+        ];
 
     return operations.reduce((promise, Operation) => {
       const operation = new Operation(graphData);
@@ -416,6 +488,18 @@ function executeActions(builder, actions) {
   );
 }
 
+// The reference markers only describe the input graph, don't return them.
+// `nodes` are the nodes before pruning, since the results of pruned branches
+// contain markers too.
+function removeReferenceProps(nodes) {
+  return () => {
+    for (const node of nodes) {
+      delete node.obj[node.modelClass.uidRefProp];
+      delete node.obj[node.modelClass.dbRefProp];
+    }
+  };
+}
+
 function isOnConflictOperation(op) {
   return op.name === 'onConflict' || op.name === 'ignore' || op.name === 'merge';
 }

package/lib/queryBuilder/graph/delete/GraphDelete.js

@@ -2,19 +2,72 @@
 
 const { GraphOperation } = require('../GraphOperation');
 const { GraphDeleteAction } = require('./GraphDeleteAction');
+const { getPropertyTypes } = require('../../../model/modelJsonAttributes');
 
 class GraphDelete extends GraphOperation {
+  // The owner of a BelongsToOneRelation row references it until `GraphPatch`
+  // points the owner to a new row or to null. These rows are deleted
+  // afterwards by `GraphDereferencedBelongsToOneDelete`, all others before.
+  get deletesDereferencedRows() {
+    return false;
+  }
+
   createActions() {
     return [
       new GraphDeleteAction(this.graphData, {
-        nodes: this.currentGraph.nodes.filter((currentNode) =>
-          this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData),
+        nodes: this.currentGraph.nodes.filter(
+          (currentNode) =>
+            this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData) &&
+            isDereferencedBelongsToOneNode(currentNode, this.graphData) ===
+              this.deletesDereferencedRows,
         ),
+        areReferenced: !this.deletesDereferencedRows,
       }),
     ];
   }
 }
 
+class GraphDereferencedBelongsToOneDelete extends GraphDelete {
+  get deletesDereferencedRows() {
+    return true;
+  }
+}
+
+function isDereferencedBelongsToOneNode(currentNode, graphData) {
+  const { graph, graphOptions } = graphData;
+  const relation = currentNode.parentEdge?.relation;
+  const parentNode = graph.nodeForNode(currentNode.parentNode);
+
+  if (relation?.isObjectionBelongsToOneRelation && parentNode) {
+    const node = graph.nodeForNode(currentNode);
+    const isReplaced = parentNode.edges.some(
+      (edge) =>
+        edge.relation === relation &&
+        edge.isOwnerNode(parentNode) &&
+        !graphOptions.shouldIgnore(edge.relatedNode, graphData),
+    );
+    const isRemoved =
+      parentNode.obj[relation.name] === null || (!!node && node.toBeUnrelatedOrDeleted);
+
+    // Removing the row sets the owner's foreign key to null, but only where
+    // its schema allows it. Otherwise we delete the row first and leave the
+    // owner's reference to the database, as the column may be `NOT NULL`.
+    return (
+      isReplaced ||
+      (isRemoved &&
+        relation.ownerProp.props.every((prop) => isNullable(relation.ownerModelClass, prop)))
+    );
+  } else {
+    return false;
+  }
+}
+
+function isNullable(modelClass, prop) {
+  const schema = modelClass.getJsonSchema()?.properties?.[prop];
+  return !!schema && (schema.nullable === true || getPropertyTypes(schema).includes('null'));
+}
+
 module.exports = {
   GraphDelete,
+  GraphDereferencedBelongsToOneDelete,
 };

package/lib/queryBuilder/graph/delete/GraphDeleteAction.js

@@ -5,10 +5,14 @@ const { groupBy } = require('../../../utils/objectUtils');
 const promiseUtils = require('../../../utils/promiseUtils');
 
 class GraphDeleteAction extends GraphAction {
-  constructor(graphData, { nodes }) {
+  constructor(graphData, { nodes, areReferenced = true }) {
     super(graphData);
     // Nodes to delete.
     this.nodes = nodes;
+    // Whether the parents still reference the nodes. Rows of
+    // BelongsToOneRelations can be deleted after their owners were patched to
+    // reference new rows or null, so they can't be found through the relation.
+    this.areReferenced = areReferenced;
   }
 
   run(builder) {
@@ -47,10 +51,14 @@ class GraphDeleteAction extends GraphAction {
         );
 
         nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
-          const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
-
-          if (!relation.isObjectionBelongsToOneRelation) {
-            // This is useless in case of BelongsToOneRelation.
+          const builder = (
+            this.areReferenced
+              ? parentNode.obj.$relatedQuery(relation.name)
+              : relation.relatedModelClass.query()
+          ).childQueryOf(parentBuilder);
+
+          if (!this.areReferenced || !relation.isObjectionBelongsToOneRelation) {
+            // This is useless in case of a referenced BelongsToOneRelation.
             builder.findByIds(nodes.map((node) => node.obj.$id()));
           }
 

package/lib/queryBuilder/graph/insert/GraphInsert.js

@@ -46,7 +46,12 @@ class GraphInsert extends GraphOperation {
       // In case of HasManyRelation the related node depends on the owner node
       // because the related node has the foreign key.
       this._addDependency(edge.relatedNode, edge, dependencies);
-    } else if (edge.relation.isObjectionBelongsToOneRelation) {
+    } else if (
+      edge.relation.isObjectionBelongsToOneRelation &&
+      // Ignored models don't replace the current one, so their keys must not
+      // be copied to the owner either.
+      !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
+    ) {
       // In case of BelongsToOneRelation the owner node depends on the related
       // node because the owner node has the foreign key.
       this._addDependency(edge.ownerNode, edge, dependencies);

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -128,8 +128,9 @@ class GraphPatchAction extends GraphAction {
         edge.relation &&
         edge.relation.isObjectionBelongsToOneRelation &&
         edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
-        // Models marked with `#unrelate` or `#delete` are handled below.
-        !edge.relatedNode.toBeUnrelatedOrDeleted
+        // Ignored models don't replace the current one, and models marked with
+        // `#unrelate` or `#delete` are handled below.
+        !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
       ) {
         const { relation } = edge;
 

package/lib/queryBuilder/join/JoinResultParser.js

@@ -9,7 +9,7 @@ class JoinResultParser {
     this.omitColumnAliases = new Set(omitColumnAliases);
 
     this.columnsByTableNode = null;
-    this.parentMap = null;
+    this.modelsByTableNode = null;
     this.rootModels = null;
   }
 
@@ -25,7 +25,8 @@ class JoinResultParser {
     this._checkIdColumns(flatRows[0]);
 
     this.columnsByTableNode = this._createColumns(flatRows[0]);
-    this.parentMap = new Map();
+    // Key the models of each table node by the ids on their path from the root:
+    this.modelsByTableNode = new Map(this.tableTree.nodes.map((node) => [node, new Map()]));
     this.rootModels = [];
 
     for (const flatRow of flatRows) {
@@ -42,14 +43,15 @@ class JoinResultParser {
       return;
     }
 
-    const key = getKey(parentKey, id, tableNode);
-    let model = this.parentMap.get(key);
+    const key = getKey(parentKey, id);
+    const models = this.modelsByTableNode.get(tableNode);
+    let model = models.get(key);
 
     if (!model) {
       model = this._createModel(tableNode, flatRow);
 
       this._addToParent(tableNode, model, parentModel);
-      this.parentMap.set(key, model);
+      models.set(key, model);
     }
 
     for (const childNode of tableNode.childNodes) {
@@ -128,11 +130,14 @@ function getTableNode(column) {
   return column.tableNode;
 }
 
-function getKey(parentKey, id, tableNode) {
+// Escape the separator in the ids, since string ids can contain it.
+function getKey(parentKey, id) {
+  const escapedId = id.includes('/') || id.includes('\\') ? id.replace(/[/\\]/g, '\\$&') : id;
+
   if (parentKey !== null) {
-    return `${parentKey}/${tableNode.relationProperty}/${id}`;
+    return `${parentKey}/${escapedId}`;
   } else {
-    return `/${id}`;
+    return escapedId;
   }
 }
 

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { uniqBy } = require('../../utils/objectUtils');
-const { Selection } = require('../operations/select/Selection');
+const { Selection, isSameTable, mapIdentifier } = require('../operations/select/Selection');
 const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
@@ -89,6 +89,13 @@ class RelationJoiner {
     }
   }
 
+  // Whether the joins can return more than one row per root model.
+  hasToManyJoins(builder) {
+    return this._getTableTree(builder).nodes.some(
+      (tableNode) => tableNode.relation && !tableNode.relation.isOneToOne(),
+    );
+  }
+
   parseResult(builder, flatRows) {
     const parser = JoinResultParser.create({
       tableTree: this._getTableTree(builder),
@@ -203,7 +210,60 @@ class RelationJoiner {
       }
     }
 
-    builder.select(selectionsToStrings(selections));
+    // Each name is selected only once, as SQL Server returns duplicate names as
+    // arrays of values, and the other databases silently return one of them.
+    removeRootSelectAll(builder);
+    const tableTree = this._getTableTree(builder);
+    const userSelectionsByName = new Map();
+
+    for (const selection of findJoinSelections(builder)) {
+      // Only the columns of the joined tables are known for `table.*`:
+      const node = isSelectAll(selection) ? tableTree.nodesByAlias.get(selection.table) : null;
+      const names = node
+        ? getAllColumnSelectionsForNode({ builder, tableNode: node }).map((it) => it.column)
+        : [selection.name];
+
+      for (const name of names) {
+        userSelectionsByName.set(mapIdentifier(builder, name), { selection, name });
+      }
+    }
+
+    const idAliases = new Set(
+      tableTree.nodes.flatMap((node) =>
+        getIdSelectionsForNode({ tableNode: node }).map((it) => it.alias),
+      ),
+    );
+
+    builder.select(
+      selectionsToStrings(
+        selections.filter(({ table, column, alias }) => {
+          const { selection, name } = userSelectionsByName.get(mapIdentifier(builder, alias)) || {};
+
+          if (!selection) {
+            return true;
+          } else if (selection.column) {
+            if (!Selection.doesSelect(builder, selection, `${table}.${column}`)) {
+              throw new Error(
+                `withGraphJoined: the selection '${selectionToString(selection)}' selects '${name}', ` +
+                  `the name under which the column '${table}.${column}' is selected. ` +
+                  'Select it under a different name.',
+              );
+            }
+          } else if (idAliases.has(alias)) {
+            // Raws, subqueries and aggregates select values that we can't see
+            // into. They replace our columns, but not the ids that we need to
+            // parse the result.
+            throw new Error(
+              `withGraphJoined: a raw, subquery or aggregate selection selects '${name}', ` +
+                `the name under which the id column '${table}.${column}' is selected. ` +
+                'Select it under a different name, or select the id column itself.',
+            );
+          }
+
+          return false;
+        }),
+      ),
+    );
   }
 }
 
@@ -268,8 +328,9 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
     ),
   ];
 
+  const hasSelectionAs = createHasSelectionAs(builder);
   const selectStrings = uniqBy(cols)
-    .filter((col) => !hasSelectionAs(builder, col))
+    .filter((col) => !hasSelectionAs(col))
     .map((col) => `${tableRef}.${col}`);
 
   return builder.select(selectStrings);
@@ -297,9 +358,10 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     selections = allColumnSelections.concat(selections);
   } else {
     const idSelections = getIdSelectionsForNode({ tableNode });
+    const hasUserSelectionAs = createHasUserSelectionAs(userSelectQuery, tableNode);
 
     for (const idSelection of idSelections) {
-      if (!hasUserSelectionAs(userSelectQuery, tableNode, idSelection.column)) {
+      if (!hasUserSelectionAs(idSelection.column)) {
         selections.push(idSelection);
         internalSelections.push(idSelection);
       }
@@ -334,14 +396,16 @@ function findJoinSelections(builder) {
   return selections;
 }
 
-// Like `builder.hasSelectionAs(column, column)`, but ignoring the columns
-// passed to aggregates, as they don't select them.
-function hasSelectionAs(builder, column) {
+// Create a `(column) => builder.hasSelectionAs(column, column)` function that
+// ignores the columns passed to aggregates, as they don't select them. Clone
+// the builder once, not once per column.
+function createHasSelectionAs(builder) {
   if (builder.has(isAggregateOperation)) {
+    const selectionQuery = builder.clone().clear(isAggregateOperation);
     // Explicit, as a query with only aggregates doesn't select all columns.
-    return builder.clone().clear(isAggregateOperation).hasSelectionAs(column, column, true);
+    return (column) => selectionQuery.hasSelectionAs(column, column, true);
   } else {
-    return builder.hasSelectionAs(column, column);
+    return (column) => builder.hasSelectionAs(column, column);
   }
 }
 
@@ -355,11 +419,12 @@ function findUserSelections(builder, tableNode) {
   }
 }
 
-function hasUserSelectionAs(builder, tableNode, column) {
+function createHasUserSelectionAs(builder, tableNode) {
   if (tableNode.parentNode) {
-    return hasSelectionAs(builder, column);
+    return createHasSelectionAs(builder);
   } else {
-    return builder.hasSelectionAs(column, column);
+    // Qualified, as the root query can also select the columns of the joined tables.
+    return (column) => builder.hasSelectionAs(`${tableNode.alias}.${column}`, column);
   }
 }
 
@@ -416,6 +481,29 @@ function getIdSelectionsForNode({ tableNode }) {
   });
 }
 
+// The selections of all columns of the root table replace the user's `*`, which
+// would select them a second time, and a bare `*` also the columns of the
+// joined tables under the same names.
+function removeRootSelectAll(builder) {
+  const tableRef = builder.tableRef();
+  const isRootSelectAll = (selection) =>
+    selection.column === '*' &&
+    (!selection.table || isSameTable(builder, selection.table, tableRef));
+  const isSelect = (op) =>
+    op.constructor === SelectOperation && !isAggregateOperation(op) && !op.isDistinctOn;
+
+  builder.forEachOperation(isSelect, (op) => {
+    op.args = op.args.filter((arg) => {
+      const selection = Selection.create(arg);
+      return !selection || !isRootSelectAll(selection);
+    });
+    op.selections = op.selections.filter((selection) => !isRootSelectAll(selection));
+  });
+
+  // An empty `distinct()` still makes the whole select distinct.
+  builder.clear((op) => isSelect(op) && op.name !== 'distinct' && op.args.length === 0);
+}
+
 function selectionsToStrings(selections) {
   return selections.map((selection) => {
     const selectStr = `${selection.table}.${selection.column}`;
@@ -423,6 +511,11 @@ function selectionsToStrings(selections) {
   });
 }
 
+function selectionToString({ table, column, alias }) {
+  const selection = table ? `${table}.${column}` : column;
+  return alias ? `${selection} as ${alias}` : selection;
+}
+
 function isSelectAll(selection) {
   return selection.column === '*';
 }