Function toEntityPartitionBy

packages/sql/src/schema/partitioning.ts:419–474

(
  partitioning: TablePartitioning | undefined,
  parentTableName?: string,
  parentSchema?: string,
)

/** @internal */
export const toEntityPartitionBy = (
  partitioning: TablePartitioning | undefined,
  parentTableName?: string,
  parentSchema?: string,
): EntityPartitionBy | undefined => {
  if (!partitioning) {
    return undefined;
  }

  const normalizedDefinition = normalizePartitionDefinition(partitioning.definition);
  const normalizedPartitions = partitioning.partitions.map(partition => ({
    ...partition,
    bound: normalizePartitionBound(partition.bound),
  }));
  // Split the leading type keyword off of the definition without using `split(' ')`, which would
  // shatter quoted literals containing spaces. Match a bareword prefix followed by whitespace.
  const [, rawType = normalizedDefinition, rawExpression = ''] =
    /^(\S+)(?:\s+([\s\S]*))?$/.exec(normalizeWhitespace(normalizedDefinition)) ?? [];
  const type = rawType.toLowerCase();

  if (!isSupportedPartitionType(type)) {
    throw new Error(`Unsupported partition type '${rawType}' in definition '${partitioning.definition}'`);
  }

  const expression = unwrapOuterParentheses(rawExpression);
  const qualify = (partition: TablePartition) =>
    partition.schema && partition.schema !== parentSchema ? `${partition.schema}.${partition.name}` : partition.name;

  if (type === 'hash') {
    // Collapse to a bare count when catalog names follow the default
    // `${parentTableName}_${remainder}` pattern and live in the parent's schema, or when we have
    // no parent context to compare against (backwards-compatible behavior for callers that pass
    // just the `TablePartitioning`). Otherwise preserve the explicit name array so the next DDL
    // generation reproduces the same children.
    const usesDefaultShape =
      parentTableName == null ||
      normalizedPartitions.every(
        (p, i) => p.name === `${parentTableName}_${i}` && (!p.schema || p.schema === parentSchema),
      );

    return {
      type,
      expression,
      partitions: usesDefaultShape ? normalizedPartitions.length : normalizedPartitions.map(qualify),
    };
  }

  return {
    type,
    expression,
    partitions: normalizedPartitions.map(partition => ({
      name: qualify(partition),
      values: partition.bound === 'default' ? 'default' : partition.bound.replace(/^for values\s+/i, ''),
    })),
  };
};