8929693502

Committed 02 May 2024 07:57PM UTC coverage: 31.925% (+0.002%) from 31.923%

Build # 8929693502

Build Type

Pull #9213

github

Committed by

web-flow

Commit Message

Merge fee2a8b72 into b04e7a3d3

Pull Request Pull Request #9213: update merge accounts script

Run Details

4729 of 38674 branches covered (12.23%)

Branch coverage included in aggregate %.

11 of 17 new or added lines in 3 files covered. (64.71%)

1 existing line in 1 file now uncovered.

27580 of 62529 relevant lines covered (44.11%)

178.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.33

/packages/lesswrong/lib/sql/UpdateQuery.ts

import Query, { Atom } from "./Query";
import Table from "./Table";
import SelectQuery from "./SelectQuery";
import { JsonType, Type } from "./Type";

export type UpdateOptions = Partial<{
  limit: number,
  returnUpdated: boolean,
}>

interface CompileUpdateExpressionOptions {
  skipTypeHint?: boolean,
  jsonType?: JsonType
}

/**
 * Builds a Postgres query to update some specific data in the given table.
 * Note that upserting is handled by `InsertQuery` instead.
 */
class UpdateQuery<T extends DbObject> extends Query<T> {
  constructor(
    table: Table<T>,
    selector: string | MongoSelector<T>,
    modifier: MongoModifier<T>,
    options?: MongoUpdateOptions<T>, // TODO: What can options be?
    updateOptions?: UpdateOptions,
  ) {
    if (options?.upsert) {
      throw new Error("To create an upserting update use an InsertQuery with conflictStrategy 'upsert'");
    }

    super(table, ["UPDATE", table, "SET"]);
    this.nameSubqueries = false;

    const set: Partial<Record<keyof T, any>> = modifier.$set ?? {};
    const push: Partial<Record<keyof T, any>> = modifier.$push ?? {};
    const inc: Partial<Record<keyof T, any>> = modifier.$inc ?? {};
    const addToSet: Partial<Record<keyof T, any>> = modifier.$addToSet ?? {};
    for (const operation of Object.keys(modifier)) {
      switch (operation) {
        case "$set":
        case "$inc":
        case "$push":
        case "$addToSet":
          break;
        case "$unset":
          for (const field of Object.keys(modifier.$unset)) {
            (set as AnyBecauseTodo)[field] = null;
          }
          break;
        default:
          throw new Error(`Unimplemented update operation: ${operation}`);
      }
    }

    const compiledUpdates = [
      ...this.compileSetFields(set),
      ...this.compilePushFields(push),
      ...this.compileIncFields(inc),
      ...this.compileAddToSetFields(addToSet),
    ];

    this.atoms = this.atoms.concat(compiledUpdates.slice(1));

    if (typeof selector === "string") {
      selector = {_id: selector};
    }

    const {limit, returnUpdated} = updateOptions ?? {};

    if (selector && Object.keys(selector).length > 0) {
      this.atoms.push("WHERE");

      if (limit) {
        this.atoms = this.atoms.concat([
          "_id IN",
          new SelectQuery(table, selector, {limit, projection: {_id: 1}}, {forUpdate: true}),
        ]);
      } else {
        this.appendSelector(selector);
      }
    } else if (limit) {
      this.atoms = this.atoms.concat([
        "WHERE _id IN ( SELECT \"_id\" FROM",
        table,
        "LIMIT",
        this.createArg(limit),
        "FOR UPDATE)",
      ]);
    }

    if (returnUpdated) {
      this.atoms.push("RETURNING *");
    } else {
      this.atoms.push(`RETURNING "_id"`);
    }
  }

  private compileSetFields(sets: Partial<Record<keyof T, any>>): Atom<T>[] {
    const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>
      [",", resolvedField, "=", ...updateValue];
    return this.compileUpdateFields(sets, format);
  }

  private compilePushFields(pushes: Partial<Record<keyof T, any>>): Atom<T>[] {
    const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>
      [",", resolvedField, "= ARRAY_APPEND(", resolvedField, ",",  ...updateValue, ")"];
    return this.compileUpdateFields(pushes, format);
  }

  private compileIncFields(incs: Partial<Record<keyof T, any>>): Atom<T>[] {
    const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>
      [",", resolvedField, "= COALESCE(", resolvedField, ", 0 ) +",  ...updateValue];
    return this.compileUpdateFields(incs, format);
  }

