如何在postgresql动态SQL中引用变量？

Question

我正在尝试编写一个可用于任何表的表更新插入的 PostgreSQL 函数。我的出发点取自特定表类型的具体函数：

CREATE TABLE doodad(id BIGINT PRIMARY KEY, data JSON);
CREATE OR REPLACE FUNCTION upsert_doodad(d doodad) RETURNS VOID AS
  $BODY$
BEGIN
  LOOP
    UPDATE doodad
       SET id = (d).id, data = (d).data
     WHERE id = (d).id;
    IF found THEN
      RETURN;
    END IF;

    -- does not exist, or was just deleted.

    BEGIN
      INSERT INTO doodad SELECT d.*;
      RETURN;
    EXCEPTION when UNIQUE_VIOLATION THEN
      -- do nothing, and loop to try the update again
    END;

  END LOOP;
END;
  $BODY$
LANGUAGE plpgsql;

我提出的任何表的动态 SQL 版本都在这里： SQL 小提琴

CREATE OR REPLACE FUNCTION upsert(target ANYELEMENT) RETURNS VOID AS
$$
DECLARE
  attr_name NAME;
  col TEXT;
  selectors TEXT[];
  setters TEXT[];
  update_stmt TEXT;
  insert_stmt TEXT;
BEGIN
  FOR attr_name IN SELECT a.attname
                     FROM pg_index i
                     JOIN pg_attribute a ON a.attrelid = i.indrelid 
                                        AND a.attnum = ANY(i.indkey)
                    WHERE i.indrelid = format_type(pg_typeof(target), NULL)::regclass
                      AND i.indisprimary
  LOOP
    selectors := array_append(selectors, format('%1$s = target.%1$s', attr_name));
  END LOOP;

  FOR col IN SELECT json_object_keys(row_to_json(target))
  LOOP
    setters := array_append(setters, format('%1$s = (target).%1$s', col)); 
  END LOOP;

  update_stmt := format(
    'UPDATE %s SET %s WHERE %s',
    pg_typeof(target),
    array_to_string(setters, ', '),
    array_to_string(selectors, ' AND ')
  );
  insert_stmt := format('INSERT INTO %s SELECT (target).*', pg_typeof(target));

  LOOP
    EXECUTE update_stmt; 
    IF found THEN
      RETURN;
    END IF;

    BEGIN
      EXECUTE insert_stmt;
      RETURN;
    EXCEPTION when UNIQUE_VIOLATION THEN
      -- do nothing
    END;
  END LOOP;
END;
$$
LANGUAGE plpgsql;

当我尝试使用此功能时，出现错误：

SELECT * FROM upsert(ROW(1,'{}')::doodad);

错误：列“目标”不存在：SELECT * FROM upsert(ROW(1,'{}')::doodad)

我尝试更改 upsert 语句以使用占位符，但我不知道如何使用记录调用它：

EXECUTE update_stmt USING target;

错误：没有参数 $2：SELECT * FROM upsert(ROW(1,'{}')::doodad)

EXECUTE update_stmt USING target.*;

错误：查询“SELECT target.*”返回 2 列：SELECT * FROM upsert(ROW(1,'{}')::doodad)

我感觉非常接近解决方案，但我无法弄清楚语法问题。

Answer 1

简短回答：你不能。

给 EXECUTE 或其变体之一的命令字符串中不会发生变量替换。如果您需要将变化的值插入到此类命令中，请在构造字符串值的过程中执行此操作，或者使用 USING，如第 40.5.4 节所示。 ^{1（9.3），1a（当前）}

更长的答案：

PL/pgSQL 函数中的 SQL 语句和表达式可以引用函数的变量和参数。在幕后，PL/pgSQL 用查询参数替代此类引用。 ^{2（9.3），2a（当前）}

这是这个难题的第一个重要部分：PL/pgSQL 对函数参数进行神奇的转换，将它们变成变量替换。

第二个是变量替换的字段可以引用：

函数的参数可以是复合类型（完整的表行）。在这种情况下，相应的标识符

$n

将是一个行变量，并且可以从中选择字段，例如

$1.user_id

。 ^{3，(9.3) 3a（当前）}

这段摘录让我很困惑，因为它引用了函数参数，但知道函数参数在底层是作为变量替换实现的，似乎我应该能够在

EXECUTE

中使用相同的语法。

这两个事实解锁了解决方案：在 USING 子句中使用 ROW 变量，并在动态 SQL 中取消引用其字段。结果（SQL Fiddle）：

CREATE OR REPLACE FUNCTION upsert(v_target ANYELEMENT)
  RETURNS SETOF ANYELEMENT AS
$$
DECLARE
  v_target_name TEXT;
  v_attr_name NAME;
  v_selectors TEXT[];
  v_colname TEXT;
  v_setters TEXT[];
  v_update_stmt TEXT;
  v_insert_stmt TEXT;
  v_temp RECORD;
BEGIN
  v_target_name := format_type(pg_typeof(v_target), NULL);

  FOR v_attr_name IN SELECT a.attname
                     FROM pg_index i
                     JOIN pg_attribute a ON a.attrelid = i.indrelid 
                                        AND a.attnum = ANY(i.indkey)
                    WHERE i.indrelid = v_target_name::regclass
                      AND i.indisprimary
  LOOP
    v_selectors := array_append(v_selectors, format('t.%1$I = $1.%1$I', v_attr_name));
  END LOOP;

  FOR v_colname IN SELECT json_object_keys(row_to_json(v_target))
  LOOP
    v_setters := array_append(v_setters, format('%1$I = $1.%1$I', v_colname));
  END LOOP;

  v_update_stmt := format(
      'UPDATE %I t SET %s WHERE %s RETURNING t.*',
      v_target_name,
      array_to_string(v_setters, ','),
      array_to_string(v_selectors, ' AND ')
  );

  v_insert_stmt = format('INSERT INTO %I SELECT $1.*', v_target_name);
  
  LOOP
    EXECUTE v_update_stmt INTO v_temp USING v_target;
    IF v_temp IS NOT NULL THEN
      EXIT;
    END IF;

    BEGIN
      EXECUTE v_insert_stmt USING v_target;
      EXIT;
    EXCEPTION when UNIQUE_VIOLATION THEN
      -- do nothing
    END;
  END LOOP;
  RETURN QUERY SELECT v_target.*;
END;
$$
LANGUAGE plpgsql;

对于可写 CTE 爱好者，这可以轻松转换为 CTE 形式：

v_cte_stmt = format(
    'WITH up as (%s) %s WHERE NOT EXISTS (SELECT 1 from up t WHERE %s)',
    v_update_stmt,
    v_insert_stmt,
    array_to_string(v_selectors, ' AND '));

LOOP
  BEGIN
    EXECUTE v_cte_stmt USING v_target;
    EXIT;
  EXCEPTION when UNIQUE_VIOLATION THEN
    -- do nothing
  END;
END LOOP;
RETURN QUERY SELECT v_target.*;

NB：我对此解决方案进行了零性能测试，并且我依靠其他人的分析来确保其正确性。目前，它在我的开发环境中的 PostgreSQL 9.3 上似乎可以正确运行。 YMMV.