Question

我试图为可以用于任何表的表upsert编写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 Fiddle

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);

错误：列＆＃34;目标＆＃34;不存在：SELECT * FROM upsert（ROW（1，＆＃39; {}＆＃39;）:: doodad）

我尝试更改upsert语句以使用占位符，但我无法弄清楚如何使用记录调用它：

EXECUTE update_stmt USING target;

错误：没有参数$ 2：SELECT * FROM upsert（ROW（1，＆＃39; {}＆＃39;）:: doodad）

EXECUTE update_stmt USING target.*;

错误：查询＆＃34; SELECT目标。*＆＃34;返回2列：SELECT * FROM upsert（ROW（1，＆＃39; {}＆＃39;）:: doodad）

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

Answer 1

简短回答：你不能。

在给予EXECUTE或其变体之一的命令字符串中不会发生变量替换。如果需要在这样的命令中插入变量值，请将其作为构造字符串值的一部分，或使用USING，如第40.5.4节所示。 ¹

更长的答案：

PL / pgSQL函数中的SQL语句和表达式可以引用函数的变量和参数。在幕后，PL / pgSQL将查询参数替换为此类引用。 ²

这是解决这个难题的第一个重要部分：PL / pgSQL对函数参数进行魔术转换，将它们转换为可变替换。

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

函数的参数可以是复合类型（完整的表行）。在这种情况下，相应的标识符$n将是行变量，并且可以从中选择字段，例如$1.user_id。 ³

这段摘录让我很困惑，因为它引用了函数参数，但知道函数参数是作为变量替换实现的，我似乎应该能够在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。

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

1 个答案: