# 表达式
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 执行表达式之前，请分别设置以下GUC参数：
  ```
  SET plsql_code_type=BYTECODE;
  SET behavior_compat_options='compat_cursor,allow_procedure_compile_check,proc_outparam_override,dynamic_sql_compat,proc_outparam_transfer_length,varray_compat';
  ```
  
- 该章节中的示例可根据[字节码相关DFX](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0736.html)章节介绍，判断存储过程是否通过字节码框架进行执行。
 
当前字节码支持的表达式场景如[表1]所示。
 表1字节码支持的表达式场景 
| 表达式                                                                            | 说明                                                          |
|:---|:---|
| [常量表达式]                 | 用于常量访问的表达式。                                               |
| [变量表达式]                    | 用于变量访问的表达式。                                                |
| [行构造器]                  | 用于构造一个行结构类型的表达式。                                           |
| [布尔类型表达式]               | 用于表示包含逻辑条件（AND、OR以及NOT）的表达式类型。                             |
| [数组引用表达式]                 | 用于表示对数组元素的索引访问的表达式。                                         |
| [集合类型引用表达式]              | 用于表示对集合类型的索引访问的表达式。                                       |
| [集合类型构造器]                   | 用于构造一个集合类型的表达式。                                             |
| [IS NULL/IS NOT NULL表达式] | 用于检测某个值为NULL或不为NULL的表达式。                                     |
| [字段选择表达式]                 | 用于从复合数据类型（如行、结构体、对象或表）中选择特定字段的表达式。                            |
| [操作符表达式]                   | 用于表示由运算符连接一个或多个操作数组成的表达式。                                   |
| [函数表达式]                    | 用于表示包含函数或存储过程调用的表达式。                                         |
| [条件表达式]                   | 用于实现条件逻辑分支的表达式。允许根据不同的条件返回不同的值。                              |
| [复合类型构造器]               | 用于构造一个复合类型的表达式。                                             |
| [空值条件表达式]                  | 一种特殊的条件表达式，用于在两个值相等时返回NULL，不等时返回第一个值的表达式。                  |
| [布尔测试表达式]                | 用于检测布尔值状态的特殊表达式，主要判断某个表达式或列的值是否为TRUE、FALSE或UNKNOWN（即NULL）。 |
| [数组类型构造器]                  | 用于构造一个数组类型的表达式。                                            |
| [XML表达式]                | 用于构造或处理XML内容的表达式。                                           |
| [Coalesce表达式]           | 用于返回一组数据中第一个非NULL值的表达式。                                     |
| [ScalarArrayOp表达式]     | 用于执行标量与数组之间的比较运算（如 = ANY(...)）的表达式。                       |
| [CoerceViaIO表达式]       | 用于通过文本输入/输出函数在不同类型之间进行转换的表达式。                             |
| [MinMax表达式]           | 用于在多个值中计算最小值或最大值的表达式。                                      |
   
 #### 常量表达式
用于常量访问的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_const() AS
a int;
BEGIN
a:=1;
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_const();
 bc_const 
----------
(1 row)
gaussdb=# DROP PROCEDURE bc_const;
DROP PROCEDURE
```
 #### 变量表达式
用于变量访问的表达式。
```
gaussdb=#CREATE OR REPLACE PROCEDURE bc_param() AS
a int;
b int := 1;
BEGIN
a:=b;
END;
/
CREATE PROCEDURE
gaussdb=#CALL bc_param();
 bc_param 
----------
(1 row)
gaussdb=# DROP PROCEDURE bc_param;
DROP PROCEDURE
```
 #### 行构造器
用于构造一个行结构类型的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_rowexpr AS
type tr is record(a int, b varchar);
v tr;
BEGIN
 v := tr(1,2);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_rowexpr();
 bc_rowexpr 
------------
(1 row)
gaussdb=# DROP PROCEDURE bc_rowexpr;
DROP PROCEDURE
```
 #### 布尔类型表达式
用于表示包含逻辑条件（AND、OR以及NOT）的表达式类型。
```
gaussdb=# CREATE OR REPLACE FUNCTION bc_boolexpr() RETURN int
is
a int:= 1;
b int:= 2;
c boolean:=false;
BEGIN
IF a = 1 AND b = 2 THEN
NULL;
END IF;
IF a = 1 OR b = 2 THEN
NULL;
END IF;
IF NOT c THEN
RETURN 1;
END IF;
end;
/
CREATE FUNCTION
gaussdb=# SELECT bc_boolexpr();
 bc_boolexpr
-------------
           1
(1 row)
gaussdb=# DROP FUNCTION bc_boolexpr;
DROP FUNCTION
```
 #### 数组引用表达式
用于表示对数组元素的索引访问的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_arrayref AS
type t_arr is varray(20) of int;
v t_arr := t_arr(1,2,3);
a int;
BEGIN
  a := v(2);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_arrayref();
 bc_arrayref 
-------------
(1 row)
gaussdb=# DROP PROCEDURE bc_arrayref;
DROP PROCEDURE
```
 #### 集合类型引用表达式
对集合类型的索引访问。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_tableofref AS
 type t_tabn is table of int;
 vn t_tabn := t_tabn(1,2,3);
 type t_tabi is table of int index by varchar;
 vi t_tabi := t_tabi('a'=>1,'b'=>2,'c'=>3);
 a int; 
BEGIN
  a := vn(2);
  a := vi('b');
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_tableofref();
 bc_tableofref 
---------------
(1 row)
gaussdb=# DROP PROCEDURE bc_tableofref;
DROP PROCEDURE
```
 #### 集合类型构造器
用于构造一个集合类型的表达式。
```
gaussdb=#CREATE OR REPLACE PROCEDURE bc_tableofexpr AS
type t_tabn is table of int;
vn t_tabn;
type t_tabi is table of int index by varchar;
vi t_tabi;
BEGIN
  vn := t_tabn(1,2,3);
  vi := t_tabi('a'=>1,'b'=>2,'c'=>3);
END;
/
CREATE PROCEDURE
gaussdb=#CALL bc_tableofexpr();
 bc_tableofref 
---------------
(1 row)
gaussdb=# DROP PROCEDURE bc_tableofexpr;
DROP PROCEDURE
```
 #### IS NULL/IS NOT NULL表达式
用于检测某个值为NULL或不为NULL的表达式。
```
gaussdb=# CREATE OR REPLACE FUNCTION bc_nulltest() RETURN int
IS
b int:=1;
c int:=null;
BEGIN
IF c IS NULL THEN
NULL;
END IF;
-- is not null
IF c IS NOT NULL then
NULL;
END IF;
RETURN 1;
END;
/
CREATE FUNCTION
gaussdb=# SELECT bc_nulltest();
 bc_nulltest
-------------
           1
(1 row)
gaussdb=# DROP FUNCTION bc_nulltest;
DROP FUNCTION
```
 #### 字段选择表达式
用于从复合数据类型（如行、结构体、对象或表）中选择特定字段的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_fieldselect AS
 type t_rec is record(a varchar,b int);
 type t_tab2 is table of t_rec;
 v t_rec := t_rec('abc', 3);
 v1 t_tab2 := t_tab2(v);
 a int; 
 b varchar;
BEGIN
  a := v1(1).b;--复合数据类型字段访问
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_fieldselect();
 bc_fieldselect 
----------------
(1 row)
gaussdb=# DROP PROCEDURE bc_fieldselect;
DROP PROCEDURE
```
 #### 操作符表达式
用于表示由运算符连接一个或多个操作数组成的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_opexpr()
AS
DECLARE
a int;
BEGIN
a := 0;
a := a + 1;
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_opexpr();
 bc_opexpr 
-----------
(1 row)
gaussdb=# DROP PROCEDURE bc_opexpr;
DROP PROCEDURE
```
 #### 函数表达式
用于表示包含函数或存储过程调用的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_funcexpr()
AS
DECLARE
a varchar2;
BEGIN
a := 'abc';
a := trim(a);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_funcexpr();
 bc_funcexpr 
-------------
(1 row)
gaussdb=# DROP PROCEDURE bc_funcexpr;
DROP PROCEDURE
```
 #### 条件表达式
用于实现条件逻辑分支的表达式。允许根据不同的条件返回不同的值。
```
gaussdb=# CREATE OR REPLACE FUNCTION bc_caseexpr(score INT)
 RETURN VARCHAR2
 AS
  grade VARCHAR2(1);
 BEGIN
  grade := CASE
  WHEN score >= 90 THEN 'A'
  WHEN score >= 80 THEN 'B'
  WHEN score >= 70 THEN 'C'
  WHEN score >= 60 THEN 'D'
  ELSE 'F'
 END;
 RETURN grade;
 END;
 /
CREATE FUNCTION 
gaussdb=# SELECT bc_caseexpr(65);
 bc_caseexpr
-------------
 D
(1 row)
gaussdb=# DROP PROCEDURE bc_caseexpr;
DROP PROCEDURE
```
 #### 复合类型构造器
用于构造一个复合类型的表达式。
```
gaussdb=# CREATE TYPE bc_complex_type AS (
    r       double precision,
    i       double precision
);
CREATE TYPE
gaussdb=# CREATE OR REPLACE FUNCTION bc_complex_type_function()
RETURN bc_complex_type
AS
    v2 NUMBER := 3;
    v3 NUMBER := 4;
    v1 bc_complex_type;
BEGIN
    v1 := bc_complex_type(v2, v3);
    DBE_OUTPUT.PUT_LINE('Complex Number: ' || v1.r || ' + ' || v1.i || 'i');
    RETURN v1;
END;
/
CREATE FUNCTION
gaussdb=# SELECT bc_complex_type_function();
 bc_complex_type_function
--------------------------
 (3,4)
(1 row)
gaussdb=# DROP FUNCTION bc_complex_type_function;
DROP FUNCTION
gaussdb=# DROP TYPE bc_complex_type;
DROP TYPE
```
 #### 空值条件表达式
一种特殊的条件表达式，用于在两个值相等时返回NULL，不等时返回第一个值的表达式。
```
gaussdb=# CREATE OR REPLACE FUNCTION bc_nullif() RETURN int
IS
a text:= 'aaa123';
b text:= 'aaa123';
d text:= 'abb123';
BEGIN
dbe_output.print_line(NULLIF(a,b));
dbe_output.print_line(NULLIF(a,d));
RETURN 1;
END;
/
CREATE FUNCTION
gaussdb=# SELECT bc_nullif();
aaa123
 bc_nullif
-----------
         1
(1 row)
gaussdb=# DROP FUNCTION bc_nullif;
DROP FUNCTION
```
 #### 布尔测试表达式
用于检测布尔值状态的特殊表达式，主要判断某个表达式或列值是否为TRUE、FALSE或UNKNOWN（即NULL）。
```
gaussdb=# CREATE OR REPLACE FUNCTION bc_booleantest() RETURN int
IS
a boolean:= 'true';
BEGIN
dbe_output.print_line((a is true)::TEXT);
dbe_output.print_line((a is not true)::TEXT);
dbe_output.print_line((a is false)::TEXT);
dbe_output.print_line((a is not false)::TEXT);
dbe_output.print_line((a is UNKNOWN)::TEXT);
dbe_output.print_line((a is not UNKNOWN)::TEXT);
RETURN 1;
END;
/
CREATE FUNCTION
gaussdb=# SELECT bc_booleantest();
true
false
false
true
false
true
 bc_booleantest
----------------
              1
(1 row)
gaussdb=# DROP FUNCTION bc_booleantest;
DROP FUNCTION
```
 #### 数组类型构造器
用于构造一个数组类型的表达式。
```
gaussdb=#CREATE OR REPLACE PROCEDURE bc_arrayexpr AS
type t_arr is varray(20) of int;
v t_arr;
BEGIN
 v := t_arr(1,2,3);
END;
/
CREATE PROCEDURE
gaussdb=#CALL bc_arrayexpr();
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_arrayexpr;
DROP PROCEDURE
```
 #### XML表达式
用于构造或处理XML内容的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_xmlexpr() AS
var xml;
var1 bool;
var2 varchar2;
BEGIN
 var := xmlconcat('<data>Hello</data>', '<data>World</data>');
 var := XMLPARSE(DOCUMENT '<emp><id>101</id><name>Alice</name></emp>');
 var := XMLPI(NAME php, 'echo "Hello";');
 var := XMLROOT('<?xml version="1.1"?><root><b>2</b></root>',VERSION '2.0');
 var := XMLSERIALIZE(CONTENT 'good' AS CHAR(10));
 var := XMLTYPE('<a>123</a>');
 var1 := XMLPARSE(DOCUMENT '<root><x/></root>') IS DOCUMENT;
 var2 := xmltype('<a>123<b>456</b></a>').getstringval();
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_xmlexpr();
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_xmlexpr;
DROP PROCEDURE
```
 #### Coalesce表达式
用于返回一组数据中第一个非NULL值的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_coalesceexpr(va int, vb int, vc int) AS
var text;
BEGIN
 var := coalesce(null, null, va*2, vb, vc);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_coalesceexpr(null,null,1);
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_coalesceexpr;
DROP PROCEDURE
```
 #### ScalarArrayOp表达式
用于执行标量与数组之间的比较运算（如 = ANY(...)）的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_scalararrayopexpr() AS
arr _int4 := (null);
value1 int := 1;
var bool;
BEGIN
 var := value1 = ANY(arr);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_scalararrayopexpr();
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_scalararrayopexpr;
DROP PROCEDURE
```
 #### CoerceViaIO表达式
用于通过文本输入/输出函数在不同类型之间进行转换的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_coerceviaiopexpr() AS
text1 text;
BEGIN
 text1 := ARRAY[1,2,3]::text;
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_coerceviaiopexpr();
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_coerceviaiopexpr;
DROP PROCEDURE
```
 #### MinMax表达式
用于在多个值中计算最小值或最大值的表达式。
```
gaussdb=# CREATE OR REPLACE PROCEDURE bc_minmaxexpr() AS
var bool;
BEGIN
 var := GREATEST(1, 3, 2);
 var := LEAST(1, 3, 2);
END;
/
CREATE PROCEDURE
gaussdb=# CALL bc_minmaxexpr();
 bc_arrayexpr
--------------
(1 row)
gaussdb=# DROP PROCEDURE bc_minmaxexpr;
DROP PROCEDURE
```
