Для обработки строковых типов данных SQL, таких как varchar и text, существует два возможных способа объявления главных переменных.

Первый способ заключается в использовании char[], массив тип данных char, что является наиболее распространенным способом обработки символьных данных в языке C.

EXEC SQL BEGIN DECLARE SECTION;
    char str[50];
EXEC SQL END DECLARE SECTION;

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

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

VARCHAR var[180];

преобразуется в:

struct varchar_var { int len; char arr[180]; } var;

Элемент структуры arr содержит строку, включая завершающий нулевой байт. Таким образом, для хранения строки в VARCHAR главной переменной, ее необходимо объявить с указанием длины, включающей завершающий нулевой байт. Элемент len содержит длину строки, хранящейся в arr без завершающего нулевого байта. Если главная переменная используется в качестве входного параметра для запроса и значения strlen(arr) и len различаются, то используется меньшее из них.

VARCHAR может быть записано в верхнем или нижнем регистре, но не в смешанном.

тип данных char и VARCHAR главные переменные также могут содержать значения других типов SQL, которые будут храниться в их строковом представлении.

препроцессор ECPG включает в себя специальные типы, упрощающие взаимодействие с определенными специальными типами данных сервера PostgreSQL. В частности, реализована поддержка для тип numeric, тип данных decimal, date, timestamp, и тип данных interval типов. Эти типы данных нельзя эффективно сопоставить с примитивными типами главных переменных (такими как int, long long int, или char[]), поскольку они имеют сложную внутреннюю структуру. Приложения работают с данными типами, объявляя главные переменные специальных типов и обращаясь к ним при помощи функций библиотеки pgtypes. Библиотека pgtypes, подробно описанная в Раздел 4.3.6 содержит основные функции для работы с этими типами данных, благодаря чему не требуется отправлять запрос на сервер SQL, например, только для того, чтобы прибавить тип данных interval к метке времени.

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

#include 

EXEC SQL BEGIN DECLARE SECTION;
timestamp ts;
EXEC SQL END DECLARE SECTION;

EXEC SQL SELECT now()::timestamp INTO :ts;

printf("ts = %s\n", PGTYPEStimestamp_to_asc(ts));

ts = 2010-06-27 18:03:56.949343

#include 
#include 
#include 

int
main(void)
{
EXEC SQL BEGIN DECLARE SECTION;
    interval *in;
EXEC SQL END DECLARE SECTION;

    EXEC SQL CONNECT TO testdb;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;

    in = PGTYPESinterval_new();
    EXEC SQL SELECT '1 min'::interval INTO :in;
    printf("interval = %s\n", PGTYPESinterval_to_asc(in));
    PGTYPESinterval_free(in);

    EXEC SQL COMMIT;
    EXEC SQL DISCONNECT ALL;
    return 0;
}

#include 
#include 
#include 

EXEC SQL WHENEVER SQLERROR STOP;

int
main(void)
{
EXEC SQL BEGIN DECLARE SECTION;
    numeric *num;
    numeric *num2;
    decimal *dec;
EXEC SQL END DECLARE SECTION;

    EXEC SQL CONNECT TO testdb;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;

    num = PGTYPESnumeric_new();
    dec = PGTYPESdecimal_new();

    EXEC SQL SELECT 12.345::numeric(4,2), 23.456::decimal(4,2) INTO :num, :dec;

    printf("numeric = %s\n", PGTYPESnumeric_to_asc(num, 0));
    printf("numeric = %s\n", PGTYPESnumeric_to_asc(num, 1));
    printf("numeric = %s\n", PGTYPESnumeric_to_asc(num, 2));

    /* Преобразование типа данных decimal в тип numeric для отображения значения decimal. */
    num2 = PGTYPESnumeric_new();
    PGTYPESnumeric_from_decimal(dec, num2);

    printf("decimal = %s\n", PGTYPESnumeric_to_asc(num2, 0));
    printf("decimal = %s\n", PGTYPESnumeric_to_asc(num2, 1));
    printf("decimal = %s\n", PGTYPESnumeric_to_asc(num2, 2));

    PGTYPESnumeric_free(num2);
    PGTYPESdecimal_free(dec);
    PGTYPESnumeric_free(num);

    EXEC SQL COMMIT;
    EXEC SQL DISCONNECT ALL;
    return 0;
}

bytea var[180];

struct bytea_var { int len; char arr[180]; } var;

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

int
main(void)
{
EXEC SQL BEGIN DECLARE SECTION;
    int dbid[8];
    char dbname[8][16];
    int i;
EXEC SQL END DECLARE SECTION;

    memset(dbname, 0, sizeof(char)* 16 * 8);
    memset(dbid, 0, sizeof(int) * 8);

    EXEC SQL CONNECT TO testdb;
    EXEC SQL SELECT pg_catalog.set_config('search_path', '', false); EXEC SQL COMMIT;

    /* Retrieve multiple rows into arrays at once. */
    EXEC SQL SELECT oid,datname INTO :dbid, :dbname FROM pg_database;

    for (i = 0; i < 8; i++)
        printf("oid=%d, dbname=%s\n", dbid[i], dbname[i]);

    EXEC SQL COMMIT;
    EXEC SQL DISCONNECT ALL;
    return 0;
}

oid=1, dbname=template1
oid=11510, dbname=template0
oid=11511, dbname=postgres
oid=313780, dbname=testdb
oid=0, dbname=
oid=0, dbname=
oid=0, dbname=

EXEC SQL BEGIN DECLARE SECTION;
    typedef struct
    {
       int oid;
       char datname[65];
       long long int size;
    } dbinfo_t;

    dbinfo_t dbval;
EXEC SQL END DECLARE SECTION;

    memset(&dbval, 0, sizeof(dbinfo_t));

    EXEC SQL DECLARE cur1 CURSOR FOR SELECT oid, datname, pg_database_size(oid) AS size FROM pg_database;
    EXEC SQL OPEN cur1;

    /* когда достигнут конец набора результатов, выход из цикла while */
    EXEC SQL WHENEVER NOT FOUND DO BREAK;

    while (1)
    {
        /* Выборка нескольких столбцов в одну структуру. */
        EXEC SQL FETCH FROM cur1 INTO :dbval;

        /* Вывод полей структуры. */
        printf("oid=%d, datname=%s, size=%lld\n", dbval.oid, dbval.datname, dbval.size);
    }

    EXEC SQL CLOSE cur1;

oid=1, datname=template1, size=4324580
oid=11510, datname=template0, size=4243460
oid=11511, datname=postgres, size=4324580
oid=313780, datname=testdb, size=8183012

EXEC SQL BEGIN DECLARE SECTION;
    typedef struct
    {
       int oid;
       char datname[65];
    } dbinfo_t;

    dbinfo_t dbval;
    long long int size;
EXEC SQL END DECLARE SECTION;

    memset(amp;dbval, 0, sizeof(dbinfo_t));

    EXEC SQL DECLARE cur1 CURSOR FOR SELECT oid, datname, pg_database_size(oid) AS size FROM pg_database;
    EXEC SQL OPEN cur1;

    /* при достижении конца набора результатов выйти из цикла while */
    EXEC SQL WHENEVER NOT FOUND DO BREAK;

    while (1)
    {
        /* Выборка нескольких столбцов в одну структуру. */
        EXEC SQL FETCH FROM cur1 INTO :dbval, :size;

        /* Вывод полей структуры. */
        printf("oid=%d, datname=%s, size=%lld\n", dbval.oid, dbval.datname, size);
    }

    EXEC SQL CLOSE cur1;

EXEC SQL BEGIN DECLARE SECTION;
    typedef char mychartype[40];
    typedef long serial_t;
EXEC SQL END DECLARE SECTION;

EXEC SQL TYPE serial_t IS long;

EXEC SQL BEGIN DECLARE SECTION;
    typedef int start;
EXEC SQL END DECLARE SECTION;
...
EXEC SQL START TRANSACTION;

EXEC SQL BEGIN DECLARE SECTION;
    int   *intp;
    char **charp;
