postgres stored procedure pl pgSQL - ghdrako/doc_snipets GitHub Wiki

CREATE EXTENSION plpgsql;
\dx
select * from pg_extension where extname='plpgsql';

create or replace function f1(istr  varchar)
 returns text as $func$ 
 select 'hello! '::varchar || istr;
 $func$ language sql;

SELECT * FROM f1('ala');

create or replace function f_multiply_by_5(inout p_inout int) 
as $$
begin
 select p_inout * 5
 into p_inout;
end;
$$ language plpgsql;

select f_multiply_by_5(3);

CREATE FUNCTION f2(istr varchar)
  RETURNS text AS
$func$
BEGIN
   RETURN 'hello! ';  -- defaults to type text anyway
END
$func$ LANGUAGE plpgsql;

create or replace function f_multiply_together(variadic p_nums int[])
 returns int as $$
declare
 v_tot int = 1;
 v_ind int;
begin
 foreach v_ind in array p_nums loop
 v_tot = v_tot * v_ind;
 end loop;
 return v_tot;
end;
$$ language plpgsql;

select f_multiply_together(3,5,2);
select f_multiply_together(12,4,9,8,1,333,1,87,5,2);

CREATE OR REPLACE FUNCTION investment_calculator(
    IN v_amount numeric, IN v_interest numeric,
    IN v_years int)
RETURNS numeric AS
$$
  DECLARE
    v_sum   ALIAS FOR $1;
    v_result  numeric := 0;
  BEGIN
    v_result := v_amount
     * pow(1 + v_interest, v_years);
    RETURN v_result;
  END;
$$ LANGUAGE 'plpgsql';
SELECT investment_calculator(1000, 0.1, 2);

CREATE OR REPLACE FUNCTION <function_name> 
RETURNS TABLE (col1 type, col2...)
 AS $$ BEGIN
  RETURN QUERY <your select query>;
END;
$$ LANGUAGE plpgsql;

$$ CREATE OR REPLACE FUNCTION get_users_return_TABLE() 
RETURNS TABLE (id INTEGER, username VARCHAR)
 AS $$ BEGIN
  RETURN QUERY SELECT user_id, name FROM users;
END;
$$ LANGUAGE plpgsql;
SELECT * FROM get_users_return_TABLE();

DO $o$ 
BEGIN  
   RAISE NOTICE $i$ 
      Hello   
      World 
   $i$;
END;
$o$;

DO
$$
BEGIN
  BEGIN
    RAISE NOTICE 'Hello World';
  END;
END;
$$;

DO
$o$
BEGIN
  DO
  $i$
  BEGIN
    RAISE NOTICE 'Hello World';
  END;
  $i$;
END;
$o$;

DO $inline$
BEGIN
  PERFORM 1/0;
  RAISE NOTICE 'Hello World!';
EXCEPTION
  WHEN OTHERS THEN
  DO $$
  BEGIN
    RAISE NOTICE 'Got error';
  END;
  $$;
END;
$inline$;

<<label>>
DECLARE
-- declare variables here
BEGIN
-- Named block's code here
END;

PERFORM block_name;

CREATE OR REPLACE FUNCTION example_nested_loops()
RETURNS VOID AS $$
BEGIN
    <<outer_loop>> -- Label for the outer loop
    FOR i IN 1..5 LOOP
        <<inner_loop>> -- Label for the inner loop
        FOR j IN 1..5 LOOP
            IF i * j > 10 THEN
                -- Exit both loops when a condition is met
                EXIT outer_loop;
            END IF;
            -- Your inner loop logic here
        END LOOP inner_loop;
        -- Your outer loop logic here
    END LOOP outer_loop;
END;
$$ LANGUAGE plpgsql;

$$
<<parent>>
DECLARE
v_var1 INT := 1;
BEGIN
  DECLARE
    v_var1 INT := 10;
  BEGIN
    RAISE NOTICE 'Parent v_var1 %', parent.v_var1;
    RAISE NOTICE 'Local v_var1 %', v_var1;
  END;
END;
$$;

-- Escaping single quote inside string
select 'I''m also a string constant';
select E'I\'m also a string constant';  -- in old version postgres

$tag$<string_constant>$tag$

select $$I'm a string constant that contains a backslash \$$;
SELECT $message$I'm a string constant that contains a backslash \$message$;

