Как вы используете переменные скрипта в psql?

В MS SQL Server я создаю свои сценарии для использования настраиваемых переменных:

DECLARE @somevariable int  
SELECT @somevariable = -1

INSERT INTO foo VALUES ( @somevariable )

Затем я изменю значение @somevariableво время выполнения в зависимости от значения, которое мне нужно в конкретной ситуации. Поскольку он находится в верхней части сценария, его легко увидеть и запомнить.

Как мне сделать то же самое с клиентом PostgreSQL psql?

Переменные Postgres создаются с помощью команды \ set, например ...

\set myvariable value

... и затем может быть заменен, например, как ...

SELECT * FROM :myvariable.table1;

... или ...

SELECT * FROM table1 WHERE :myvariable IS NULL;

edit: Начиная с psql 9.1, переменные можно раскрывать в кавычках, как в:

\set myvariable value 

SELECT * FROM table1 WHERE column1 = :'myvariable';

В старых версиях клиента psql:

... Если вы хотите использовать переменную в качестве значения в условном строковом запросе, например ...

SELECT * FROM table1 WHERE column1 = ':myvariable';

... тогда вам нужно включить кавычки в саму переменную, так как приведенное выше не будет работать. Вместо этого определите свою переменную как таковую ...

\set myvariable 'value'

Однако, если вы, как и я, столкнетесь с ситуацией, когда захотите создать строку из существующей переменной, я обнаружил, что уловка будет в следующем ...

\set quoted_myvariable '\'' :myvariable '\''

Теперь у вас есть переменная в кавычках и без кавычек одной и той же строки! А можно сделать что-то вроде этого ....

INSERT INTO :myvariable.table1 SELECT * FROM table2 WHERE column1 = :quoted_myvariable;

И последнее слово о переменных PSQL:

1. Они не расширяются, если вы заключите их в одинарные кавычки в операторе SQL. Таким образом, это не работает:

   SELECT * FROM foo WHERE bar = ':myvariable'

2. Чтобы преобразовать в строковый литерал в операторе SQL, вы должны включить кавычки в набор переменных. Однако значение переменной уже должно быть заключено в кавычки, что означает, что вам нужен второй набор кавычек, а внутренний набор должен быть экранирован. Таким образом, вам необходимо:

   \set myvariable '\'somestring\''  
   SELECT * FROM foo WHERE bar = :myvariable

   РЕДАКТИРОВАТЬ : начиная с PostgreSQL 9.1, вы можете вместо этого написать:

   \set myvariable somestring
   SELECT * FROM foo WHERE bar = :'myvariable'

Вы можете попробовать использовать предложение WITH .

WITH vars AS (SELECT 42 AS answer, 3.14 AS appr_pi)
SELECT t.*, vars.answer, t.radius*vars.appr_pi
FROM table AS t, vars;

В частности psql, вы также можете передавать psqlпеременные из командной строки; вы можете передать их с помощью -v. Вот пример использования:

$ psql -v filepath=/path/to/my/directory/mydatafile.data regress
regress=> SELECT :'filepath';
               ?column?                
---------------------------------------
 /path/to/my/directory/mydatafile.data
(1 row)

Обратите внимание, что двоеточие не заключено в кавычки, тогда указывается само имя переменной. Странный синтаксис, я знаю. Это работает только в psql; это не будет работать (скажем) в PgAdmin-III.

Эта подстановка происходит во время обработки ввода в psql, поэтому вы не можете (скажем) определить функцию, которая использует, :'filepath'и ожидать, что значение :'filepath'будет изменяться от сеанса к сеансу. Он будет заменен один раз, когда функция определена, и после этого станет константой. Это полезно для написания сценариев, но не для использования во время выполнения.

FWIW, настоящая проблема заключалась в том, что я поставил точку с запятой в конце моей команды \ set:

\ установить пароль_владельца 'пароль';

Точка с запятой интерпретировалась как фактический символ в переменной:

\ echo: owner_password thepassword;

Итак, когда я попытался его использовать:

СОЗДАТЬ РОЛЬ myrole ВОЙТИ НЕШифрованный пароль: owner_password NOINHERIT CREATEDB CREATEROLE VALID ДО 'бесконечности';

... Получил вот что:

СОЗДАТЬ РОЛЬ myrole ВХОД НЕШифрованный ПАРОЛЬ thepassword; NOINHERIT CREATEDB CREATEROLE ДЕЙСТВИТЕЛЬНО ДО "бесконечности";

При этом не только не удалось установить кавычки вокруг литерала, но и разбить команду на 2 части (вторая из которых была недействительной, поскольку начиналась с «NOINHERIT»).

Мораль этой истории: «переменные» PostgreSQL - это на самом деле макросы, используемые при расширении текста, а не истинные значения. Я уверен, что это пригодится, но поначалу это сложно.

Вам необходимо использовать один из процедурных языков, например PL / pgSQL, а не язык процедур SQL. В PL / pgSQL вы можете использовать переменные прямо в операторах SQL. Для одинарных кавычек вы можете использовать функцию кавычки.

postgres (начиная с версии 9.0) разрешает анонимные блоки на любом из поддерживаемых языков сценариев на стороне сервера

DO '
DECLARE somevariable int = -1;
BEGIN
INSERT INTO foo VALUES ( somevariable );
END
' ;

http://www.postgresql.org/docs/current/static/sql-do.html

Поскольку все находится внутри строки, заменяемые внешние строковые переменные должны быть экранированы и дважды заключены в кавычки. Использование долларовых кавычек вместо этого не даст полной защиты от SQL-инъекций.

Другой подход - (ab) использовать механизм PostgreSQL GUC для создания переменных. См. Предыдущий ответ для получения подробностей и примеров.

Вы объявляете GUC в postgresql.conf, затем изменяете его значение во время выполнения с помощью SETкоманд и получаете его значение с помощьюcurrent_setting(...) .

Я не рекомендую это для общего использования, но это может быть полезно в узких случаях, таких как тот, который упоминается в связанном вопросе, когда плакат хотел предоставить способ предоставить имя пользователя на уровне приложения для триггеров и функций.

Я решил это с помощью временной таблицы.

CREATE TEMP TABLE temp_session_variables (
    "sessionSalt" TEXT
);
INSERT INTO temp_session_variables ("sessionSalt") VALUES (current_timestamp || RANDOM()::TEXT);

Таким образом, у меня была «переменная», которую я мог использовать для нескольких запросов, уникальную для сеанса. Мне нужно, чтобы он генерировал уникальные «имена пользователей», но при этом не имел коллизий при импорте пользователей с тем же именем пользователя.

Я нашел этот вопрос и ответы чрезвычайно полезными, но также сбивающими с толку. У меня было много проблем с тем, чтобы заставить работать цитируемые переменные, поэтому вот как у меня это работает:

\set deployment_user username    -- username
\set deployment_pass '\'string_password\''
ALTER USER :deployment_user WITH PASSWORD :deployment_pass;

Таким образом, вы можете определить переменную в одном операторе. Когда вы его используете, в переменную будут вставлены одинарные кавычки.

НОТА! Когда я помещал комментарий после цитируемой переменной, он был засосан как часть переменной, когда я пробовал некоторые методы в других ответах. Это действительно какое-то время меня облажало. С этим методом комментарии обрабатываются так, как и следовало ожидать.

Я очень скучаю по этой функции. Единственный способ добиться чего-то подобного - использовать функции.

Я использовал его двумя способами:

• функции perl, использующие переменную $ _SHARED
• сохраните свои переменные в таблице

Версия Perl:

   CREATE FUNCTION var(name text, val text) RETURNS void AS $$
        $_SHARED{$_[0]} = $_[1];
   $$ LANGUAGE plperl;
   CREATE FUNCTION var(name text) RETURNS text AS $$
        return $_SHARED{$_[0]};
   $$ LANGUAGE plperl;

Настольная версия:

CREATE TABLE var (
  sess bigint NOT NULL,
  key varchar NOT NULL,
  val varchar,
  CONSTRAINT var_pkey PRIMARY KEY (sess, key)
);
CREATE FUNCTION var(key varchar, val anyelement) RETURNS void AS $$
  DELETE FROM var WHERE sess = pg_backend_pid() AND key = $1;
  INSERT INTO var (sess, key, val) VALUES (sessid(), $1, $2::varchar);
$$ LANGUAGE 'sql';

CREATE FUNCTION var(varname varchar) RETURNS varchar AS $$
  SELECT val FROM var WHERE sess = pg_backend_pid() AND key = $1;
$$ LANGUAGE 'sql';

Ноты:

• plperlu быстрее Perl
• pg_backend_pid - не лучшая идентификация сеанса, рассмотрите возможность использования pid в сочетании с backend_start из pg_stat_activity
• эта версия таблицы также плохая, потому что вы должны время от времени очищать ее (и не удалять текущие рабочие переменные сеанса)

Переменные в psql отстой. Если вы хотите объявить целое число, вы должны ввести целое число, затем выполнить возврат каретки и завершить оператор точкой с запятой. Заметим:

Допустим, я хочу объявить целочисленную переменную my_varи вставить ее в таблицуtest :

Примерная таблица test:

thedatabase=# \d test;
                         Table "public.test"
 Column |  Type   |                     Modifiers                     
--------+---------+---------------------------------------------------
 id     | integer | not null default nextval('test_id_seq'::regclass)
Indexes:
    "test_pkey" PRIMARY KEY, btree (id)

Понятно, что в этой таблице пока ничего:

thedatabase=# select * from test;
 id 
----
(0 rows)

Объявляем переменную. Обратите внимание на точку с запятой на следующей строке!

thedatabase=# \set my_var 999
thedatabase=# ;

Теперь мы можем вставить. Мы должны использовать этот " :''" странный синтаксис:

thedatabase=# insert into test(id) values (:'my_var');
INSERT 0 1

Это сработало!

thedatabase=# select * from test;
 id  
-----
 999
(1 row)

Объяснение:

Итак ... что произойдет, если в следующей строке нет точки с запятой? Переменная? Посмотри:

Объявляем my_varбез новой строки.

thedatabase=# \set my_var 999;

Выберем my_var.

thedatabase=# select :'my_var';
 ?column? 
----------
 999;
(1 row)

Что это за хрень? Это не целое число , это строка 999; !

thedatabase=# select 999;
 ?column? 
----------
      999
(1 row)

Я опубликовал новое решение для этого в другом потоке .

Он использует таблицу для хранения переменных и может быть обновлен в любое время. Статическая неизменяемая функция-получатель создается динамически (другой функцией), запускается обновлением вашей таблицы. Вы получаете хорошее хранилище таблиц, а также невероятно высокую скорость неизменяемого геттера.