EXEC SQL END DECLARE SECTION;

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

Если запрос обращается к элементам массива по отдельности, это позволяет избежать использования массивов в препроцессоре ECPG. В таком случае следует использовать главную переменную, тип которой может быть сопоставлен с типом элементов массива. Например, если типом столбца является массив integer, может быть использована главная переменная типа int can be used. Также, если типом элемента является varchar или text, может быть использована главная переменная типа char[] или VARCHAR[] can be used.

Ниже приведен пример. Предположим, имеется следующая таблица:

CREATE TABLE t3 (
    ii integer[]
);

testdb=> SELECT * FROM t3;
     ii
-------------
 {1,2,3,4,5}
(1 row)

Следующий пример программы извлекает 4-й элемент массива и сохраняет его в главную переменную типа int:

EXEC SQL BEGIN DECLARE SECTION;
int ii;
EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE cur1 CURSOR FOR SELECT ii[4] FROM t3;
EXEC SQL OPEN cur1;

EXEC SQL WHENEVER NOT FOUND DO BREAK;

while (1)
{
    EXEC SQL FETCH FROM cur1 INTO :ii ;
    printf("ii=%d\n", ii);
}

EXEC SQL CLOSE cur1;

В данном примере выводится следующий результат:

ii=4

Для сопоставления нескольких элементов массива с несколькими элементами главной переменной типа массив каждый элемент столбца массива и каждый элемент массива главной переменной должны обрабатываться отдельно, например:

EXEC SQL BEGIN DECLARE SECTION;
int ii_a[8];
EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE cur1 CURSOR FOR SELECT ii[1], ii[2], ii[3], ii[4] FROM t3;
EXEC SQL OPEN cur1;

EXEC SQL WHENEVER NOT FOUND DO BREAK;

while (1)
{
    EXEC SQL FETCH FROM cur1 INTO :ii_a[0], :ii_a[1], :ii_a[2], :ii_a[3];
    ...
}

Еще раз обратите внимание на то, что

EXEC SQL BEGIN DECLARE SECTION;
int ii_a[8];
EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE cur1 CURSOR FOR SELECT ii FROM t3;
EXEC SQL OPEN cur1;

EXEC SQL WHENEVER NOT FOUND DO BREAK;

while (1)
{
    /* WRONG */
    EXEC SQL FETCH FROM cur1 INTO :ii_a;
    ...
}

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

Другой способ обхода заключается в хранении массивов в их внешнем строковом представлении в главных переменных, имеющих char[] или VARCHAR[]. Для получения более подробной информации о данном представлении см. Раздел 2.5.15.2. Обратите внимание: это означает, что к массиву нельзя будет обращаться как к обычному массиву в главной программе (без дополнительной обработки, выполняющей синтаксический анализ текстового представления).

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

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

CREATE TYPE comp_t AS (intval integer, textval varchar(32));
CREATE TABLE t4 (compval comp_t);
INSERT INTO t4 VALUES ( (256, 'PostgreSQL') );

Наиболее очевидным решением является доступ к каждому атрибуту по отдельности. Следующая программа извлекает данные из таблицы примера путем выбора каждого атрибута типа comp_t по отдельности:

EXEC SQL BEGIN DECLARE SECTION;
int intval;
varchar textval[33];
EXEC SQL END DECLARE SECTION;

/* Поместите каждый элемент столбца составного типа в список SELECT. */
EXEC SQL DECLARE cur1 CURSOR FOR SELECT (compval).intval, (compval).textval FROM t4;
EXEC SQL OPEN cur1;

EXEC SQL WHENEVER NOT FOUND DO BREAK;

while (1)
{
    /* Извлеките каждый элемент столбца составного типа в главные переменные. */
    EXEC SQL FETCH FROM cur1 INTO :intval, :textval;

    printf("intval=%d, textval=%s\n", intval, textval.arr);
}

EXEC SQL CLOSE cur1;

Чтобы улучшить этот пример, главные переменные для хранения значений в FETCH команде, могут быть объединены в одну структуру. Для получения более подробных сведений об использовании главной переменной в форме структуры см. раздел Раздел 4.3.4.4.3.2. Для перехода к использованию структуры пример можно изменить следующим образом. Две главные переменные, intval и textval, становятся членами структуры comp_t , и сама структура указывается в FETCH команде.

EXEC SQL BEGIN DECLARE SECTION;
typedef struct
{
    int intval;
    varchar textval[33];
} comp_t;

comp_t compval;
EXEC SQL END DECLARE SECTION;

/* Поместите каждый элемент столбца составного типа в список SELECT. */ */ EXEC SQL DECLARE cur1 CURSOR FOR SELECT (compval).intval, (compval).textval FROM t4; EXEC SQL OPEN cur1;  EXEC SQL WHENEVER NOT FOUND DO BREAK;  while (1) {     /* Поместить все значения из списка SELECT в одну структуру. */     EXEC SQL FETCH FROM cur1 INTO :compval;      printf("intval=%d, textval=%s\n", compval.intval, compval.textval.arr); }  EXEC SQL CLOSE cur1;

Хотя в команде используется структура, FETCH имена атрибутов в предложении SELECT предложения указываются одно за другим. Этот процесс можно улучшить, используя * для запроса всех атрибутов значения составного типа.

...
EXEC SQL DECLARE cur1 CURSOR FOR SELECT (compval).* FROM t4;
EXEC SQL OPEN cur1;

EXEC SQL WHENEVER NOT FOUND DO BREAK;

while (1)
{
    /* Поместить все значения из списка SELECT в одну структуру. */
    EXEC SQL FETCH FROM cur1 INTO :compval;

    printf("intval=%d, textval=%s\n", compval.intval, compval.textval.arr);
}
...

Таким образом, составные типы можно сопоставлять со структурами практически бесшовно, даже если препроцессор ECPG не распознает сам составной тип.

Наконец, значения составных типов также можно сохранять в их внешнем строковом представлении в главных переменных типа char[] или VARCHAR[]. Однако в этом случае прямой доступ к полям значения из главной программы затруднен.

Новые базовые типы, определенные пользователем, не поддерживаются препроцессором ECPG напрямую. Вы можете использовать внешнее строковое представление и главные переменные типа char[] или VARCHAR[], и данное решение является подходящим и достаточным для многих типов.

Ниже приведен пример использования типа данных complex из примера в Раздел 5.1.13. Внешнее строковое представление этого типа имеет вид (%f,%f), которое определено в функциях complex_in() и complex_out() функции в Раздел 5.1.13. В следующем примере значения комплексного типа вставляются (1,1) и (3,3) в столбцы a и b, после чего выбираются из таблицы.

EXEC SQL BEGIN DECLARE SECTION;
    varchar a[64];
    varchar b[64];
EXEC SQL END DECLARE SECTION;

    EXEC SQL INSERT INTO test_complex VALUES ('(1,1)', '(3,3)');

    EXEC SQL DECLARE cur1 CURSOR FOR SELECT a, b FROM test_complex;
    EXEC SQL OPEN cur1;

    EXEC SQL WHENEVER NOT FOUND DO BREAK;

    while (1)
    {
        EXEC SQL FETCH FROM cur1 INTO :a, :b;
        printf("a=%s, b=%s\n", a.arr, b.arr);
    }

    EXEC SQL CLOSE cur1;

Данный пример выводит следующий результат:

a=(1,1), b=(3,3)

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

Например,

CREATE FUNCTION create_complex(r double, i double) RETURNS complex
LANGUAGE SQL
IMMUTABLE
AS $$ SELECT $1 * complex '(1,0')' + $2 * complex '(0,1)' $$;

После данного определения следующий фрагмент кода

EXEC SQL BEGIN DECLARE SECTION;
double a, b, c, d;
EXEC SQL END DECLARE SECTION;

a = 1;
b = 2;
c = 3;
d = 4;

EXEC SQL INSERT INTO test_complex VALUES (create_complex(:a, :b), create_complex(:c, :d));

дает тот же результат, что и

EXEC SQL INSERT INTO test_complex VALUES ('(1,2)', '(3,4)');