PostgreSQL 教程

Appearance

36.4. 使用宿主变量# ​

36.4.1. 概述
36.4.2. 声明节
36.4.3. 检索查询结果
36.4.4. 类型映射
36.4.5. 处理非原始 SQL 数据类型
36.4.6. 指示器

在第 36.3 节中，您了解了如何从嵌入式 SQL 程序执行 SQL 语句。其中一些语句仅使用固定值，并且没有提供将用户提供的值插入语句或让程序处理查询返回的值的方法。这些类型的语句在实际应用程序中并不真正有用。本节详细解释了如何使用称为宿主变量的简单机制在 C 程序和嵌入式 SQL 语句之间传递数据。在嵌入式 SQL 程序中，我们将 SQL 语句视为宿主语言中 C 程序代码中的来宾。因此，C 程序的变量称为宿主变量。

在 PostgreSQL 后端和 ECPG 应用程序之间交换值的另一种方法是使用 SQL 描述符，如第 36.7 节中所述。

36.4.1. 概述# ​

在嵌入式 SQL 中，在 C 程序和 SQL 语句之间传递数据非常简单。您可以简单地将 C 变量的名称写入 SQL 语句中，并在其前面加上冒号，而不是让程序将数据粘贴到语句中，这会带来各种复杂性，例如正确引用值。例如

EXEC SQL INSERT INTO sometable VALUES (:v1, 'foo', :v2);

此语句引用了两个名为v1和v2的 C 变量，还使用了常规 SQL 字符串文字，以说明您不必仅限于使用一种或另一种数据。

这种在 SQL 语句中插入 C 变量的样式适用于在 SQL 语句中需要值表达式的任何位置。

36.4.2. 声明节# ​

要将数据从程序传递到数据库（例如作为查询中的参数），或将数据从数据库传递回程序，则包含此数据的 C 变量需要在特殊标记的节中声明，以便嵌入式 SQL 预处理器了解它们。

此节以

EXEC SQL BEGIN DECLARE SECTION;

开头，以

EXEC SQL END DECLARE SECTION;

结尾。在这些行之间，必须有正常的 C 变量声明，例如

int   x = 4;
char  foo[16], bar[16];

如您所见，您可以选择为变量分配初始值。变量的范围由其声明节在程序中的位置决定。您还可以使用以下语法声明变量，该语法会隐式创建声明节

EXEC SQL int i = 4;

您可以在一个程序中拥有任意数量的 declare 部分。

声明也会像普通的 C 变量一样回显到输出文件中，因此无需再次声明它们。不打算在 SQL 命令中使用的变量可以在这些特殊部分之外正常声明。

结构或联合的定义也必须列在DECLARE部分内。否则，预处理器无法处理这些类型，因为它不知道定义。

36.4.3. 检索查询结果# ​

现在，您应该能够将程序生成的数据传递到 SQL 命令中。但如何检索查询结果？为此，嵌入式 SQL 提供了常用命令SELECT和FETCH的特殊变体。这些命令有一个特殊的INTO子句，用于指定要将检索到的值存储在哪些主机变量中。SELECT用于仅返回单行的查询，而FETCH用于使用游标返回多行的查询。

这是一个示例

/*
 * assume this table:
 * CREATE TABLE test1 (a int, b varchar(50));
 */

EXEC SQL BEGIN DECLARE SECTION;
int v1;
VARCHAR v2;
EXEC SQL END DECLARE SECTION;

 ...

EXEC SQL SELECT a, b INTO :v1, :v2 FROM test;

因此，INTO子句出现在 select 列表和FROM子句之间。select 列表中的元素数量和INTO之后的列表（也称为目标列表）中的元素数量必须相等。

这是一个使用命令FETCH的示例

EXEC SQL BEGIN DECLARE SECTION;
int v1;
VARCHAR v2;
EXEC SQL END DECLARE SECTION;

 ...

EXEC SQL DECLARE foo CURSOR FOR SELECT a, b FROM test;

 ...

do
{
    ...
    EXEC SQL FETCH NEXT FROM foo INTO :v1, :v2;
    ...
} while (...);

