Открыть страницу поиска
Привет, Я DocuDroid!
Открыть страницу ИИ Помощника
Оценка ИИ поиска
Спасибо за оценку нашего ИИ поиска!
Мы будем признательны, если вы поделитесь своими впечатлениями, чтобы мы могли улучшить наш ИИ поиск для вас и других читателей.
GitHub

Пользовательские функции (UDF)

Андрей Аксенов

Greengage DB поддерживает создание пользовательских функций. Они позволяют реализовывать собственные вычисления, недоступные среди встроенных функций, и переиспользовать их в SQL-запросах. Дополнительную информацию вы можете найти в разделе Extending SQL документации PostgreSQL.

Обзор

Типы функций

Greengage DB поддерживает следующие типы функций:

  • SQL-функции — функции, написанные на SQL. См. примеры в разделе Примеры: функции на языке запросов SQL.

  • Функции на процедурных языках (Procedural Languages, PL) — функции, написанные на языках, отличных от SQL и C (например, PL/pgSQL или PL/Python). См. примеры в разделе Примеры: функции на процедурных языках.

  • Внутренние функции — функции, написанные на языке C, статически связанные с сервером базы данных. См. раздел Internal Functions в документации PostgreSQL для получения дополнительной информации.

  • Функции на языке C — функции на C, скомпилированные в динамически загружаемые разделяемые библиотеки, которые сервер загружает по требованию. См. раздел C-Language Functions в документации PostgreSQL для получения дополнительной информации.

Создание функции

Для создания новой функции используйте команду CREATE FUNCTION. Упрощенный синтаксис данной команды показан ниже:

CREATE [OR REPLACE] FUNCTION <name>
    ( [ [<argmode>] [<argname>] <argtype>
       [ { DEFAULT | = } <default_expr> ] [, ...] ] )
    RETURNS { <rettype>
       | TABLE ( <column_name> <column_type> [, ...] ) }
    AS $$
    <definition>
    $$
    LANGUAGE <langname>
    [ IMMUTABLE | STABLE | VOLATILE ]
    [ EXECUTE ON { ANY | MASTER | ALL SEGMENTS | INITPLAN } ];

Для определения функции используются следующие компоненты:

  • Имя функции

    <name> задает имя функции (при необходимости с указанием схемы). Оно должно быть уникальным в пределах схемы для заданного набора типов входных аргументов. Функции с одним именем и разными типами аргументов могут существовать вместе — это называется перегрузкой функций.

  • Аргументы функции

    Для определения аргументов функции используются следующие параметры и выражения:

    • <argtype> — указывает тип(ы) данных аргументов функции (при необходимости с указанием схемы). Тип аргумента может быть базовым типом, составным типом, доменом или ссылаться на тип столбца таблицы.

      Пример: add_numbers(INT, INT).

    • (Опционально) <argname> — позволяет указать имя аргумента.

      Пример: multiply_numbers(a INT, b INT).

    • (Опционально) <argmode> — указывает режим аргумента: IN, OUT, INOUT или VARIADIC.

      Пример: sum_numbers(VARIADIC nums INT[]).

    • (Опционально) DEFAULT <default_expr> — определяет значение по умолчанию, которое используется, если аргумент не указан.

      Пример: greet(msg TEXT DEFAULT 'world').

  • Тип возвращаемого значения функции

    <rettype> указывает возвращаемый тип данных (при необходимости с указанием схемы). Возвращаемый тип может быть базовым типом, составным типом, доменом или ссылаться на тип столбца таблицы.

  • Определение функции

    <definition> — строковая константа, определяющая функцию; ее значение зависит от используемого языка. Это может быть имя внутренней функции, путь к объектному файлу, SQL-команда или текст на процедурном языке.

    Пример: SELECT 'Hello, world!';.

  • Язык

    <langname> — это имя языка, на котором реализована функция. Может быть sql, c, internal или именем процедурного языка. См. раздел Типы функций.

  • Категория изменчивости

    Атрибуты изменчивости (IMMUTABLE, STABLE, VOLATILE) определяют зависимость результата функции от входных аргументов и состояния базы данных. В целом изменчивость определяет, когда будет выполняться функция. См. раздел Категории изменчивости функций.

  • Атрибуты EXECUTE ON

    Выражение EXECUTE ON определяет, где будет выполняться функция в кластере Greengage DB. См. раздел Атрибуты EXECUTE ON.

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

