Function processSQLQueryIR

packages/runtime/src/preprocessor-sql.ts:15–173

(
  queryIR: SQLQueryIR,
  passedParams?: QueryParameters,
)

/* Processes query AST formed by new parser from pure SQL files */
export const processSQLQueryIR = (
  queryIR: SQLQueryIR,
  passedParams?: QueryParameters,
): InterpolatedQuery => {
  const bindings: Scalar[] = [];
  const paramMapping: QueryParameter[] = [];
  const usedParams = queryIR.params.filter(
    (p) => p.name in queryIR.usedParamSet,
  );
  let i = 1;
  const intervals: { a: number; b: number; sub: string }[] = [];
  for (const usedParam of usedParams) {
    // Handle spread transform
    if (usedParam.transform.type === TransformType.ArraySpread) {
      let sub: string;
      if (passedParams) {
        const paramValue = passedParams[usedParam.name];
        sub = (paramValue as Scalar[])
          .map((val) => {
            bindings.push(val);
            return `$${i++}`;
          })
          .join(',');
      } else {
        const idx = i++;
        paramMapping.push({
          name: usedParam.name,
          type: ParameterTransform.Spread,
          assignedIndex: idx,
          required: usedParam.required,
        } as ScalarArrayParameter);
        sub = `$${idx}`;
      }
      usedParam.locs.forEach((loc) =>
        intervals.push({
          ...loc,
          sub: `(${sub})`,
        }),
      );
      continue;
    }

    // Handle pick transform
    if (usedParam.transform.type === TransformType.PickTuple) {
      const dict: {
        [key: string]: ScalarParameter;
      } = {};
      const sub = usedParam.transform.keys
        .map(({ name, required }) => {
          const idx = i++;
          dict[name] = {
            name,
            required,
            type: ParameterTransform.Scalar,
            assignedIndex: idx,
          } as ScalarParameter;
          if (passedParams) {
            const paramValue = passedParams[usedParam.name] as NestedParameters;