此处，INTO子句出现在所有正常子句之后。

36.4.4. 类型映射# ​

当 ECPG 应用程序在 PostgreSQL 服务器和 C 应用程序之间交换值时，例如从服务器检索查询结果或使用输入参数执行 SQL 语句时，需要在 PostgreSQL 数据类型和主机语言变量类型（具体来说是 C 语言数据类型）之间转换值。ECPG 的主要优点之一是它在大多数情况下会自动处理这一点。

在这方面，有两种数据类型：一些简单的 PostgreSQL 数据类型，例如integer和text，可以由应用程序直接读写。其他 PostgreSQL 数据类型，例如timestamp和numeric，只能通过特殊库函数访问；请参见第 36.4.4.2 节。

表 36.1显示了哪些 PostgreSQL 数据类型对应于哪些 C 数据类型。当您希望发送或接收给定 PostgreSQL 数据类型的值时，您应该在 declare 部分中声明相应 C 数据类型的 C 变量。

表 36.1. PostgreSQL 数据类型与 C 变量类型之间的映射

PostgreSQL 数据类型宿主变量类型
smallintshort
integerint
bigintlong long int
decimaldecimal[a]
numericnumeric[a]
realfloat
double precisiondouble
smallserialshort
serialint
bigseriallong long int
oidunsigned int
character(n), varchar(n), textchar[n+1], VARCHAR[n+1]
namechar[NAMEDATALEN]
timestamptimestamp[a]
intervalinterval[a]
datedate[a]
booleanbool[b]
byteachar *, bytea[n]

[a] 只能通过特殊库函数访问此类型；请参见 第 36.4.4.2 节。

[b] 如果不是本机，则在 ecpglib.h 中声明

36.4.4.1. 处理字符串# ​

要处理 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 类型的值，这些值将以其字符串形式存储。

36.4.4.2. 访问特殊数据类型# ​

ECPG 包含一些特殊类型，可帮助您轻松与 PostgreSQL 服务器中的某些特殊数据类型进行交互。特别是，它已实现对numeric、decimal、date、timestamp和interval类型的支持。这些数据类型不能有效地映射到原始宿主变量类型（如int、long long int或char[]），因为它们具有复杂的内部结构。应用程序通过在特殊类型中声明宿主变量并使用 pgtypes 库中的函数访问它们来处理这些类型。pgtypes 库在第 36.6 节中详细描述，它包含处理这些类型的基本函数，这样您就不必向 SQL 服务器发送查询，例如仅将间隔添加到时间戳。

以下小节描述了这些特殊数据类型。有关 pgtypes 库函数的更多详细信息，请参见第 36.6 节。

36.4.4.2.1. timestamp、date# ​

以下是在 ECPG 主机应用程序中处理timestamp变量的模式。

首先，程序必须包含timestamp类型的头文件

#include <pgtypes_timestamp.h>

接下来，在声明部分将主机变量声明为timestamp类型

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

在将值读入主机变量后，使用 pgtypes 库函数对其进行处理。在以下示例中，timestamp值使用PGTYPEStimestamp_to_asc()函数转换为文本（ASCII）形式

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

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

此示例将显示以下结果

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

此外，DATE 类型可以以相同的方式处理。程序必须包含pgtypes_date.h，将主机变量声明为 date 类型，并使用PGTYPESdate_to_asc()函数将 DATE 值转换为文本形式。有关 pgtypes 库函数的更多详细信息，请参见第 36.6 节。

36.4.4.2.2. interval# ​

处理interval类型的过程也类似于timestamp和date类型。但是，需要显式地为interval类型值分配内存。换句话说，变量的内存空间必须分配在堆内存中，而不是栈内存中。

以下是一个示例程序

#include <stdio.h>
#include <stdlib.h>
#include <pgtypes_interval.h>

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;
}
36.4.4.2.3. numeric、decimal# ​

处理numeric和decimal类型的过程类似于interval类型：需要定义一个指针，在堆上分配一些内存空间，并使用 pgtypes 库函数访问变量。有关 pgtypes 库函数的更多详细信息，请参见第 36.6 节。