do 
$$
declare
   film_count integer;
begin 
   select count(*) into film_count
   from film;
   raise notice 'The number of films: %', film_count;
end;
$$

create function find_film_by_id(
   id int
) returns film 
language sql
as 
$$
  select * from film 
  where film_id = id;  
$$; 

create procedure proc_name(param_list)
language lang_name
as $$
  -- stored procedure body
$$

CREATE FUNCTION repeat(times integer, s text)
    RETURNS text
    AS $$
DECLARE
    result text;
BEGIN
    result := '';
    FOR i IN 1..times LOOP
        result := result || s;
    END LOOP;
    RETURN result;
END;
$$
LANGUAGE plpgsql
IMMUTABLE;

-- psql> SELECT repeat(10, '*');
--    repeat
-- ------------
--  **********
-- (1 row)

CREATE PROCEDURE check_commit(v integer)
LANGUAGE plpgsql AS $$
BEGIN
    IF v % 2 = 0 THEN
        COMMIT;
    ELSE
        ROLLBACK;
    END IF;
END $$;

-- call it
CALL check_commit(10);

CREATE PROCEDURE annual_pay_rise (percent numeric)
LANGUAGE plpgsql AS $$
DECLARE
  c CURSOR FOR
  SELECT * FROM employee
   WHERE job_code = 'A2';
BEGIN
  FOR r IN c LOOP
    UPDATE employee
       SET salary = salary * (1 + (percent/100.0))
     WHERE empid = r.empid;
    IF mod (r.empid, 100) = 0 THEN
      COMMIT;
    END IF;
  END LOOP;
END;
$$;

CALL annual_pay_rise(2);

CREATE TABLE job_status
(id bigserial not null primary key,status text not null,restartdata bigint);
CREATE OR REPLACE FUNCTION job_start_new ()
RETURNS bigint
LANGUAGE plpgsql
AS $$
DECLARE
  p_id BIGINT;
BEGIN
  INSERT INTO job_status (status, restartdata)
     VALUES ('START', 0)
   RETURNING id INTO p_id;
  RETURN p_id;  
END; $$;
CREATE OR REPLACE FUNCTION job_get_status (jobid bigint)
RETURNS bigint
LANGUAGE plpgsql
AS $$
DECLARE
rdata BIGINT;
BEGIN
  SELECT restartdata INTO rdata
    FROM job_status
    WHERE status != 'COMPLETE' AND id = jobid;
  IF NOT FOUND THEN
    RAISE EXCEPTION 'job id does not exist';
  END IF;
  RETURN rdata;
END; $$;
CREATE OR REPLACE PROCEDURE
job_update (jobid bigint, rdata bigint)
LANGUAGE plpgsql
AS $$
BEGIN
  UPDATE job_status
    SET status = 'IN PROGRESS'
       ,restartdata = rdata
    WHERE id = jobid;
END; $$;
CREATE OR REPLACE PROCEDURE job_complete (jobid bigint)
LANGUAGE plpgsql
AS $$
BEGIN
  UPDATE job_status SET status = 'COMPLETE'
    WHERE id = jobid;
END; $$;

CREATE OR REPLACE PROCEDURE annual_pay_rise (job bigint)
LANGUAGE plpgsql AS $$
DECLARE
        job_empid bigint;
        c NO SCROLL CURSOR FOR
                SELECT * FROM employee
                WHERE job_code='A2'
                AND empid > job_empid
                ORDER BY empid;
BEGIN
        SELECT job_get_status(job) INTO job_empid;
        FOR r IN c LOOP
                UPDATE employee
                SET salary = salary * 1.02
                WHERE empid = r.empid;
                IF mod (r.empid, 100) = 0 THEN
                        CALL job_update(job, r.empid);
                        COMMIT;
                END IF;
        END LOOP;
        CALL job_complete(job);
END; $$;

CREATE FUNCTION trigger_function() 
   RETURNS TRIGGER 
   LANGUAGE PLPGSQL
AS $$
BEGIN
   -- trigger logic
END;
$$

CREATE TRIGGER trigger_name 
   {BEFORE | AFTER} { event }
   ON table_name
   [FOR [EACH] { ROW | STATEMENT }]
       EXECUTE PROCEDURE trigger_function

