PostgreSQL ਐਂਟੀਪੈਟਰਨ: SQL ਨੂੰ ਸੈੱਟ ਅਤੇ ਸਿਲੈਕਟ ਪਾਸ ਕਰਨਾ

ਸਮੇਂ-ਸਮੇਂ 'ਤੇ, ਡਿਵੈਲਪਰ ਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ ਬੇਨਤੀ ਲਈ ਪੈਰਾਮੀਟਰਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਜਾਂ ਇੱਕ ਪੂਰੀ ਚੋਣ ਵੀ ਪਾਸ ਕਰੋ "ਪ੍ਰਵੇਸ਼ ਦੁਆਰ 'ਤੇ". ਕਈ ਵਾਰ ਇਸ ਸਮੱਸਿਆ ਦੇ ਬਹੁਤ ਅਜੀਬ ਹੱਲ ਹੁੰਦੇ ਹਨ.

ਚਲੋ "ਉਲਟ ਤੋਂ" ਚੱਲੀਏ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਕਿਵੇਂ ਨਹੀਂ ਕਰਨਾ ਹੈ, ਕਿਉਂ, ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਬਿਹਤਰ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ।

ਬੇਨਤੀ ਦੇ ਭਾਗ ਵਿੱਚ ਮੁੱਲਾਂ ਦਾ ਸਿੱਧਾ "ਸੰਮਿਲਨ"

ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

query = "SELECT * FROM tbl WHERE id = " + value

... ਜਾਂ ਇਸ ਤਰ੍ਹਾਂ:

query = "SELECT * FROM tbl WHERE id = :param".format(param=value)

ਇਸ ਵਿਧੀ ਬਾਰੇ ਇਹ ਕਿਹਾ ਗਿਆ ਹੈ, ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਵੀ ਖਿੱਚਿਆ ਕਾਫ਼ੀ:

ਲਗਭਗ ਹਮੇਸ਼ਾ ਇਹ ਹੁੰਦਾ ਹੈ SQL ਇੰਜੈਕਸ਼ਨ ਲਈ ਸਿੱਧਾ ਮਾਰਗ ਅਤੇ ਵਪਾਰਕ ਤਰਕ 'ਤੇ ਇੱਕ ਵਾਧੂ ਲੋਡ, ਜੋ ਤੁਹਾਡੀ ਪੁੱਛਗਿੱਛ ਸਤਰ ਨੂੰ "ਗਲੂ" ਕਰਨ ਲਈ ਮਜਬੂਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਇਸ ਪਹੁੰਚ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਸਿਰਫ਼ ਲੋੜ ਪੈਣ 'ਤੇ ਹੀ ਜਾਇਜ਼ ਠਹਿਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਵਿਭਾਗੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ ਵਧੇਰੇ ਕੁਸ਼ਲ ਯੋਜਨਾ ਲਈ PostgreSQL ਸੰਸਕਰਣ 10 ਅਤੇ ਹੇਠਾਂ ਵਿੱਚ। ਇਹਨਾਂ ਸੰਸਕਰਣਾਂ ਵਿੱਚ, ਸਕੈਨ ਕੀਤੇ ਭਾਗਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਸਾਰਿਤ ਮਾਪਦੰਡਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖੇ ਬਿਨਾਂ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਸਿਰਫ ਬੇਨਤੀ ਦੇ ਅਧਾਰ ਤੇ.

$n ਆਰਗੂਮੈਂਟਸ

ਵਰਤੋਂ ਕਰੋ ਪਲੇਸਹੋਲਡਰ ਪੈਰਾਮੀਟਰ ਚੰਗੇ ਹਨ, ਇਹ ਤੁਹਾਨੂੰ ਵਰਤਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਤਿਆਰ ਬਿਆਨ, ਵਪਾਰਕ ਤਰਕ (ਪੁੱਛਗਿੱਛ ਸਟ੍ਰਿੰਗ ਸਿਰਫ ਇੱਕ ਵਾਰ ਬਣਾਈ ਅਤੇ ਪ੍ਰਸਾਰਿਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ) ਅਤੇ ਡੇਟਾਬੇਸ ਸਰਵਰ 'ਤੇ ਲੋਡ ਨੂੰ ਘਟਾਉਣਾ (ਬੇਨਤੀ ਦੀ ਹਰੇਕ ਸਥਿਤੀ ਲਈ ਮੁੜ-ਪਾਰਸਿੰਗ ਅਤੇ ਯੋਜਨਾ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ)।

ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਪਰਿਵਰਤਨਸ਼ੀਲ ਸੰਖਿਆ

ਸਮੱਸਿਆਵਾਂ ਸਾਡੀ ਉਡੀਕ ਕਰਨਗੀਆਂ ਜਦੋਂ ਅਸੀਂ ਪਹਿਲਾਂ ਤੋਂ ਅਣਜਾਣ ਦਲੀਲਾਂ ਨੂੰ ਪਾਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ:

... id IN ($1, $2, $3, ...) -- $1 : 2, $2 : 3, $3 : 5, ...

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਫਾਰਮ ਵਿੱਚ ਬੇਨਤੀ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਹਾਲਾਂਕਿ ਇਹ ਸਾਨੂੰ ਸੰਭਾਵੀ ਟੀਕਿਆਂ ਤੋਂ ਬਚਾਏਗਾ, ਫਿਰ ਵੀ ਇਹ ਬੇਨਤੀ ਨੂੰ ਗੂੰਦ / ਪਾਰਸ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਵੱਲ ਲੈ ਜਾਵੇਗਾ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਗਿਣਤੀ ਤੋਂ ਹਰੇਕ ਵਿਕਲਪ ਲਈ. ਹਰ ਵਾਰ ਇਸ ਨੂੰ ਕਰਨ ਨਾਲੋਂ ਪਹਿਲਾਂ ਹੀ ਬਿਹਤਰ ਹੈ, ਪਰ ਤੁਸੀਂ ਇਸ ਤੋਂ ਬਿਨਾਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।

ਇਹ ਸਿਰਫ ਇੱਕ ਪੈਰਾਮੀਟਰ ਰੱਖਣ ਲਈ ਕਾਫ਼ੀ ਹੈ ਇੱਕ ਐਰੇ ਦੀ ਲੜੀਬੱਧ ਪ੍ਰਤੀਨਿਧਤਾ:

... id = ANY($1::integer[]) -- $1 : '{2,3,5,8,13}'

ਫਰਕ ਸਿਰਫ ਇਹ ਹੈ ਕਿ ਆਰਗੂਮੈਂਟ ਨੂੰ ਲੋੜੀਂਦੀ ਐਰੇ ਕਿਸਮ ਵਿੱਚ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ। ਪਰ ਇਸ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਨਹੀਂ ਹੁੰਦੀਆਂ, ਕਿਉਂਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਕਿੱਥੇ ਸੰਬੋਧਨ ਕਰ ਰਹੇ ਹਾਂ।

ਨਮੂਨਾ ਟ੍ਰਾਂਸਫਰ (ਮੈਟ੍ਰਿਕਸ)

ਆਮ ਤੌਰ 'ਤੇ "ਇੱਕ ਬੇਨਤੀ ਵਿੱਚ" ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੰਮਿਲਨ ਲਈ ਡੇਟਾ ਸੈੱਟਾਂ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਇਹ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਦੇ ਵਿਕਲਪ ਹਨ:

INSERT INTO tbl(k, v) VALUES($1,$2),($3,$4),...

ਬੇਨਤੀ ਦੇ "ਮੁੜ-ਗਲੂਇੰਗ" ਦੇ ਨਾਲ ਉੱਪਰ ਦੱਸੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਸਾਨੂੰ ਵੀ ਲੈ ਸਕਦਾ ਹੈ ਸਮਝ ਤੋ ਬਾਹਰ ਅਤੇ ਸਰਵਰ ਕਰੈਸ਼. ਕਾਰਨ ਸਧਾਰਨ ਹੈ - PG ਆਰਗੂਮੈਂਟਾਂ ਲਈ ਵਾਧੂ ਮੈਮੋਰੀ ਰਿਜ਼ਰਵ ਕਰਦਾ ਹੈ, ਅਤੇ ਸੈੱਟ ਵਿੱਚ ਰਿਕਾਰਡਾਂ ਦੀ ਗਿਣਤੀ ਸਿਰਫ਼ ਵਪਾਰਕ ਤਰਕ ਐਪਲੀਕੇਸ਼ਨ ਵਿਸ਼ਲਿਸਟ ਦੁਆਰਾ ਸੀਮਿਤ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ ਕਲੀਨਿਕਲ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਦੇਖਣਾ ਜ਼ਰੂਰੀ ਸੀ $9000 ਤੋਂ ਵੱਧ "ਗਿਣਤੀ" ਆਰਗੂਮੈਂਟਸ - ਇਸ ਤਰ੍ਹਾਂ ਨਾ ਕਰੋ।

ਆਓ ਪਹਿਲਾਂ ਹੀ ਅਰਜ਼ੀ ਦੇ ਕੇ ਪੁੱਛਗਿੱਛ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖੀਏ "ਦੋ-ਪੱਧਰੀ" ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ:

INSERT INTO tbl
SELECT
  unnest[1]::text k
, unnest[2]::integer v
FROM (
  SELECT
    unnest($1::text[])::text[] -- $1 : '{"{a,1}","{b,2}","{c,3}","{d,4}"}'
) T;

ਹਾਂ, ਇੱਕ ਐਰੇ ਦੇ ਅੰਦਰ "ਗੁੰਝਲਦਾਰ" ਮੁੱਲਾਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਉਹਨਾਂ ਨੂੰ ਕੋਟਸ ਦੇ ਨਾਲ ਫਰੇਮ ਕੀਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ।
ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਇਸ ਤਰੀਕੇ ਨਾਲ ਤੁਸੀਂ ਖੇਤਰ ਦੀ ਮਨਮਰਜ਼ੀ ਨਾਲ ਚੋਣ ਨੂੰ "ਪਸਾਰ" ਕਰ ਸਕਦੇ ਹੋ।

ਅਨੈਸਟ, ਅਨੈਸਟ,…

ਸਮੇਂ-ਸਮੇਂ 'ਤੇ "ਐਰੇ ਦੀ ਐਰੇ" ਕਈ "ਕਾਲਮਾਂ ਦੀਆਂ ਐਰੇ" ਦੀ ਬਜਾਏ ਪਾਸ ਕਰਨ ਦੇ ਵਿਕਲਪ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ:

SELECT
  unnest($1::text[]) k
, unnest($2::integer[]) v;

ਇਸ ਵਿਧੀ ਨਾਲ, ਜੇ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਕਾਲਮਾਂ ਲਈ ਮੁੱਲਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਵੇਲੇ ਕੋਈ ਗਲਤੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ ਅਚਾਨਕ ਨਤੀਜੇ, ਜੋ ਕਿ ਸਰਵਰ ਸੰਸਕਰਣ 'ਤੇ ਵੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ:

-- $1 : '{a,b,c}', $2 : '{1,2}'
-- PostgreSQL 9.4
k | v
-----
a | 1
b | 2
c | 1
a | 2
b | 1
c | 2
-- PostgreSQL 11
k | v
-----
a | 1
b | 2
c |

JSON

ਸੰਸਕਰਣ 9.3 ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, PostgreSQL ਵਿੱਚ json ਕਿਸਮ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਪੂਰੇ ਫੰਕਸ਼ਨ ਹਨ। ਇਸਲਈ, ਜੇਕਰ ਤੁਹਾਡੇ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਉੱਥੇ ਹੀ ਫਾਰਮ ਬਣਾ ਸਕਦੇ ਹੋ SQL ਪੁੱਛਗਿੱਛ ਲਈ json ਆਬਜੈਕਟ:

SELECT
  key k
, value v
FROM
  json_each($1::json); -- '{"a":1,"b":2,"c":3,"d":4}'

ਪਿਛਲੇ ਸੰਸਕਰਣਾਂ ਲਈ, ਇਹੀ ਤਰੀਕਾ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਹਰੇਕ (ਹਸਟੋਰ), ਪਰ hstore ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ ਤੋਂ ਬਚਣ ਦੇ ਨਾਲ ਸਹੀ "ਫੋਲਡਿੰਗ" ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ।

json_populate_recordset

ਜੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣਦੇ ਹੋ ਕਿ "ਇਨਪੁਟ" json ਐਰੇ ਤੋਂ ਡੇਟਾ ਕੁਝ ਸਾਰਣੀ ਵਿੱਚ ਭਰਨ ਲਈ ਜਾਵੇਗਾ, ਤਾਂ ਤੁਸੀਂ json_populate_recordset ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ "dereferencing" ਖੇਤਰਾਂ ਅਤੇ ਕਾਸਟ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀਆਂ ਕਿਸਮਾਂ ਵਿੱਚ ਬਹੁਤ ਸਾਰਾ ਬਚਾ ਸਕਦੇ ਹੋ:

SELECT
  *
FROM
  json_populate_recordset(
    NULL::pg_class
  , $1::json -- $1 : '[{"relname":"pg_class","oid":1262},{"relname":"pg_namespace","oid":2615}]'
  );

json_to_recordset

ਅਤੇ ਇਹ ਫੰਕਸ਼ਨ ਟੇਬਲ ਫਾਰਮੈਟ 'ਤੇ ਨਿਰਭਰ ਕੀਤੇ ਬਿਨਾਂ, ਇੱਕ ਚੋਣ ਵਿੱਚ ਪਾਸ ਕੀਤੇ ਗਏ ਆਬਜੈਕਟਸ ਦੀ ਐਰੇ ਨੂੰ "ਵਿਸਤਾਰ" ਕਰੇਗਾ:

SELECT
  *
FROM
  json_to_recordset($1::json) T(k text, v integer);
-- $1 : '[{"k":"a","v":1},{"k":"b","v":2}]'
k | v
-----
a | 1
b | 2

ਅਸਥਾਈ ਟੇਬਲ

ਪਰ ਜੇ ਪ੍ਰਸਾਰਿਤ ਨਮੂਨੇ ਵਿੱਚ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਇੱਕ ਲੜੀਬੱਧ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਸੁੱਟਣਾ ਮੁਸ਼ਕਲ ਹੈ, ਅਤੇ ਕਈ ਵਾਰ ਅਸੰਭਵ ਹੈ, ਕਿਉਂਕਿ ਇਸ ਲਈ ਇੱਕ ਵਾਰ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਵੱਡੀ ਮੈਮੋਰੀ ਵੰਡ. ਉਦਾਹਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਲੰਬੇ, ਲੰਬੇ ਸਮੇਂ ਲਈ ਇੱਕ ਬਾਹਰੀ ਸਿਸਟਮ ਤੋਂ ਇਵੈਂਟ ਡੇਟਾ ਦੇ ਇੱਕ ਵੱਡੇ ਬੈਚ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਫਿਰ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਵਾਲੇ ਪਾਸੇ ਇੱਕ ਵਾਰ ਇਸਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੋਵੇਗਾ ਅਸਥਾਈ ਟੇਬਲ:

CREATE TEMPORARY TABLE tbl(k text, v integer);
...
INSERT INTO tbl(k, v) VALUES($1, $2); -- повторить много-много раз
...
-- тут делаем что-то полезное со всей этой таблицей целиком

ਤਰੀਕਾ ਵਧੀਆ ਹੈ ਵੱਡੀ ਮਾਤਰਾ ਦੇ ਅਕਸਰ ਪ੍ਰਸਾਰਣ ਲਈ ਡਾਟਾ।
ਇਸਦੇ ਡੇਟਾ ਦੀ ਬਣਤਰ ਦਾ ਵਰਣਨ ਕਰਨ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇੱਕ ਅਸਥਾਈ ਸਾਰਣੀ ਕੇਵਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਵਿੱਚ ਇੱਕ "ਨਿਯਮਿਤ" ਸਾਰਣੀ ਤੋਂ ਵੱਖਰੀ ਹੁੰਦੀ ਹੈ। pg_class ਸਿਸਟਮ ਟੇਬਲ ਵਿੱਚਅਤੇ ਅੰਦਰ pg_type, pg_depend, pg_attribute, pg_attrdef, ... - ਅਤੇ ਕੁਝ ਵੀ ਨਹੀਂ।

ਇਸ ਲਈ, ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਲਈ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਕਨੈਕਸ਼ਨਾਂ ਵਾਲੇ ਵੈਬ ਸਿਸਟਮਾਂ ਵਿੱਚ, ਅਜਿਹੀ ਸਾਰਣੀ ਹਰ ਵਾਰ ਨਵੇਂ ਸਿਸਟਮ ਰਿਕਾਰਡ ਤਿਆਰ ਕਰੇਗੀ, ਜੋ ਕਿ ਡਾਟਾਬੇਸ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਹੋਣ 'ਤੇ ਮਿਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਆਖਰਕਾਰ, TEMP TABLE ਦੀ ਬੇਕਾਬੂ ਵਰਤੋਂ pg_catalog ਵਿੱਚ ਟੇਬਲਾਂ ਦੀ "ਸੋਜ" ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਬਹੁਤ ਸਾਰੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਹੌਲੀ ਕਰਨਾ।
ਬੇਸ਼ੱਕ, ਇਸ ਨਾਲ ਮੁਕਾਬਲਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਆਵਰਤੀ ਪਾਸ ਵੈਕਿਊਮ ਫੁਲ ਸਿਸਟਮ ਕੈਟਾਲਾਗ ਟੇਬਲ ਦੇ ਅਨੁਸਾਰ.

ਸੈਸ਼ਨ ਵੇਰੀਏਬਲ

ਮੰਨ ਲਓ ਕਿ ਪਿਛਲੇ ਕੇਸ ਤੋਂ ਡੇਟਾ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਇੱਕ ਸਿੰਗਲ SQL ਪੁੱਛਗਿੱਛ ਲਈ ਕਾਫ਼ੀ ਗੁੰਝਲਦਾਰ ਹੈ, ਪਰ ਤੁਸੀਂ ਇਸਨੂੰ ਅਕਸਰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਭਾਵ, ਅਸੀਂ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆਤਮਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ DO ਬਲਾਕ, ਪਰ ਅਸਥਾਈ ਟੇਬਲਾਂ ਰਾਹੀਂ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਮਹਿੰਗਾ ਹੋਵੇਗਾ।

ਅਸੀਂ ਕਿਸੇ ਅਗਿਆਤ ਬਲਾਕ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ $n-ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਸੈਸ਼ਨ ਵੇਰੀਏਬਲ ਅਤੇ ਫੰਕਸ਼ਨ ਸਥਿਤੀ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰਨਗੇ। ਮੌਜੂਦਾ_ਸੈਟਿੰਗ.

ਸੰਸਕਰਣ 9.2 ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਪ੍ਰੀ-ਕਨਫਿਗਰ ਕਰਨਾ ਪੈਂਦਾ ਸੀ ਵਿਸ਼ੇਸ਼ ਨਾਮ ਸਥਾਨ custom_variable_classes "ਉਨ੍ਹਾਂ ਦੇ" ਸੈਸ਼ਨ ਵੇਰੀਏਬਲ ਲਈ। ਮੌਜੂਦਾ ਸੰਸਕਰਣਾਂ 'ਤੇ, ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ ਲਿਖ ਸਕਦੇ ਹੋ:

SET my.val = '{1,2,3}';
DO $$
DECLARE
  id integer;
BEGIN
  FOR id IN (SELECT unnest(current_setting('my.val')::integer[])) LOOP
    RAISE NOTICE 'id : %', id;
  END LOOP;
END;
$$ LANGUAGE plpgsql;
-- NOTICE:  id : 1
-- NOTICE:  id : 2
-- NOTICE:  id : 3

ਹੋਰ ਸਮਰਥਿਤ ਕਾਰਜਪ੍ਰਣਾਲੀ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਹੋਰ ਹੱਲ ਉਪਲਬਧ ਹਨ।

ਹੋਰ ਤਰੀਕੇ ਜਾਣਦੇ ਹੋ? ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਸਾਂਝਾ ਕਰੋ!

ਸਰੋਤ: www.habr.com