没有专门针对decimal类型的函数。应用程序必须使用 pgtypes 库函数将其转换为numeric变量，以进行进一步处理。

以下是一个处理numeric和decimal类型变量的示例程序。

#include <stdio.h>
#include <stdlib.h>
#include <pgtypes_numeric.h>

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));

    /* Convert decimal to numeric to show a decimal value. */
    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;
}
36.4.4.2.4. bytea# ​

对bytea类型的处理与VARCHAR类似。对bytea类型数组的定义会针对每个变量转换为一个已命名的结构。类似于这样的声明

bytea var[180];

转换为

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

成员arr托管二进制格式数据。它还可以处理'\0'作为数据的一部分，这与VARCHAR不同。数据会从/转换为十六进制格式，并由 ecpglib 发送/接收。

注意

bytea变量只能在将bytea_output设置为hex时使用。

36.4.4.3. 具有非基本类型的宿主变量# ​

您还可以将数组、typedef、结构和指针用作宿主变量。

36.4.4.3.1. 数组# ​

将数组用作宿主变量有两种用例。第一种方式是将一些文本字符串存储在char[]或VARCHAR[]中，如第 36.4.4.1 节中所述。第二种用例是从查询结果中检索多行，而无需使用游标。如果没有数组，要处理由多行组成的查询结果，则需要使用游标和FETCH命令。但是，使用数组宿主变量时，可以一次接收多行。必须定义数组的长度才能容纳所有行，否则可能会发生缓冲区溢出。

以下示例扫描pg_database系统表，并显示所有 OID 和可用数据库的名称

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=
36.4.4.3.2. 结构# ​

可以将成员名称与查询结果的列名称匹配的结构用于一次检索多个列。该结构支持在单个宿主变量中处理多个列值。

以下示例从pg_database系统表中检索可用数据库的 OID、名称和大小，并使用pg_database_size()函数。在此示例中，结构变量dbinfo_t的成员名称与SELECT结果中的每一列匹配，用于检索一行结果，而无需在FETCH语句中放置多个宿主变量。

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;

    /* when end of result set reached, break out of while loop */
    EXEC SQL WHENEVER NOT FOUND DO BREAK;

    while (1)
    {
        /* Fetch multiple columns into one structure. */
        EXEC SQL FETCH FROM cur1 INTO :dbval;

        /* Print members of the structure. */
        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

结构宿主变量“absorb”与结构一样多的列作为字段。其他列可以分配给其他宿主变量。例如，上述程序还可以像这样重新构建，其中size变量位于结构之外

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(&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;

    /* when end of result set reached, break out of while loop */
    EXEC SQL WHENEVER NOT FOUND DO BREAK;

    while (1)
    {
        /* Fetch multiple columns into one structure. */
        EXEC SQL FETCH FROM cur1 INTO :dbval, :size;

        /* Print members of the structure. */
        printf("oid=%d, datname=%s, size=%lld\n", dbval.oid, dbval.datname, size);
    }

    EXEC SQL CLOSE cur1;
36.4.4.3.3. 类型定义# ​

使用typedef关键字将新类型映射到已存在的类型。

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;

此声明不需要成为声明部分的一部分；也就是说，您还可以将类型定义写为常规 C 语句。

您声明为 typedef 的任何单词都无法在同一程序中EXEC SQL命令中用作 SQL 关键字。例如，此操作将不起作用

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

ECPG 将为START TRANSACTION报告语法错误，因为它不再将START识别为 SQL 关键字，而仅将其识别为 typedef。（如果您遇到此类冲突，并且重命名 typedef 似乎不切实际，则可以使用动态 SQL编写 SQL 命令。）

注意

在 v16 之前的PostgreSQL版本中，使用 SQL 关键字作为 typedef 名称很可能会导致与使用 typedef 本身相关的语法错误，而不是将名称用作 SQL 关键字。当现有 ECPG 应用程序在具有新关键字的新PostgreSQL版本中重新编译时，新行为不太可能导致问题。

36.4.4.3.4. 指针# ​

您可以声明指向最常见类型的指针。但请注意，您不能在没有自动分配的情况下将指针用作查询的目标变量。有关自动分配的更多信息，请参见第 36.7 节。

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

36.4.5. 处理非基本 SQL 数据类型# ​

本节包含有关如何在 ECPG 应用程序中处理非标量和用户定义的 SQL 级数据类型的信息。请注意，这与上一节中描述的非基本类型的宿主变量处理不同。

36.4.5.1. 数组# ​

ECPG 中不支持多维 SQL 级数组。可以将一维 SQL 级数组映射到 C 数组宿主变量，反之亦然。但是，在创建语句时，ecpg 不知道列的类型，因此它无法检查 C 数组是否输入到相应的 SQL 级数组中。在处理 SQL 语句的输出时，ecpg 具有必要的信息，因此会检查两者是否都是数组。

如果查询分别访问数组的元素，则可以避免在 ECPG 中使用数组。然后，应使用可以映射到元素类型的类型的宿主变量。例如，如果列类型是integer数组，则可以使用类型为int的宿主变量。此外，如果元素类型是varchar或text，则可以使用类型为char[]或VARCHAR[]的宿主变量。

下面是一个示例。假设有以下表

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[]。有关此表示的更多详细信息，请参见第 8.15.2 节。请注意，这意味着无法在宿主程序中自然地将数组作为数组访问（不进行进一步处理以解析文本表示）。

36.4.5.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;

/* Put each element of the composite type column in the SELECT list. */
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)
{
    /* Fetch each element of the composite type column into host variables. */
    EXEC SQL FETCH FROM cur1 INTO :intval, :textval;

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

EXEC SQL CLOSE cur1;

为了增强此示例，可以将用于在FETCH命令中存储值的宿主变量收集到一个结构中。有关结构形式中宿主变量的更多详细信息，请参见第 36.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;

/* Put each element of the composite type column in the SELECT list. */
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)
{
    /* Put all values in the SELECT list into one structure. */
    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)
{
    /* Put all values in the SELECT list into one structure. */
    EXEC SQL FETCH FROM cur1 INTO :compval;

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

通过这种方式，即使 ECPG 本身不理解复合类型，复合类型也可以几乎无缝地映射到结构中。

最后，还可以将复合类型值存储在其外部字符串表示形式中，存储在类型为char[]或VARCHAR[]的宿主变量中。但是，通过这种方式，无法轻松地从宿主程序访问该值的字段。

36.4.5.3. 用户定义的基本类型# ​

ECPG 不直接支持新的用户定义基本类型。您可以使用类型为char[]或VARCHAR[]的外部字符串表示形式和宿主变量，并且此解决方案确实适用于许多类型，并且足够。

以下是使用第 38.13 节中示例中的数据类型complex的示例。该类型的外部字符串表示形式为(%f,%f)，它在第 38.13 节中的函数complex_in()和complex_out()中定义。以下示例将复杂类型值(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)');

36.4.6. 指示符# ​

以上示例不处理空值。事实上，如果从数据库中获取空值，检索示例将引发错误。要能够将空值传递到数据库或从数据库中检索空值，您需要向每个包含数据的宿主变量附加第二个宿主变量规范。第二个宿主变量称为指示符，它包含一个标志，指示数据是否为空，在这种情况下，将忽略真实宿主变量的值。以下是一个正确处理空值检索的示例

EXEC SQL BEGIN DECLARE SECTION;
VARCHAR val;
int val_ind;
EXEC SQL END DECLARE SECTION:

 ...

EXEC SQL SELECT b INTO :val :val_ind FROM test1;

如果值不为空，指示符变量val_ind将为零，如果值为 null，则将为负值。（请参阅第 36.16 节以启用特定于 Oracle 的行为。）

指示符还有另一个功能：如果指示符值为正，则表示该值不为空，但当将其存储在宿主变量中时它被截断。

如果将参数-r no_indicator传递给预处理器ecpg，它将在“no-indicator”模式下工作。在 no-indicator 模式下，如果没有指定指示符变量，则将空值（在输入和输出时）表示为字符字符串类型的空字符串，对于整数类型表示为该类型的最小可能值（例如，INT_MIN对于int）。