  private compileAddToSetFields(addToSets: Partial<Record<keyof T, any>>): Atom<T>[] {
    const nativeArrays: Partial<Record<keyof T, any>> = {};
    const jsonArrays: Partial<Record<keyof T, any>> = {};

    for (const update of Object.keys(addToSets)) {
      const dot = update.indexOf(".");
      const column = dot > 0 ? update.substring(0, dot) : update;
      const columnType = this.getField(column);
      if (columnType?.toConcrete() instanceof JsonType) {
        (jsonArrays as AnyBecauseTodo)[update] = (addToSets as AnyBecauseTodo)[update];
      } else {
        (nativeArrays as AnyBecauseTodo)[update] = (addToSets as AnyBecauseTodo)[update];
      }
    }

    let jsonUpdates: Atom<T>[] = [];

    for (const jsonUpdate of Object.keys(jsonArrays)) {
      const {column, path} = this.buildJsonUpdatePath(jsonUpdate);
      const updateValue = this.compileUpdateExpression((jsonArrays as AnyBecauseTodo)[jsonUpdate]);
      jsonUpdates = jsonUpdates.concat(
        ",",
        column,
        "= fm_add_to_set(",
        column,
        ",",
        path,
        "::TEXT[] ,",
        ...updateValue,
        ")",
      );
    }

    const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>
      [",", resolvedField, "= fm_add_to_set(", resolvedField, ",",  ...updateValue, ")"];
    return [
      ...jsonUpdates,
      ...this.compileUpdateFields(nativeArrays, format),
    ];
  }

  private compileUpdateFields(
    updates: Partial<Record<keyof T, any>>,
    format: (resolvedField: string, updateValue: Atom<T>[]) => Atom<T>[],
  ): Atom<T>[] {
    return Object.keys(updates).flatMap((field) => this.compileUpdateField(field, (updates as AnyBecauseTodo)[field], format));
  }

  private compileUpdateField(
    field: string,
    value: any,
    format: (resolvedField: string, updateValue: Atom<T>[]) => Atom<T>[],
  ): Atom<T>[] {
    // If we're updating the value of a JSON blob without totally replacing
    // it then we need to wrap the update in a call to `JSONB_SET`.
    if (field.includes(".")) {
      const updateValue = this.compileUpdateExpression(value);
      const {column, path} = this.buildJsonUpdatePath(field);
      // Check if we're trying to unset the field (currently you can only unset fields in the first level)
      if (value === null) {
        const fieldTokens = field.split(".")
        if (fieldTokens.length === 2) {
          return format(
            column,
            [column, ` - '${fieldTokens[1]}'`],
          );
        } else {
          throw new Error(`Unsetting a field past the first level of a JSON blob is not yet supported`)
        }
      }
      
      return format(
        column,
        ["JSONB_SET(", column, ",", path, "::TEXT[], TO_JSONB(", ...updateValue, "), TRUE)"],
      );
    }
    
    try {
      const fieldType = this.getField(field);
      const arrayValueInNonArrayJsonbField = fieldType && !fieldType.isArray() && fieldType.toConcrete() instanceof JsonType && Array.isArray(value);
      const typeForArg = arrayValueInNonArrayJsonbField ? new JsonType() : undefined;
      const updateValue = this.compileUpdateExpression(value, { jsonType: typeForArg });
      const resolvedField = this.resolveFieldName(field);
      return format(resolvedField, updateValue);
    } catch (e) {
      // @ts-ignore
      throw new Error(`Field "${field}" is not recognized - is it missing from the schema?`, {cause: e});
    }
  }

  private compileUpdateExpression(value: unknown, options: CompileUpdateExpressionOptions = {}): Atom<T>[] {
    const { jsonType, skipTypeHint } = options;
    if (typeof value === "object" && value && Object.keys(value).some((key) => key[0] === "$")) {
      return this.compileExpression(value);
    } else {
      const arg = this.createArg(value, jsonType);
      if (!arg.typehint) {
        arg.typehint = this.getTypeHint(value);
      }
      if (skipTypeHint) {
        arg.typehint = "" 
      }
      return [arg];
    }
  }

  private buildJsonUpdatePath(field: string) {
    const tokens = field.split(".");
    const path = `'{${tokens.slice(1).join(", ")}}'`;
    return {
      column: `"${tokens[0]}"`,
      path,
    };
  }
}

export default UpdateQuery;