CREATE OR REPLACE FUNCTION log_last_name_changes()
  RETURNS TRIGGER 
  LANGUAGE PLPGSQL
  AS
$$
BEGIN
	IF NEW.last_name <> OLD.last_name THEN
		 INSERT INTO employee_audits(employee_id,last_name,changed_on)
		 VALUES(OLD.id,OLD.last_name,now());
	END IF;

	RETURN NEW;
END;
$$

CREATE TRIGGER last_name_changes
  BEFORE UPDATE
  ON employees
  FOR EACH ROW
  EXECUTE PROCEDURE log_last_name_changes();

ALTER TRIGGER trigger_name
ON table_name 
RENAME TO new_trigger_name;

\dS <table_name> -- view all triggers associated with a table

ALTER TABLE table_name
DISABLE TRIGGER trigger_name | ALL

ALTER TABLE table_name
ENABLE TRIGGER trigger_name | ALL

testdb=> DO $code$
 DECLARE
   counter int := 0;
 BEGIN
   LOOP
      counter := counter + 1;
      RAISE INFO 'This is the % time I say HELLO!', counter;
      EXIT WHEN counter > 3;
   END LOOP;

   RAISE INFO 'Good bye';
 END $code$;

INFO:  This is the 1 time I say HELLO!
INFO:  This is the 2 time I say...

DO $$ BEGIN PERFORM pg_sleep(10); END $$;
SELECT pg_sleep(10);
SELECT pg_sleep_for('10 seconds');
SELECT pg_sleep_until('today 21:45');
SELECT pg_sleep_until('tomorrow 03:00');

\x
SELECT 
  clock_timestamp(),
  pg_sleep(1),
  clock_timestamp(),
  pg_sleep(1),
  clock_timestamp();

SELECT 
  clock_timestamp(),
  pg_sleep(.5),
  clock_timestamp(),
  pg_sleep(.5),
  clock_timestamp();

EXECUTE statement_name [ INTO target ] [ USING expression [, ...] ];

CREATE TABLE test_dynamic_sql (id int, name varchar);
INSERT INTO test_dynamic_sql VALUES(1, 'test1');
 – Create a function that uses dynamic SQL:
CREATE OR REPLACE FUNCTION test_func_dynamic_sql(input_table_ name text) RETURNS TABLE(id integer, name text) AS $$ BEGIN  EXECUTE 'SELECT id, name FROM ' || input_table_name INTO id, name;
 RETURN NEXT;
END;
$$ LANGUAGE plpgsql;

SELECT * FROM test_func_dynamic_sql('test_dynamic_sql');
 id | name 
----+------- 
1 | test1 
(1 row)

CREATE OR REPLACE FUNCTION create_index(table_name text, column_name text, index_name text) 
RETURNS void 
AS 
$$ 
BEGIN  
  EXECUTE 'CREATE INDEX ' || index_name || ' ON ' || table_name || '(' || column_name || ')';
END;
$$ LANGUAGE plpgsql;

SELECT create_index('sample_table', 'column1', 'sample_column1_index'); 

CREATE OR REPLACE FUNCTION select_columns(table_name text, column_ names text[]) 
RETURNS record 
AS 
$$ 
DECLARE
  rec record;
BEGIN
  EXECUTE 'SELECT ' || array_to_string(column_names, ', ') || ' FROM ' || table_name INTO rec;
 RETURN rec;
END;
$$ LANGUAGE plpgsql;

SELECT * FROM select_columns('employee_data', ARRAY['first_name', 'salary']) as foo(fname text, sal numeric);

EXECUTE 'SELECT * FROM employees WHERE first_name = ' || quote_ literal(input_name);

CREATE FUNCTION my_func(my_age INT, my_id INT) RETURNS VOID
AS $$
BEGIN
  EXECUTE 'UPDATE person SET age = $1 WHERE id = $2' USING my_age, my_id;
END;                                              
$$ LANGUAGE plpgsql

PREPARE dynamic_query(text) AS  SELECT * FROM employees WHERE last_name = $1;
EXECUTE dynamic_query(input_last_name);

PREPARE rental_insert (INTEGER, INTEGER, TIMESTAMP, INTEGER) AS
    INSERT INTO rental (rental_id, inventory_id, rental_date, customer_id)
    VALUES ($1, $2, $3, $4);

EXECUTE rental_insert(10001, 2019, '2023-06-01 09:00:00', 153);

EXECUTE 'SELECT count(*) FROM mytable WHERE inserted_by = $1 AND inserted <= $2'
   INTO c
   USING checked_user, checked_date;

EXECUTE 'SELECT count(*) FROM '
    || quote_ident(tabname)
    || ' WHERE inserted_by = $1 AND inserted <= $2'
   INTO c
   USING checked_user, checked_date;

EXECUTE format('SELECT count(*) FROM %I '
   'WHERE inserted_by = $1 AND inserted <= $2', tabname)
   INTO c
   USING checked_user, checked_date;

postgres=# DO 
 $$ 
DECLARE v_rec RECORD;
BEGIN 
  FOR v_rec IN (SELECT * FROM many_rows_table) 
  LOOP 
   ...
  END LOOP;
END;
$$;

DO 
$$ 
DECLARE  
  v_cur CURSOR FOR SELECT * FROM many_rows_table;
  v_rec many_rows_table%ROWTYPE;
BEGIN  
  OPEN v_cur;
  FETCH v_cur INTO v_rec;
  IF FOUND THEN
    RAISE NOTICE 'Row found.';
  ELSE
    RAISE NOTICE 'No rows found.';
  END IF;
  CLOSE v_cur;
END;
$$;

DO 
$$ 
DECLARE  
  v_cur CURSOR FOR SELECT * FROM many_rows_table;
  v_rec many_rows_table%ROWTYPE;
  num_rows int;
BEGIN   
  OPEN v_cur;
  MOVE FORWARD ALL FROM v_cur;
  GET DIAGNOSTICS num_rows = ROW_COUNT;
  RAISE NOTICE 'Number of rows fetched: %', num_rows;
  CLOSE v_cur;
END;
$$;

postgres=# \d pg_cursors
SELECT name, creation_time FROM pg_cursors; 

postgres# BEGIN WORK;
DO 
$$ 
DECLARE 
  v_cur SCROLL CURSOR FOR SELECT * FROM scroll_test;
BEGIN 
  OPEN v_cur;
END;
$$;
postgres# FETCH NEXT FROM v_cur;
postgres# FETCH NEXT FROM v_cur;
postgres# MOVE BACKWARD 1 IN v_cur;
postgres# MOVE BACKWARD 1 IN v_cur;
postgres# FETCH NEXT FROM v_cur;

postgres=# BEGIN WORK;
postgres=*# DO 
$$ 
DECLARE 
  v_cur NO SCROLL CURSOR FOR SELECT * FROM scroll_test FOR UPDATE;
BEGIN 
  OPEN v_cur;
END;
$$;
postgres=# FETCH NEXT FROM v_cur;
postgres=# DELETE FROM scroll_test WHERE CURRENT OF v_cur;
postgres=# FETCH NEXT FROM v_cur;
postgres=# END

postgres=# DO 
$$ 
BEGIN
EXECUTE 'DECLARE cur CURSOR WITH HOLD FOR select * from scroll_test;';
END;
$$;
 postgres=# FETCH NEXT FROM cur; 

postgres=# CREATE OR REPLACE FUNCTION test_refcursor(rf REFCURSOR) 
RETURNS VOID 
AS 
$$ 
DECLARE v_rec RECORD;
BEGIN 
  LOOP 
    FETCH rf INTO v_rec;
    RAISE NOTICE 'Record %', v_rec;
    -- print only one record and exit the loop EXIT WHEN FOUND;
  END LOOP;
END;
$$ LANGUAGE PLPGSQL;


postgres=# DO 
$$  
DECLARE 
  v_cur REFCURSOR;
BEGIN
  OPEN v_cur FOR SELECT * FROM scroll_test;
  PERFORM test_refcursor(v_cur);
END;
$$;

-- A function that builds a part of dynamic SQL - return string
CREATE OR REPLACE FUNCTION age_category_dyn (p_age text)
RETURNS text language plpgsql AS
$body$
BEGIN
  RETURN ($$CASE
    WHEN $$||p_age ||$$ <= 2 THEN 'Infant'
    WHEN $$||p_age ||$$<= 12 THEN 'Child'
    WHEN $$||p_age ||$$< 65 THEN 'Adult'
    ELSE 'Senior'
  END$$);
END; $body$;


CREATE TYPE passenger_age_cat_record AS (
  passenger_id int,
  age_category text
);

CREATE OR REPLACE FUNCTION passenger_age_category_select (p_limit int)
RETURNS setof passenger_age_cat_record
AS
$body$
BEGIN
  RETURN QUERY
  EXECUTE $$SELECT
             passenger_id,
             $$||age_category_dyn('age')||$$ AS age_category
           FROM passenger LIMIT $$ ||p_limit::text
  ;
END;
$body$ LANGUAGE plpgsql;

--Now, we can execute the following statement:
SELECT * FROM passenger_age_category_select (5000000)
This will take about 11 seconds to execute, which is more than a

-- A function that builds dynamic SQL to search by different criteria
CREATE OR REPLACE FUNCTION select_booking_dyn (p_email text,
p_dep_airport text,
p_arr_airport text,
p_dep_date date,
p_flight_id int)
returns setof booking_record_basic
as
$func$
DECLARE
v_sql text:='SELECT DISTINCT b.booking_id, b.booking_ref, booking_name,
account_id, email
FROM booking b ';
v_where_booking text;
v_where_booking_leg text;
v_where_flight text;
BEGIN
IF p_email IS NOT NULL then v_where_booking :=$$ lower(email) like $$
||quote_literal(p_email||'%'); END IF;
IF p_flight_id IS NOT NULL then v_where_booking_leg:= $$ flight_id=$$||p_
flight_id::text;
END IF;
IF p_dep_airport IS NOT NULL
THEN v_where_flight:=concat_ws($$ AND $$, v_where_flight, $$departure_
airport=$$||
quote_literal(p_dep_airport));
END IF;
IF p_arr_airport IS NOT NULL
THEN v_where_flight:=concat_ws($$ AND $$,v_where_flight,
$$arrival_airport=$$||quote_literal(p_arr_airport));
END IF;
IF p_dep_date IS NOT NULL
THEN v_where_flight:=concat_ws($$ AND $$,v_where_flight,
$$scheduled_departure BETWEEN $$||
quote_literal(p_dep_date)||$$::date AND $$||quote_literal(p_dep_
date)||$$::date+1$$);
END IF;
IF v_where_flight IS NOT NULL OR v_where_booking_leg IS NOT NULL
THEN v_sql:=v_sql||$$ JOIN booking_leg bl USING (booking_id) $$;
END IF;
IF v_where_flight IS NOT NULL THEN
v_sql:=v_sql ||$$ JOIN flight f USING (flight_id) $$;
END IF;
v_sql:=v_sql ||$$ WHERE $$||
concat_ws($$ AND $$,v_where_booking, v_where_booking_leg, v_where_flight);
--raise notice 'sql:%', v_sql;
return query EXECUTE (v_sql);
END;
$func$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION register(login varchar(50), email varchar(50), password varchar(50), ip inet)
returns TABLE (
  new_id bigint,
  message varchar(255),
  email varchar(255),
  email_validation_token varchar(36)
)
AS
$$
DECLARE
  new_id bigint;
  message varchar(255);
  hashedpw varchar(255);
  validation_token varchar(36);
BEGIN

  --hash the password using pgcrypto
  SELECT crypt(password, gen_salt('bf', 10)) into hashedpw;

  --create a random string for the
  select substring(md5(random()::text),0, 36) into validation_token;

  --create the member. Email has a unique constraint so this will
  --throw. You could wrap this in an IF if you like too
  insert into members(email, created_at, email_validation_token)
  VALUES(email, now(), validation_token) returning id into new_id;

  --set the return message
  select 'Successfully registered' into message;

  --add login bits to logins
  insert into logins(member_id, provider, provider_key, provider_token)
  values(new_id, 'local',email,hashedpw);

  --add auth token to logins
  insert into logins(member_id, provider, provider_key, provider_token)
  values(new_id, 'token',null,validation_token);

  -- add them to the members role which is 99
  insert into members_roles(member_id, role_id)
  VALUES(new_id, 99);

  --add log entry
  insert into logs(subject,entry,member_id, ip, created_at)
  values('registration','Added to system, set role to User',new_id, ip, now());

  --return out what happened here with relevant data
  return query
  select new_id, message, new_email, success, validation_token;

END
$$ LANGUAGE plpgsql;