В этом примере с помощью CREATE FUNCTION создается SQL-функция greet(), которая принимает текстовый аргумент и возвращает приветственное сообщение:

CREATE FUNCTION greet(msg TEXT DEFAULT 'world')
    RETURNS TEXT
AS
$$
SELECT 'Hello, ' || msg || '!';
$$ LANGUAGE sql
    IMMUTABLE
    EXECUTE ON MASTER;

Вызовите greet() без аргументов, чтобы использовать значение по умолчанию:

SELECT greet();

Результат выглядит так:

     greet
---------------
 Hello, world!
(1 row)

Вы также можете указать аргумент:

SELECT greet('Alice');

Результат выглядит следующим образом:

     greet
---------------
 Hello, Alice!
(1 row)

Изменение функций

Вы можете изменить существующую функцию с помощью одной из следующих команд:

  • CREATE OR REPLACE FUNCTION — заменяет тело функции или ее атрибуты (например, язык или категорию изменчивости), сохраняя имя, типы аргументов и тип возвращаемого значения.

  • ALTER FUNCTION — изменяет свойства функции (например, владельца, имя или место исполнения), но не изменяет тело функции, а также ее аргументы или возвращаемый тип.

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

Удаление и создание функции заново также требует удаления и повторного создания всех зависимых объектов (например, правил, представлений или триггеров). Чтобы избежать этого, используйте CREATE OR REPLACE FUNCTION для обновления определения функции без нарушения зависимостей.

Следующий пример определяет функцию greet():

CREATE FUNCTION greet(msg TEXT DEFAULT 'world')
    RETURNS TEXT
AS
$$
SELECT 'Hello, ' || msg || '!';
$$ LANGUAGE sql
    IMMUTABLE
    EXECUTE ON MASTER;

Команда CREATE OR REPLACE FUNCTION изменяет тело функции greet():

CREATE OR REPLACE FUNCTION greet(msg TEXT DEFAULT 'world')
    RETURNS TEXT
AS
$$
SELECT 'Hello, ' || msg || '! Have a great day!';
$$ LANGUAGE sql
    IMMUTABLE
    EXECUTE ON MASTER;

Вы можете проверить обновленную функцию, вызвав ее:

SELECT greet('Alice');

Ожидаемый результат:

              greet
---------------------------------
 Hello, Alice! Have a great day!
(1 row)

Используйте ALTER FUNCTION, чтобы переименовать функцию, например, с greet() на greet_user():

ALTER FUNCTION greet(TEXT) RENAME TO greet_user;

Категории изменчивости функций

В Greengage DB для функций указывается атрибут изменчивости: IMMUTABLE, STABLE или VOLATILE. Эти атрибуты PostgreSQL определяют, когда функция вычисляется в процессе обработки запроса. Например, функция с атрибутом IMMUTABLE может быть вычислена на этапе планирования запроса, в то время как функция с атрибутом VOLATILE должна вычисляться для каждой строки. В таблице ниже приведены атрибуты изменчивости функций и их поддержка в Greengage DB.

Атрибут функции Поддержка в Greengage DB Описание Комментарии

IMMUTABLE

Да

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

 — 

STABLE

Да, в большинстве случаев

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

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

VOLATILE (по умолчанию)

Ограничена

Значения функции могут меняться в пределах одного сканирования таблицы. Примеры: random(), timeofday()

Любая функция с побочными эффектами является изменчивой, даже если ее результат предсказуем. Пример: setval()

В Greengage DB данные разделяются по сегментам, причем каждый сегмент работает как отдельный экземпляр PostgreSQL. Чтобы избежать несогласованных или непредсказуемых результатов, функции с атрибутом STABLE или VOLATILE не должны выполняться на сегментах, если они содержат SQL-команды или изменяют состояние базы данных. Например, такие функции как random(), timeofday() или setval() запрещены при работе с распределенными данными, так как их результаты могут отличаться на разных сегментах.

Вы можете безопасно использовать функции STABLE и VOLATILE в запросах, которые выполняются только на мастере. К ним относятся запросы без выражения FROM, например:

SELECT setval('myseq', 201);
SELECT foo();

Если в SQL-запросе в выражении FROM используется распределенная таблица, а функция возвращает набор строк, выполнение функции может происходить на сегментах:

SELECT * FROM foo();

Итог: функции с атрибутом IMMUTABLE можно свободно использовать на сегментах, а функции STABLE и VOLATILE следует ограничивать запросами, выполняемыми на мастере, чтобы обеспечить согласованные результаты.

Атрибуты EXECUTE ON

Greengage DB предоставляет атрибуты EXECUTE ON для управления тем, где выполняется функция. Эти атрибуты специфичны для Greengage DB и определяют, выполняется ли функция на мастере, на всех сегментах или на любом экземпляре кластера. Например, функция, определенная с помощью EXECUTE ON MASTER, выполняется только на мастере, а функция с параметром EXECUTE ON ALL SEGMENTS выполняется на всех основных сегментах (не на мастере). В таблице ниже приведены поддерживаемые атрибуты EXECUTE ON.

Атрибут функции Описание Комментарии

EXECUTE ON ANY (по умолчанию)

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

Greengage DB определяет, где будет выполнена функция

EXECUTE ON MASTER

Функция должна выполняться на мастере

Укажите этот атрибут, если пользовательская функция выполняет запросы для доступа к таблицам

EXECUTE ON ALL SEGMENTS

При каждом вызове функция должна выполняться на всех основных сегментах, но не на мастере

 — 

EXECUTE ON INITPLAN

Функция содержит SQL-команду, которая отправляет запросы на сегменты и требует специальной обработки на мастере Greengage DB, когда это возможно

 — 

Функции и реплицируемые таблицы

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

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

ПРИМЕЧАНИЕ

Скрытые системные столбцы (ctid, cmin, cmax, xmin, xmax и gp_segment_id) недоступны в пользовательских запросах к реплицируемым таблицам, поскольку для них не существует одного определенного значения.

Примеры: функции на языке запросов SQL

Обращение к аргументам: порядковый номер или имя

К аргументам SQL-функции можно обращаться в теле функции как по порядковым номерам ($1, $2 и так далее), так и по именам. В примере ниже используются порядковые номера:

CREATE FUNCTION add_numbers(INT, INT)
    RETURNS INT
AS
$$
SELECT $1 + $2;
$$ LANGUAGE sql
    IMMUTABLE;

Вызовите функцию с двумя аргументами:

SELECT add_numbers(3, 7);

Результат:

 add_numbers
-------------
          10
(1 row)

Вы можете обращаться к именованным аргументам напрямую в теле SQL-функции:

CREATE FUNCTION multiply_numbers(a INT, b INT)
    RETURNS INT
AS
$$
SELECT a * b;
$$ LANGUAGE sql
    IMMUTABLE;

Вызовите функцию с именованными аргументами:

SELECT multiply_numbers(a := 2, b := 3);

Результат:

 multiply_numbers
------------------
                6
(1 row)

Полиморфные аргументы

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

Этот пример демонстрирует функцию, которая вычитает одно значение из другого с использованием полиморфного типа:

CREATE FUNCTION subtract_numbers(a ANYELEMENT, b ANYELEMENT)
    RETURNS ANYELEMENT
AS
$$
SELECT a - b;
$$ LANGUAGE sql
    IMMUTABLE;

Вызовите функцию с целочисленными аргументами:

SELECT subtract_numbers(10, 4);

Результат выглядит следующим образом:

 subtract_numbers
------------------
                6
(1 row)

Вызовите функцию с числовыми аргументами:

SELECT subtract_numbers(10.5, 4.0);

Результат:

 subtract_numbers
------------------
              6.5
(1 row)

Переменное количество аргументов

SQL-функции в Greengage DB могут принимать переменное число аргументов с помощью ключевого слова VARIADIC.

В этом примере функция складывает произвольное количество целых чисел:

CREATE FUNCTION sum_numbers(VARIADIC nums INT[])
    RETURNS BIGINT
AS
$$
SELECT SUM(n)
FROM unnest(nums) AS n;
$$ LANGUAGE sql
    IMMUTABLE;

Вызовите функцию с четырьмя аргументами:

SELECT sum_numbers(1, 2, 3, 4);

Вызовите функцию с двумя аргументами:

SELECT sum_numbers(5, 10);

Выходные параметры

SQL-функции могут определять выходные параметры с помощью ключевого слова OUT. Это позволяет функции возвращать несколько значений как именованные столбцы без явного использования RETURNS TABLE.

Ниже приведена функция, которая вычисляет сумму и разность двух чисел:

CREATE FUNCTION calculate_stats(a NUMERIC, b NUMERIC, OUT sum_result NUMERIC, OUT diff_result NUMERIC)
AS
$$
SELECT a + b, a - b;
$$ LANGUAGE sql
    IMMUTABLE;

Вызовите функцию, чтобы вернуть все выходные столбцы:

SELECT *
FROM calculate_stats(10, 4);

Результат выглядит следующим образом:

 sum_result | diff_result
------------+-------------
         14 |           6
(1 row)

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

SELECT (calculate_stats(10, 4)).sum_result;

Результат:

 sum_result
------------
         14
(1 row)

Составные типы

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

Создайте составной тип для хранения результатов:

CREATE TYPE stats_result AS
(
    sum_result  NUMERIC,
    diff_result NUMERIC
);

Создайте функцию, которая возвращает составной тип:

CREATE FUNCTION calculate_stats(a NUMERIC, b NUMERIC)
    RETURNS stats_result
AS
$$
SELECT a + b, a - b;
$$ LANGUAGE sql
    IMMUTABLE;

Функции, возвращающие и использующие таблицы

Чтобы выполнить примеры из этого раздела, создайте таблицу sales:

CREATE TABLE sales
(
    id       INT,
    date     DATE,
    amount   DECIMAL(10, 2),
    category TEXT
)
    WITH (appendoptimized = true)
    DISTRIBUTED BY (id);

Добавьте данные:

INSERT INTO sales
VALUES (1, '2025-08-01', 100.00, 'Books'),
       (2, '2025-08-02', 200.00, 'Electronics'),
       (3, '2025-08-03', 150.00, 'Books'),
       (4, '2025-08-03', 300.00, 'Furniture');

  • SQL-функции могут принимать в качестве аргументов строки или табличные типы и возвращать вычисленные значения.

    Ниже представлена функция, вычисляющая сумму со скидкой для одной строки таблицы sales:

    CREATE FUNCTION get_discount_amount(s sales, pct DECIMAL)
    RETURNS DECIMAL(10, 2)
AS
$$
SELECT s.amount * (1 - pct);
$$ LANGUAGE sql
    IMMUTABLE
    EXECUTE ON MASTER;

    Чтобы передать в функцию всю строку, используйте звездочку (*) — sales.*:

    SELECT id,
       category,
       amount,
       get_discount_amount(sales.*, 0.1) AS discounted_amount
FROM sales;

    Результат следующий:

     id |  category   | amount | discounted_amount
----+-------------+--------+-------------------
  3 | Books       | 150.00 |           135.000
  4 | Furniture   | 300.00 |           270.000
  1 | Books       | 100.00 |            90.000
  2 | Electronics | 200.00 |           180.000
(4 rows)

  • SQL-функции в Greengage DB могут возвращать таблицу с помощью выражения RETURNS TABLE. Это позволяет явно задать выходные столбцы и возвращать из функции несколько строк, как в результате запроса.

    Эта функция возвращает все строки из sales с учетом скидки:

    CREATE FUNCTION sales_with_discounted_amount(pct DECIMAL)
    RETURNS TABLE
            (
                id       INT,
                date     DATE,
                amount   DECIMAL(10, 2)
            )
AS
$$
SELECT id,
       date,
       amount * (1 - pct)
FROM sales;
$$ LANGUAGE sql
    STABLE
    EXECUTE ON MASTER;

    Вызовите функцию с 15% скидкой:

    SELECT *
FROM sales_with_discounted_amount(0.15);

    Результат должен выглядеть так:

     id |    date    |  amount
----+------------+----------
  1 | 2025-08-01 |  85.0000
  2 | 2025-08-02 | 170.0000
  3 | 2025-08-03 | 127.5000
  4 | 2025-08-03 | 255.0000
(4 rows)

  • SQL-функции в Greengage DB могут возвращать несколько строк с помощью ключевого слова SETOF. Это позволяет возвращать строки определенного типа (таблица, составной тип или базовый тип) и позволяет функции работать как таблица, возвращая одну или несколько строк за вызов.

    В отличие от RETURNS TABLE, где выходные столбцы задаются явно в определении функции, RETURNS SETOF использует существующее определение типа для результата.

    Функция ниже возвращает все строки продаж с учетом скидки:

    CREATE FUNCTION sales_with_discounted_amount(pct DECIMAL)
    RETURNS SETOF sales
AS
$$
SELECT id,
       date,
       amount * (1 - pct),
       category
FROM sales;
$$ LANGUAGE sql
    STABLE
    EXECUTE ON MASTER;

    Вызовите функцию с 20% скидкой:

    SELECT *
FROM sales_with_discounted_amount(0.2);

    Результат должен выглядеть так:

     id |    date    | amount  |  category
----+------------+---------+-------------
  3 | 2025-08-03 | 120.000 | Books
  4 | 2025-08-03 | 240.000 | Furniture
  1 | 2025-08-01 |  80.000 | Books
  2 | 2025-08-02 | 160.000 | Electronics
(4 rows)

Выполнение функций на сегментах

Вы можете выполнять SQL-функции напрямую на сегментах. Ниже приведен пример функции, которая возвращает IP-адрес и порт каждого сегмента:

CREATE OR REPLACE FUNCTION get_segment_address()
    RETURNS SETOF TEXT
AS
$$
SELECT 'IP: ' || inet_server_addr()::text || ', port: ' || inet_server_port()::text;
$$ LANGUAGE sql
    VOLATILE
    EXECUTE ON ALL SEGMENTS;

Вызовите функцию, чтобы увидеть адреса всех сегментов:

SELECT *
FROM get_segment_address();

Вывод может выглядеть так:

       get_segment_address
----------------------------------
 IP: 192.168.1.30/32, port: 10000
 IP: 192.168.1.40/32, port: 10001
 IP: 192.168.1.30/32, port: 10001
 IP: 192.168.1.40/32, port: 10000
(4 rows)

Примеры: функции на процедурных языках

Greengage DB позволяет создавать пользовательские функции на языках, отличных от SQL или C. Эти языки называются процедурными языками (Procedural Languages, PL). Greengage DB поддерживает несколько процедурных языков, включая PL/pgSQL, PL/Python и PL/Java.

PL/pgSQL

Функции PL/pgSQL позволяют писать процедурную логику в Greengage DB, включая условные операторы, циклы и присваивание переменных. В примере ниже суммы продаж классифицируются как Low, Medium или High:

CREATE FUNCTION categorize_amount(amount DECIMAL)
    RETURNS TEXT
AS
$$
BEGIN
    IF amount <= 100 THEN
        RETURN 'Low';
    ELSIF amount <= 200 THEN
        RETURN 'Medium';
    ELSE
        RETURN 'High';
    END IF;
END;
$$ LANGUAGE plpgsql;

Вызовите функцию для таблицы sales:

SELECT id,
       amount,
       categorize_amount(amount) AS category
FROM sales
ORDER BY id;

Результат должен выглядеть так:

 id | amount | category
----+--------+----------
  1 | 100.00 | Low
  2 | 200.00 | Medium
  3 | 150.00 | Medium
  4 | 300.00 | High
(4 rows)

PL/Python

Функции PL/Python позволяют использовать синтаксис и библиотеки Python внутри СУБД.

Включите язык PL/Python:

CREATE EXTENSION plpythonu;

Создайте функцию, которая классифицирует суммы продаж с использованием Python:

CREATE FUNCTION categorize_amount(amount DECIMAL)
    RETURNS TEXT
AS
$$
    if amount <= 100:
        return 'Low'
    elif amount <= 200:
        return 'Medium'
    else:
        return 'High'
$$ LANGUAGE plpythonu
    IMMUTABLE;

Вызовите функцию для таблицы sales:

SELECT id,
       amount,
       categorize_amount(amount) AS category
FROM sales
ORDER BY id;

Ожидаемый результат:

 id | amount | category
----+--------+----------
  1 | 100.00 | Low
  2 | 200.00 | Medium
  3 | 150.00 | Medium
  4 | 300.00 | High
(4 rows)

Удалите расширение PL/Python, если оно больше не требуется:

DROP EXTENSION plpythonu;

Просмотр информации о функциях

Метакоманды psql

Вы можете использовать метакоманды psql для просмотра информации о функциях в Greengage DB.

Вывести список всех функций в текущей базе данных:

\df

Пример вывода:

                                         List of functions
 Schema |             Name             | Result data type |      Argument data types       |  Type
--------+------------------------------+------------------+--------------------------------+--------
 public | add_numbers                  | integer          | integer, integer               | normal
 public | calculate_stats              | stats_result     | a numeric, b numeric           | normal
 public | get_discount_amount          | numeric          | s sales, pct numeric           | normal
 public | get_segment_address          | SETOF text       |                                | normal
 public | greet_user                   | text             | msg text DEFAULT 'world'::text | normal
 public | multiply_numbers             | integer          | a integer, b integer           | normal
 public | sales_with_discounted_amount | SETOF sales      | pct numeric                    | normal
 public | subtract_numbers             | anyelement       | a anyelement, b anyelement     | normal
 public | sum_numbers                  | bigint           | VARIADIC nums integer[]        | normal
(9 rows)

Просмотреть информацию о конкретной функции:

\df add_numbers

Результат может выглядеть так:

                           List of functions
 Schema |    Name     | Result data type | Argument data types |  Type
--------+-------------+------------------+---------------------+--------
 public | add_numbers | integer          | integer, integer    | normal
(1 row)

Показать определение функции:

\sf add_numbers

Результат может выглядеть следующим образом:

CREATE OR REPLACE FUNCTION public.add_numbers(integer, integer)
 RETURNS integer
 LANGUAGE sql
 IMMUTABLE
AS $function$
SELECT $1 + $2;
$function$

Системные каталоги

Вы можете выполнить запрос к системному каталогу pg_proc, чтобы просмотреть свойства функций, такие как изменчивость и место выполнения, например:

SELECT nspname         AS schema,
       proname         AS function_name,
       provolatile     AS volatility,
       proexeclocation AS execute_on
FROM pg_proc
         JOIN pg_namespace ON pg_namespace.oid = pg_proc.pronamespace
WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'gp_toolkit')
ORDER BY schema, proname;

Результат может выглядеть так:

 schema |        function_name         | volatility | execute_on
--------+------------------------------+------------+------------
 public | add_numbers                  | i          | a
 public | calculate_stats              | i          | a
 public | get_discount_amount          | i          | m
 public | get_segment_address          | v          | s
 public | greet_user                   | i          | m
 public | multiply_numbers             | i          | a
 public | sales_with_discounted_amount | s          | m
 public | subtract_numbers             | i          | a
 public | sum_numbers                  | i          | a
(9 rows)

где:

  • Коды volatility: i = IMMUTABLE, s = STABLE, v = VOLATILE.

  • Коды execute_on: a = ANY, m = MASTER, s = ALL SEGMENTS.

Удаление функций

Чтобы удалить функцию, используйте команду DROP FUNCTION:

DROP FUNCTION add_numbers(INT, INT);

Чтобы удалить функцию вместе со связанными объектами, такими как операторы, добавьте параметр CASCADE.

Предыдущая
Представления и материализованные представления
Следующая
Модификация данных