1	import Query, { Atom } from "./Query";	1,757✔
2	import Table from "./Table";
3	import SelectQuery from "./SelectQuery";	44✔
4	import { JsonType, Type } from "./Type";	44✔
5
6	export type UpdateOptions = Partial<{
7	limit: number,
8	returnUpdated: boolean,
9	}>
10
11	interface CompileUpdateExpressionOptions {
12	skipTypeHint?: boolean,
13	jsonType?: JsonType
14	}
15
16	/**
17	* Builds a Postgres query to update some specific data in the given table.
18	* Note that upserting is handled by `InsertQuery` instead.
19	*/
20	class UpdateQuery<T extends DbObject> extends Query<T> {
21	constructor(
22	table: Table<T>,
23	selector: string \| MongoSelector<T>,
24	modifier: MongoModifier<T>,
25	options?: MongoUpdateOptions<T>, // TODO: What can options be?
26	updateOptions?: UpdateOptions,
27	) {
28	if (options?.upsert) {	1,620!
29	throw new Error("To create an upserting update use an InsertQuery with conflictStrategy 'upsert'");	×
30	}
31
32	super(table, ["UPDATE", table, "SET"]);	1,620✔
33	this.nameSubqueries = false;	1,620✔
34
35	const set: Partial<Record<keyof T, any>> = modifier.$set ?? {};	1,620✔
36	const push: Partial<Record<keyof T, any>> = modifier.$push ?? {};	1,620✔
37	const inc: Partial<Record<keyof T, any>> = modifier.$inc ?? {};	1,620✔
38	const addToSet: Partial<Record<keyof T, any>> = modifier.$addToSet ?? {};	1,620✔
39	for (const operation of Object.keys(modifier)) {	1,620✔
40	switch (operation) {	1,657!
41	case "$set":
42	case "$inc":
43	case "$push":
44	case "$addToSet":
45	break;	1,636✔
46	case "$unset":
47	for (const field of Object.keys(modifier.$unset)) {	21✔
48	(set as AnyBecauseTodo)[field] = null;	21✔
49	}
50	break;	21✔
51	default:
52	throw new Error(`Unimplemented update operation: ${operation}`);	×
53	}
54	}
55
56	const compiledUpdates = [	1,620✔
57	...this.compileSetFields(set),
58	...this.compilePushFields(push),
59	...this.compileIncFields(inc),
60	...this.compileAddToSetFields(addToSet),
61	];
62
63	this.atoms = this.atoms.concat(compiledUpdates.slice(1));	1,619✔
64
65	if (typeof selector === "string") {	1,619✔
66	selector = {_id: selector};	562✔
67	}
68
69	const {limit, returnUpdated} = updateOptions ?? {};	1,619✔
70
71	if (selector && Object.keys(selector).length > 0) {	1,619✔
72	this.atoms.push("WHERE");	1,613✔
73
74	if (limit) {	1,613✔
75	this.atoms = this.atoms.concat([	1,430✔
76	"_id IN",
77	new SelectQuery(table, selector, {limit, projection: {_id: 1}}, {forUpdate: true}),
78	]);
79	} else {
80	this.appendSelector(selector);	183✔
81	}
82	} else if (limit) {	6✔
83	this.atoms = this.atoms.concat([	1✔
84	"WHERE _id IN ( SELECT \"_id\" FROM",
85	table,
86	"LIMIT",
87	this.createArg(limit),
88	"FOR UPDATE)",
89	]);
90	}
91
92	if (returnUpdated) {	1,619✔
93	this.atoms.push("RETURNING *");	17✔
94	} else {
95	this.atoms.push(`RETURNING "_id"`);	1,602✔
96	}
97	}
98
99	private compileSetFields(sets: Partial<Record<keyof T, any>>): Atom<T>[] {
100	const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>	1,620✔
101	[",", resolvedField, "=", ...updateValue];	2,655✔
102	return this.compileUpdateFields(sets, format);	1,620✔
103	}
104
105	private compilePushFields(pushes: Partial<Record<keyof T, any>>): Atom<T>[] {
106	const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>	1,619✔
107	[",", resolvedField, "= ARRAY_APPEND(", resolvedField, ",", ...updateValue, ")"];	1✔
108	return this.compileUpdateFields(pushes, format);	1,619✔
109	}
110
111	private compileIncFields(incs: Partial<Record<keyof T, any>>): Atom<T>[] {
112	const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>	1,619✔
113	[",", resolvedField, "= COALESCE(", resolvedField, ", 0 ) +", ...updateValue];	649✔
114	return this.compileUpdateFields(incs, format);	1,619✔
115	}
116
117	private compileAddToSetFields(addToSets: Partial<Record<keyof T, any>>): Atom<T>[] {
118	const nativeArrays: Partial<Record<keyof T, any>> = {};	1,619✔
119	const jsonArrays: Partial<Record<keyof T, any>> = {};	1,619✔
120
121	for (const update of Object.keys(addToSets)) {	1,619✔
122	const dot = update.indexOf(".");	2✔
123	const column = dot > 0 ? update.substring(0, dot) : update;	2✔
124	const columnType = this.getField(column);	2✔
125	if (columnType?.toConcrete() instanceof JsonType) {	2!
126	(jsonArrays as AnyBecauseTodo)[update] = (addToSets as AnyBecauseTodo)[update];	1✔
127	} else {
128	(nativeArrays as AnyBecauseTodo)[update] = (addToSets as AnyBecauseTodo)[update];	1✔
129	}
130	}
131
132	let jsonUpdates: Atom<T>[] = [];	1,619✔
133
134	for (const jsonUpdate of Object.keys(jsonArrays)) {	1,619✔
135	const {column, path} = this.buildJsonUpdatePath(jsonUpdate);	1✔
136	const updateValue = this.compileUpdateExpression((jsonArrays as AnyBecauseTodo)[jsonUpdate]);	1✔
137	jsonUpdates = jsonUpdates.concat(	1✔
138	",",
139	column,
140	"= fm_add_to_set(",
141	column,
142	",",
143	path,
144	"::TEXT[] ,",
145	...updateValue,
146	")",
147	);
148	}
149
150	const format = (resolvedField: string, updateValue: Atom<T>[]): Atom<T>[] =>	1,619✔
151	[",", resolvedField, "= fm_add_to_set(", resolvedField, ",", ...updateValue, ")"];	1✔
152	return [	1,619✔
153	...jsonUpdates,
154	...this.compileUpdateFields(nativeArrays, format),
155	];
156	}
157
158	private compileUpdateFields(
159	updates: Partial<Record<keyof T, any>>,
160	format: (resolvedField: string, updateValue: Atom<T>[]) => Atom<T>[],
161	): Atom<T>[] {
162	return Object.keys(updates).flatMap((field) => this.compileUpdateField(field, (updates as AnyBecauseTodo)[field], format));	6,477✔
163	}
164
165	private compileUpdateField(
166	field: string,
167	value: any,
168	format: (resolvedField: string, updateValue: Atom<T>[]) => Atom<T>[],
169	): Atom<T>[] {
170	// If we're updating the value of a JSON blob without totally replacing
171	// it then we need to wrap the update in a call to `JSONB_SET`.
172	if (field.includes(".")) {	3,307✔
173	const updateValue = this.compileUpdateExpression(value);	3✔
174	const {column, path} = this.buildJsonUpdatePath(field);	3✔
175	// Check if we're trying to unset the field (currently you can only unset fields in the first level)
176	if (value === null) {	3✔
177	const fieldTokens = field.split(".")	2✔
178	if (fieldTokens.length === 2) {	2✔
179	return format(	1✔
180	column,
181	[column, ` - '${fieldTokens[1]}'`],
182	);
183	} else {
184	throw new Error(`Unsetting a field past the first level of a JSON blob is not yet supported`)	1✔
185	}
186	}
187
188	return format(	1✔
189	column,
190	["JSONB_SET(", column, ",", path, "::TEXT[], TO_JSONB(", ...updateValue, "), TRUE)"],
191	);
192	}
193
194	try {	3,304✔
195	const fieldType = this.getField(field);	3,304✔
196	const arrayValueInNonArrayJsonbField = fieldType && !fieldType.isArray() && fieldType.toConcrete() instanceof JsonType && Array.isArray(value);	3,304✔
197	const typeForArg = arrayValueInNonArrayJsonbField ? new JsonType() : undefined;	3,304✔
198	const updateValue = this.compileUpdateExpression(value, { jsonType: typeForArg });	3,304✔
199	const resolvedField = this.resolveFieldName(field);	3,304✔
200	return format(resolvedField, updateValue);	3,304✔
201	} catch (e) {
202	// @ts-ignore
203	throw new Error(`Field "${field}" is not recognized - is it missing from the schema?`, {cause: e});	×
204	}
205	}
206
207	private compileUpdateExpression(value: unknown, options: CompileUpdateExpressionOptions = {}): Atom<T>[] {	4✔
208	const { jsonType, skipTypeHint } = options;	3,308✔
209	if (typeof value === "object" && value && Object.keys(value).some((key) => key[0] === "$")) {	3,308!
210	return this.compileExpression(value);	×
211	} else {
212	const arg = this.createArg(value, jsonType);	3,308✔
213	if (!arg.typehint) {	3,308✔
214	arg.typehint = this.getTypeHint(value);	3,306✔
215	}
216	if (skipTypeHint) {	3,308!
UNCOV 217	arg.typehint = ""	×
218	}
219	return [arg];	3,308✔
220	}
221	}
222
223	private buildJsonUpdatePath(field: string) {
224	const tokens = field.split(".");	4✔
225	const path = `'{${tokens.slice(1).join(", ")}}'`;	4✔
226	return {	4✔
227	column: `"${tokens[0]}"`,
228	path,
229	};
230	}
231	}
232
233	export default UpdateQuery;	44✔

ForumMagnum / ForumMagnum / 8929693502

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous