HANA SQL

TIMESTAMP 数据类型由日期和时间信息组成时戳。默认格式为‘YYYY-MM-DD HH24:MI:SS.FF7’。 FFn 表明含有小数的秒，其中 n 表示小数部分的数字位数。时间戳的范围从 0001-01-01 00:00:00.0000000 至 9999-12-31 23:59:59.9999999。

select to_timestamp('2015/1/2 1:1:1','YYYY/MM/DD HH:MI:SS') from dummy;

select to_timestamp('2015/1/2 1:1:1.999','YYYY/MM/DD HH:MI:SS.FF3') from dummy;

select to_timestamp('2015/1/2 1:1:1.9999999','YYYY/MM/DD HH:MI:SS.FF7') from dummy;

selectcurrent_timestampfrom dummy;--2015-6-12 16:50:26.349

select to_char(current_timestamp,'D') from dummy;--5 注：这个应该是星期几

select to_char(current_timestamp,'DD') from dummy;--12

select to_char(current_timestamp,'DDD') from dummy;--163

select to_char(current_timestamp,'Day') from dummy;--Friday

select to_char(current_timestamp,'Dy') from dummy;--Fri

select to_char(current_timestamp,'mon') from dummy;--jun

select to_char(current_timestamp,'month') from dummy;--june

select to_char(current_timestamp,'rm') from dummy;--vi

select to_char(current_timestamp,'q') from dummy;--2

select to_char(current_timestamp,'w') from dummy;--2

select to_char(current_timestamp,'ww') from dummy;--24

select to_char(current_timestamp,'FF7') from dummy;--1260000

select to_char(current_timestamp,'YY') from dummy;--15

2.2数字类型

2.2.1 TINYINT

TINYINT 数据类型存储一个 8 位（1个字节）无符号整数。 TINYINT 的最小值是 0，最大值是 255。

2.2.2 SMALLINT

SMALLINT 数据类型存储一个 16 （2个字节）位无符号整数。 SMALLINT 的最小值为-32,768 ，最大值为32, 767。

2.2.3 INTEGER

INTEGER 数据类型存储一个 32 （4个字节）位有符号整数。 INTEGER 的最小值为-2,147,483,648 ，最大值为 2,147,483,647。

2.2.4 BIGINT

BIGINT 数据类型存储一个 64 （8个字节）位有符号整数。 INTEGER 的最小值为-9,223,372,036,854,775,808，最大值为 9, 223,372,036,854,775,807。

2.2.5 DECIMAL（精度，小数位数）或 DEC（ p, s）

DECIMAL (p, s) 数据类型指定了一个精度为 p 小数位数为 s 的定点小数。精度是有效位数的总数，范围从 1 至 34。

小数位数是从小数点到最小有效数字的数字个数，范围从-6,111 到 6,176，这表示位数指定了十进制小数的指数范围从 10^-6111 至 10⁶¹⁷⁶。若是没有指定小数位数，则默认值为 0。

当数字的有效数字在小数点的右侧（后面）时，小数位数为正；有效数字在小数点左侧（前面）时，小数位数为负。

例子：

0.0000001234 (1234 x 10^-10) 精度为 4，小数位数 10。

1.0000001234(10000001234 x 10^-10) 精度为 11，小数位数为 10。

1234000000 (1234x10⁶) 精度为 4，小数位数为-6。

当未指定精度和小数位数， DECIMAL 成为浮点小数。这种状况下，精度和小数位数能够在上文描述的范围内不一样，根据存储的数值， 1-34 的精度和 6111-6176 的小数位数。

2.2.6 SMALLDECIMAL

SMALLDECIMAL 是一个浮点十进制数。精度和小数位数能够在范围有所不一样，根据存储的数值， 1-16 的精度以及-369-368的小数位数。 SMALLDECIMAL 只支持列式存储。

DECIMAL 和 SMALLDECIMAL 都是浮点十进制数。举例来讲，一个十进制列能够存储 3.14，3.1415， 3.141592 同时保持它们的精度。

DECIMAL(p, s) 是 SQL 对于定点十进制数的标准标记。例如， 3.14, 3.1415,3.141592 存储在 decimal(5, 4)列中为 3.1400, 3.1415, 3.1416，各自保持其精度（ 5）和小数位数（ 4）。

2.2.7 REAL

REAL 数据类型定义一个 32 位（4个字节）单精度浮点数。

2.2.8 DOUBLE

DOUBLE 数据类型定义一个 64 位（8个字节）的双精度浮点数，最小值为-1.79769 x 10³⁰⁸，最大值为

1.79769x10³⁰⁸， DOUBLE 最小的正数为 2.2207x10^-308，最大的负数为-2.2207x10^-308。

2.2.9 FLOAT( n )

FLOAT 数据类型定义一个 32 位或 64 位的实数， n 指定有效数字的个数，范围能够从 1 至53。

当你使用 FLOAT( n )数据类型时，若是 n 比 25 小，其会变成 32 位的实数类型；若是 n 大于等于 25，则会成为 64 的 DOUBLE 数据类型。若是 n 没有声明，默认变成 64 位的double 数据类型。

2.3字符类型

字符类型用来存储包含字符串的值。 VARCHAR类型包含 ASCII字符串，而 NVARCHAR用来存储 Unicode字符串。

2.3.1 VARCHAR

VARCHAR (n) 数据类型定义了一个可变长度的 ASCII 字符串， n 表示最大长度，是一个 1 至5000的整数值。

2.3.2 NVARCHAR

NVARCHAR (n) 数据类型定义了一个可变长度的 Unicode 字符串， n 表示最大长度，是一个1 至 5000的整数值。

2.3.3 ALPHANUM

ALPHANUM (n) 数据类型定义了一个可变长度的包含字母数字的字符串， n 表示最大长度，是一个 1 至 127的整数值。

2.3.4 SHORTTEXT

SHORTTEXT (n) 数据类型定义了一个可变长度的字符串，支持文本搜索和字符搜索功能。

这不是一个标准的 SQL 类型。选择一列 SHORTTEXT (n) 列会生成一个 NVARCHAR (n)类型的列。

2.4二进制类型

二进制类型用来存储二进制数据的字节。

2.4.1 VARBINARY

VARBINARY 数据类型用来存储指定最大长度的二进制数据，以字节为单位， n 表明最大长度，是一个 1 至 5000的整数。

2.5大对象（ LOB）类型

LOB（大对象）数据类型， CLOB， NCLOB 和 BLOB，用来存储大量的数据例如文本文件和图像。一个 LOB 的最大大小为 2GB。

2.5.1 BLOB

BLOB 数据类型用来存储大二进制数据。

2.5.2 CLOB

CLOB 数据类型用来存储大 ASCII 字符数据。

2.5.3 NCLOB

NCLOB 数据类型用来存储大 Unicode 字符对象。

2.5.4 TEXT

TEXT 数据类型指定支持文本搜索功能，这不是一个独立的 SQL 类型。选择一列 TEXT 列会

生成一个 NCLOB 类型的列。

LOB 类型用于存储和检索大量的数据。 LOB 类型支持如下操做：

lLength(n)以字节形式返回 LOB 的长度。

lLIKE 能够用来搜索 LOB 列。

LOB 类型有以下限制：

lLOB 列不能出如今 ORDER BY 或 GROUP BY 子句中。

lLOB 列不能出如今 FROM 子句做为联接谓词。

l不能做为谓词出如今 WHERE 子句中，除了 LIKE， CONTAINS， =或<>。

lLOB 列不能出如今 SELECT 子句做为一个聚合函数的参数。

lLOB 列不能出如今 SELECT DISTINCT 语句中。

lLOB 列不能用于集合操做，除了 EXCEPT， UNION ALL 是个例外。

lLOB 列不能做为主键。

lLOB 列不能使用 CREATE INDEX 语句。

lLOB 列不能使用统计信息更新语句。

2.6SQL 数据类型和列存储数据类型之间的映射

2.7数据类型转换

本节描述 SAP HANA 数据库中容许的类型转换。

2.7.1 显式类型转换

表达式结果的类型，例如一个字段索引，一个字段函数或者文字可使用以下函数进行转换： CAST, TO_ALPHANUM, TO_BIGINT, TO_VARBINARY,TO_BLOB, TO_CLOB, TO_DATE, TO_DATS, TO_DECIMAL, TO_DOUBLE, TO_INTEGER, TO_INT,TO_NCLOB, TO_NVARCHAR, TO_REAL, TO_SECONDDATE, TO_SMALLINT, TO_TINYINT, TO_TIME,TO_TIMESTAMP, TO_VARCHAR。

2.7.2 隐式类型转换

当给定的一系列运算符/参数类型不符合其所指望的类型， SAP HANA 数据库就会执行类型转换。这种转换仅仅发生在相关的转换可供使用，而且使得运算符/参数类型可执行。

举例来讲， BIGINT 和 VARCHAR 之间的比较是经过把 VARCHAR 隐式转换成 BIGINT 进行的。

显式转换能够所有用于隐式转换，除了 TIME 和 TIMESTAMP 数据类型。 TIME 和TIMESTAMP 可使用 TO_TIME(TIMESTAMP)以及 TO_TIMESTAMP(TIME)相互转换。

例子

2.7.3 转换规则表

在下表中：

 方框中“OK”表示容许的数据类型转换，没有任何检查。

 方框中”CHK”表示数据类型转换只有在数据是有效的目标类型时才执行。

 方框中”-”表示不容许该数据类型转换。

以下显示的规则同时适用于隐式和显示转换，除了 TIME 至 TIMESTAMP 的转换。 TIME 类型只能经过显示转换 TO_TIMESTAMP 或者 CAST 函数执行。

2.7.4 类型转换优先级

本节介绍 SAP HANA 数据库实施的数据类型的优先级。数据类型优先级指定较低优先级的类型转换为较高优先级的类型。

2.8类型常量

常量是表示一个特定的固定数值的符号。

2.8.1 字符串常量

字符串常量括在单引号中。

o 'Brian'

o '100'

Unicode 字符串的格式与字符串类似，但前面有一个 N 标识符（ N 表明 SQL-92 标准中的国际语言）。 N 字母前缀必须是大写。

o N'abc'

SELECT'Brian'"character string 1", '100'"character string 2", N'abc'"unicode string"FROM DUMMY;

2.8.2 数字常量

数字常量用没有括在单引号中的数字字符串表示。数字可能包含小数点或者科学计数。

o 123

o 123.4

o 1.234e2

2.8.3 十六进制数字常量

十六进制数字常量是十六进制数的字符串，含有前缀 0x。

o 0x0abc

SELECT 123 "integer", 123.4 "decimal1", 1.234e2 "decimal2", 0x0abc "hexadecimal"FROM DUMMY;

2.8.4 二进制字符串常量

二进制字符串有前缀 X，是一个括在单引号中的十六进制数字字符串。

o X'00abcd'

o x'dcba00'

SELECT X'00abcd'"binary string 1", x'dcba00'"binary string 2"FROM DUMMY;

2.8.5 日期、时间、时间戳常量

日期、时间、时间戳各自有以下前缀：

o date'2010-01-01'

o time'11:00:00.001'

o timestamp'2011-12-31 23:59:59'

SELECT date'2010-01-01' "date", time'11:00:00.001' "time", timestamp'2011-12-31 23:59:59' "timestamp" FROM DUMMY;

SELECTdate'2010-01-01'"date", time'11:00:00.001'"time", timestamp'2011-12-31 23:59:59'"timestamp"FROM DUMMY;

3 谓词

谓词由组合的一个或多个表达式，或者逻辑运算符指定，并返回如下逻辑 /真值中的一个：

TRUE、 FALSE、或者 UNKNOW。

3.1比较谓词

两个值使用比较谓词进行比较，并返回 TRUE， FALSE 或 UNKNOW。

语法：

<comparison_predicate> ::=<expression> { = | != | <> | > | < | >= | <= } [ ANY | SOME| ALL ] { <expression_list> | <subquery> }

<expression_list> ::= <expression>, ...

表达式能够是简单的表达式如字符、日期或者数字，也能够是标量（只有一条结果）子查询，这种子查询的SELECT从句中只有一个表字段或者是一个统计列

若是子查询的结果只有一条数据时，能够省略[ALL|ANY|SOME]选项

若是子查询返回的是多条，则可须要带上[ALL|ANY|SOME]选项

²  ALL：若是子查询返回的全部行都知足比较条件时，才为真

²  ANY|SOME：若是子查询返回的全部行中只要有一条知足比较条件时，就会为真

²  =等号与ANY|SOME一块儿使用时，与IN操做符具备同样的效果

3.2BETWEEN谓词

值将在给定范围中进行比较。

语法：

<range_predicate> ::= <expression1> [NOT] BETWEEN <expression2> AND <expression3>

BETWEEN …AND … - 当指定了范围谓词时，若是 expression1 在 expression2 和 expression3 指定的范围内时，结果返回真；若是 expression2 比 expression3 小，则只返回真。

3.3In 谓词

一个值与一组指定的值比较。若是 expression1 的值在 expression_list（或子查询）中，结果返回真。

语法：

<in_predicate> ::= <expression> [NOT] IN { <expression_list> | <subquery> }

... WHERE CITY IN ('BERLIN', 'NEW YORK', 'LONDON').

若是CITY为IN后面列表中的任何一个时返回true

IN后面也能够根子查询：

SELECT SINGLE city latitude longitude
  INTO (city, lati, longi)
  FROM sgeocity
  WHERE city IN ( SELECT cityfrom FROM spfli
                    WHERE carrid = carr_id
                    AND   connid = conn_id ).

3.4Exists 谓词

若是子查询返回非空结果集，结果为真；返回空结果集，结果则为假。

这类子查询没有返回值，也不要求SELECT从句中只有一个选择列，选择列能够任意个数，WHERE or HAVING从句来根据该子查询的是否查询到数据来决定外层主查询语句来选择相应数据

DATA: name_tab TYPE TABLE OF scarr-carrname,
      name LIKE LINE OF name_tab.
SELECT carrname INTO TABLE name_tab FROM scarr
  WHERE EXISTS ( SELECT * FROM spfli
                    WHERE carrid = scarr~carrid
                    AND cityfrom = 'NEW YORK' ).
LOOP AT name_tab INTO name.
  WRITE: / name.
ENDLOOP.

此子查询又为相关子查询：

若是某个子查的WHERE条件中引用了外层查询语句的列，则称此子查询为相关子查询。相关子查询对外层查询结果集中的每条记录都会执行一次，因此尽可能少用相关子查询

3.5Like 谓词

Like 用来比较字符串， Expression1 与包含在 expression2 中的模式比较。通配符（ %）和（ _）能够用在比较字符串 expression2 中。

“_”用于替代单个字符，“%”用于替代任意字符串，包括空字符串。

可使用ESCAPE选项指定一个忽略符号h，若是通配符“_”、“%”前面有符号<h>，那么通配符失去了它在模式中的功能，而指字符自己了：

... WHERE FUNCNAME LIKE'EDIT#_%'ESCAPE'#';

以“EDIT_”开头的字符串

3.6NULL 谓词

当指定了谓词 IS NULL，值能够与 NULL 比较。若是表达式值为 NULL，则 IS NULL 返回值为真；若是指定了谓词 IS NOT NULL，值不为 NULL 时返回值为真。

语法：

null_predicate> ::= <expression> IS [NOT] NULL

3.7CONTAINS 谓词

CONTAINS 谓词用来搜索子查询中文本匹配的字符串。

语法：

<contains_function> ::= CONTAINS '(' <contains_columns> ',' <search_string>')'| CONTAINS '(' <contains_columns> ',' <search_string> ',' <search_specifier> ')'

<contains_columns> ::= '*' | <column_name> | '(' <columnlist> ')'

<search_string> ::= <string_const>

<search_specifier> ::= <search_type> <opt_search_specifier2_list>| <search_specifier2_list>

<opt_search_specifier2_list> ::= empty| <search_specifier2_list>

<search_type> ::= <exact_search> | <fuzzy_search> | <linguistic_search>

<search_specifier2_list> ::= <search_specifier2>| <search_specifier2_list> ',' <search_specifier2>

<search_specifier2> := <weights> | <language>

<exact_search> ::= EXACT

<fuzzy_search> ::= FUZZY| FUZZY '(' <float_const> ')' | FUZZY '(' <float_const> ',' <additional_params> ')'

<linguistic_search> ::= LINGUISTIC

<weights> ::= WEIGHT '(' <float_const_list> ')'

<language> :: LANGUAGE '(' <string_const> ')'

<additional_params> ::= <string_const>

search_string：使用自由式字符串搜索格式（例如， Peter "Palo Alto"或 Berlin -"SAP LABS"）。

search_specifier：若是没有指定 search_specifier， EXACT 为默认值。

EXACT：对于那些在 search_attributes 中精确匹配 searchterms 的记录， EXACT 返回真。

FUZZY：对于那些在 search_attributes 类似匹配 searchterms 的记录， FUZZY 返回真(例如，以某种程度忽略拼写错误)。

Float_const：若是省略 float_const，则默认值为 0.8。能够经过定义列式存储联接视图支持的参数FUZZINESSTHRESHOLD 来覆盖默认值。

WEIGHT：若是定义了 weights 列表，则必须与<contains_columns>中的列数量同样。

LANGUAGE：LANGUAGE 在搜索字符串的预处理中使用，而且做为搜索前的过滤。只返回匹配搜索字符串的文档和定义的语言。

LINGUISTIC：对于那些在 searchattribute 中出现的 searchterms 字符变量， LINGUISTIC 返回真。

限制：若是在 where 条件中定义了多个 CONTAINS，那么只有其中的一个由<contains_columns>列表中的不止一列组成。

CONTAINS 只对列式存储表适用（简单表和联接视图）。

例子:

精确搜索：

select * from T where contains(column1, 'dog OR cat') -- EXACT is implicit

select * from T where contains(column1, 'dog OR cat', EXACT)

select * from T where contains(column1, '"cats and dogs"') -- phrase search

模糊搜索：

select * from T where contains(column1, 'catz', FUZZY(0.8))

语言搜索：

select * from T where contains(column1, 'catz', LINGUISTIC)

自由式搜索：自由式搜索是对于多列的搜索。

select * from T where CONTAINS( (column1,column2,column3), 'cats OR dogz', FUZZY(0.7))

4 操做符

你能够在表达式中使用操做符进行算术运算。操做符能够用来计算、比较值或者赋值。

4.1一元和二元操做符

4.2操做符优先级

一个表达式可使用多个操做符。若是操做符大于一个，则 SAP HANA 数据库会根据操做符优先级评估它们。你能够经过使用括号改变顺序，由于在括号内的表达式会第一个评估。

若是没有使用括号，则操做符优先级将根据下表。请注意， SAP HANA 数据库对于优先级相同的操做符将从左至右评估操做符。

4.3算术操做符

你可使用算术操做符来执行数学运算，如加法、减法、乘法和除法，以及负数。

4.4字符串操做符

对于 VARCHAR 或者 NVARCHAR 类型字符串，前导或者后置空格将保留。若是其中一字符串类型为 NVARCHAR，则结果也为 NVARCHAR 而且限制在 5000 个字母， VARCHAR 联接的最大长度也限制在 5000 个字母。

4.5比较操做符

语法：

<comparison_operation> ::= <expression1> <comparison_operator> <expression2>

4.6逻辑操做符

搜索条件可使用 AND 或者 OR 操做符结合，你也可使用 NOT 操做符否认条件。

4.7合并操做符

对两个或更多个查询的结果执行合并操做

UNION：并集，去重

UNION ALL：并集，包括重复

INTERSECT：交集

EXCEPT：差集

5 表达式

表达式是能够用来计算并返回值的子句。

语法：

5.1Case 表达式

Case 表达式容许用户使用 IF ... THEN ... ELSE逻辑，而不用在 SQL 语句中调用存储过程。

语法：

<case_expression> ::=

CASE <expression>

WHEN <expression> THEN <expression>, ...

[ ELSE <expression>]

{ END | END CASE }

若是位于 CASE 语句后面的表达式和 WHEN 后面的表达式相等，则 THEN 以后的表达式将做为返回值；不然返回 ELSE 语句以后的表达式，若是存在的话。

CASE后面还能够省略，省略后以下：

BEGIN

OUTTAB = SELECT CARRID, CONNID, FLDATE, BOOKID, CUSTOMID

FROM "SFLIGHT"."SBOOK"

WHERE (CASE WHEN CARRID = :IV_CARRID THEN '1'

ELSE '2' END) = '2';

END;

因为CASE WHEN性能很差，因此能够改写成下面这样：

SELECT CARRID, CONNID, FLDATE, BOOKID, CUSTOMID

FROM "SFLIGHT"."SBOOK"

WHERE CARRID <> :IV_CARRID or carrid is null

5.2Function 表达式

SQL 内置的函数能够做为表达式使用。

语法：

<function_expression> ::= <function_name> ( <expression>, ... )

5.3Aggregate 表达式

Aggregate 表达式利用 aggregate 函数计算同一列中多行值。

语法:

<aggregate_expression> ::= COUNT(*) | <agg_name> ( [ ALL | DISTINCT ] <expression>)

<agg_name> ::= COUNT | MIN | MAX | SUM | AVG | STDDEV | VAR

5.4表达式中的子查询

子查询是在括号中的 SELECT 语句。 SELECT 语句能够包含一个，有且仅有一个选择项。看成为表达式使用时，标量（只有一条结果）子查询容许返回零个或一个值。

语法：

<scalar_subquery_expression> ::= (<subquery>)

在最高级别的 SELECT 中的 SELECT 列表，或者 UPDATE 语句中的 SET 条件中，你能够在任何能使用列名的地方使用标量子查询。不过， scalar_subquery 不能够在 GROUP BY 条件中使用。

例子：

如下语句返回每一个部门中的员工数，根据部门名字分组：

SELECT DepartmentName, COUNT(*), 'out of',(SELECTCOUNT(*) FROM Employees)

FROM Departments AS D, Employees AS E WHERE D.DepartmentID = E.DepartmentID

GROUPBY DepartmentName;

6 SQL 函数

例子：

SELECT TO_CHAR (TO_DATE('2009-12-31'), 'YYYY/MM/DD') "to char"FROM DUMMY;--2009/12/31

SELECT TO_CHAR (TO_DATE('2009-12-31')) "to char"FROM DUMMY;--2009-12-31

6.1.7 TO_CLOB

语法：

TO_CLOB (value)

描述:

将 value 转换为 CLOB 类型。

例子：

SELECT TO_CLOB ('TO_CLOB converts the value to a CLOB data type') "to clob"FROM DUMMY;--TO_CLOB converts the value to a CLOB data type

6.1.8 TO_DATE

语法：

TO_DATE (d [, format])

描述：

将日期字符串 d 转换为 DATE 数据类型。若是省略 format 关键字，转换将会使用 Date Formats 中说明的日期格式模型。

例子：

SELECT TO_DATE('2010-01-12', 'YYYY-MM-DD') "to date"FROM DUMMY;--2010-1-12

6.1.9 TO_DATS

语法：

TO_DATS (d)

描述：

将字符串 d 转换为 ABAP 日期字符串，格式为”YYYYMMDD”。

例子：

SELECT TO_DATS ('2010-01-12') "abap date"FROM DUMMY;--20100112

6.1.10 TO_DECIMAL

语法：

TO_DECIMAL (value [, precision, scale])

描述：

语法：

语法：

DAYS_BETWEEN (d1, d2)

SELECT SECONDS_BETWEEN ('2015-01-01 01:01:01', '2015-01-01 01:01:02') "seconds between"FROM DUMMY;--1

6.2.28 UTCTOLOCAL

语法：

UTCTOLOCAL (t, timezone)

描述：

将 UTC 时间值转换为时区 timezone 下的本地时间。

例子：

SELECT UTCTOLOCAL(TO_TIMESTAMP('2012-01-01 01:00:00', 'YYYY-MM-DD HH24:MI:SS'), 'EST') "utctolocal"FROM DUMMY;--2011-12-31 20:00:00.0

6.2.29 WEEK

语法：

WEEK (d)

描述：

返回日期 d 所在星期的整数数字。另请参阅 ISOWEEK。

例子：

SELECTWEEK(TO_DATE('2011-05-30', 'YYYY-MM-DD')) "week"FROM DUMMY;--23

6.2.30 WEEKDAY

语法：

WEEKDAY (d)

描述：

返回表明日期 d 所在星期的日期数字（星期几）。返回值范围为 0 至 6，表示 Monday(0)至 Sunday(6)。

例子：

SELECTWEEKDAY (TO_DATE ('2011-01-02', 'YYYY-MM-DD')) "week day"FROM DUMMY;--6

SELECTWEEKDAY (TO_DATE ('2011-01-03', 'YYYY-MM-DD')) "week day"FROM DUMMY;--0

6.2.31 YEAR

语法：

YEAR (d)

语法：

语法：

语法：

LOCATE (haystack, needle)

描述：

返回字符串 haystack 中子字符串 needle 所在的位置。若是未找到，则返回 0。

例子：

SELECTLOCATE ('length in char', 'char') "locate"FROM DUMMY;--11

SELECTLOCATE ('length in char', 'length') "locate"FROM DUMMY;--1

SELECTLOCATE ('length in char', 'zchar') "locate"FROM DUMMY;--0

6.4.8 LOWER

语法：

LOWER (str)

描述：

将字符串 str 中全部字符转换为小写。

注意： LOWER 函数做用与 LCASE 相同。

例子：

SELECTLOWER ('AnT') "lower"FROM DUMMY;--ant

语法：

REPLACE (original_string, search_string, replace_string)

描述：

搜索 original_string 全部出现的 search_string，并用 replace_string 替换。

若是 original_string 为空，则返回值也为空。

若是 original_string 中两个重叠的子字符串与 search_string 匹配，只有第一个会被替换：

SELECTREPLACE ('abcbcb','bcb', '') "replace"FROM DUMMY;--acb

若是 original_string 未出现 search_string，则返回未修改的 original_string。

若是 original_string， search_string 或者 replace_string 为 NULL，则返回值也为 NULL。

例子：

SELECTREPLACE ('DOWNGRADE DOWNWARD','DOWN', 'UP') "replace"FROM DUMMY;--UPGRADE UPWARD

6.4.13 RIGHT

语法：

RIGHT(str, n)

描述：

返回字符串 str 中最右边的 n 字符/字节。

例子：

SELECTRIGHT('HI0123456789', 3) "right"FROM DUMMY;--789

6.4.14 RPAD

语法：

RPAD (str, n [, pattern])

描述：

从尾部开始对字符串 str 使用空格进行填充，达到 n 指定的长度。若是指定了 pattern 参数，字符串 str 将按顺序填充直到知足 n 指定的长度。

例子：

语法：

SUBSTRING (str, start_position [, string_length])

描述：

返回字符串 str 从 start_position 开始的子字符串。 SUBSTRING 能够返回 start_position 起的剩余部分字符或者做为可选，返回由 string_length 参数设置的字符数。

若是 start_position 小于 0，则被视为 1。

若是 string_length 小于 1，则返回空字符串。

例子：

SELECTSUBSTRING ('1234567890',4,2) "substring"FROM DUMMY;--45

6.4.19 TRIM

语法：

TRIM ([[LEADING | TRAILING | BOTH] trim_char FROM] str )

描述：

返回移除前导和后置空格后的字符串 str。截断操做从起始(LEADING)、结尾(TRAILING)或者两端(BOTH)执行。

若是 str 或者 trim_char 为空，则返回 NULL。

若是没有指定可选项， TRIM 移除字符串 str 中两端的子字符串 trim_char。

若是没有指定 trim_char，则使用单个空格（就是去空格）。

例子：

SELECTTRIM ('a'FROM'aaa123456789aa') "trim both"FROM DUMMY;--123456789

SELECTTRIM (LEADING'a'FROM'aaa123456789aa') "trim leading"FROM DUMMY;--123456789aa

6.4.20 UCASE

语法：

UCASE (str)

描述：

将字符串 str 中全部字符转换为大写。

注意： UCASE 函数做用与 UPPER 函数相同。

例子：

SELECTUCASE ('Ant') "ucase"FROM DUMMY;--ANT

6.4.21 UNICODE

语法：

UNICODE(c)

描述：

返回字符串中首字母的 UnIcode 字符码数字；若是首字母不是有效编码，则返回 NULL。

例子：

SELECT UNICODE ('江') "unicode"FROM DUMMY;--27743

SELECTNCHAR (27743) "nchar"FROM DUMMY;--江

6.4.22 UPPER

语法：

UPPER (str)

描述：

将字符串 str 中全部字符转换为大写。

注意： UPPER 函数做用与 UCASE 相同。

例子：

SELECTUPPER ('Ant') "uppercase"FROM DUMMY;--ANT

6.5杂项函数

6.5.1 COALESCE

语法：

COALESCE (expression_list)

描述：

返回 list 中非 NULL 的表达式。 Expression_list 中必须包含至少两个表达式，而且全部表达式都是可比较的。若是全部的参数都为 NULL，则结果也为 NULL。

例子：

CREATETABLE coalesce_example (ID INTPRIMARYKEY, A REAL, B REAL);

INSERTINTO coalesce_example VALUES(1, 100, 80);

INSERTINTO coalesce_example VALUES(2, NULL, 63);

INSERTINTO coalesce_example VALUES(3, NULL, NULL);

SELECT id, a, b, COALESCE (a, b*1.1, 50.0) "coalesce"FROM coalesce_example

6.5.2 CURRENT_CONNECTION

语法：

CURRENT_CONNECTION

描述：

返回当前链接 ID。

例子：

SELECT CURRENT_CONNECTION "current connection"FROM DUMMY;--400,038

6.5.3 CURRENCT_SCHEMA

语法：

CURRENT_SCHEMA

描述：

返回当前Schema名。

例子：

SELECT CURRENT_SCHEMA "current schema"FROM DUMMY;--SYSTEM

6.5.4 CURRENT_USER

语法：

CURRENT_USER

描述：

返回当前语句上下文的用户名，即当前受权堆栈顶部的用户名。

例子：

--使用SYSTEM用户执行基础SQL

SELECT CURRENT_USER "current user"FROM DUMMY;--SYSTEM

-- USER_A用户建立存储过程

CREATEPROCEDUREUSER_A.PROC1 LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS

BEGIN

SELECT CURRENT_USER "current user"FROM DUMMY;

END;

-- USER_A用户调用

CALL USER_A.PROC1;--USER_A

--受权予USER_B执行USER_A.PROC1的权限后调用

CALL USER_A.PROC1;--USER_A

--将Schema USER_A受权予USER_B用户后，经过USER_B用户建立存储过程

CREATEPROCEDUREUSER_A.PROC2 LANGUAGE SQLSCRIPT SQL SECURITY INVOKER AS

BEGIN

SELECT CURRENT_USER "current user"FROM DUMMY;

END;

-- USER_A用户调用

CALL USER_A.PROC2;-- USER_A

-- USER_B用户调用

CALL USER_A.PROC2;-- USER_B

6.5.5 GROUPING_ID

语法：

GROUPING_ID(column_name_list)

描述：

GROUPING_ID 函数可使用 GROUPING SETS 返回单个结果集中的多级汇集。 GROUPING_ID 返回一个整数识别每行所在的组集合。 GROUPING_ID 每一列必须是 GROUPING SETS 中的元素。

经过把生成的位矢量从 GROUPING SETS 转换为十进制数，将位矢量视做二进制数，分配GROUPING_ID。组成位矢量后，0 分配给 GROUPING SETS 指定的每一列，不然根据 GROUPING SETS 出现的顺序分配 1。经过将位矢量做为二进制数处理，该函数返回一个整型值做为输出。

例子：

SELECT customer, year, product, SUM(sales),GROUPING_ID(customer, year, product)

FROM guided_navi_tab

GROUPBYGROUPING SETS ((customer, year, product),(customer, year),(customer, product),(year, product),(customer),(year),(product));

CUSTOMER YEAR PRODUCT SUM(SALES) GROUPING_ID(CUSTOMER,YEAR,PRODUCT)

1 C1 2009 P1 100 0

2 C1 2010 P1 50 0

3 C2 2009 P1 200 0

4 C2 2010 P1 100 0

5 C1 2009 P2 200 0

6 C1 2010 P2 150 0

7 C2 2009 P2 300 0

8 C2 2010 P2 150 0

9 C1 2009 a 300 1

10 C1 2010 a 200 1

11 C2 2009 a 500 1

12 C2 2010 a 250 1

13 C1 a P1 150 2

14 C2 a P1 300 2

15 C1 a P2 350 2

16 C2 a P2 450 2

17 a 2009 P1 300 4

18 a 2010 P1 150 4

19 a 2009 P2 500 4

20 a 2010 P2 300 4

21 C1 a a 500 3

22 C2 a a 750 3

23 a 2009 a 800 5

24 a 2010 a 450 5

25 a a P1 450 6

26 a a P2 800 6

6.5.6 IFNULL

语法：

IFNULL (expression1, expression2)

描述：

返回输入中第一个不为 NULL 的表达式。

若是 expression1 不为 NULL，则返回 expression1。

若是 expression2 不为 NULL，则返回 expression2。

若是输入表达式都为 NULL，则返回 NULL。

例子：

SELECTIFNULL ('diff', 'same') "ifnull"FROM DUMMY;--diff

SELECTIFNULL (NULL, 'same') "ifnull"FROM DUMMY;--same

SELECTIFNULL (NULL, NULL) "ifnull"FROM DUMMY;--null

6.5.7 MAP

语法：

MAP (expression, search1, result1 [, search2, result2] ... [, default_result])

描述：

在搜索集合中搜索 expression，并返回相应的结果。

若是未找到 expression 值，而且定义了 default_result，则 MAP 返回 default_result。

若是未找到 expression 值，而且未定义 default_result，MAP 返回 NULL。

注意：

搜索值和相应的结果老是以搜索-结果方式提供。

例子：

SELECTMAP(2, 0, 'Zero', 1, 'One', 2, 'Two', 3, 'Three', 'Default') "map"FROM DUMMY;--Two

SELECTMAP(99, 0, 'Zero', 1, 'One', 2, 'Two', 3, 'Three', 'Default') "map"FROM DUMMY;--Default

SELECTMAP(99, 0, 'Zero', 1, 'One', 2, 'Two', 3, 'Three') "map"FROM DUMMY;--null

6.5.8 NULLIF

语法：

NULLIF (expression1, expression2)

描述：

NULLIF 比较两个输入表达式的值，若是第一个表达式等于第二个，NULLIF 返回 NULL。

若是 expression1 不等于 expression2，NULLIF 返回 expression1。

若是 expression2 为 NULL，NULLIF 返回 expression1。

第一个参数不能是NULL

例子：

SELECTNULLIF ('diff', 'same') "nullif"FROM DUMMY;--diff

SELECTNULLIF('same', 'same') "nullif"FROM DUMMY;--null

SELECTNULLIF('same', null) "nullif"FROM DUMMY;--same

6.5.9 SESSION_CONTEXT

语法：

SESSION_CONTEXT(session_variable)

描述：

返回分配给当前用户的 session_variable 值。

访问的 session_variable ，能够是预约义或者用户自定义。预约义的会话变量能够经过客户端设置的有'APPLICATION', 'APPLICATIONUSER'以及'TRACEPROFILE'。

会话变量能够定义或者修改经过使用命令 SET [SESSION] <variable_name> = <value>，使用 UNSET [SESSION] <variable_name>取消设置。

SESSION_CONTEXT 返回最大长度为 512 字符的 NVARCHAR 类型。

例子：

读取会话变量：

SELECT SESSION_CONTEXT('APPLICATION') "session context"FROM DUMMY;--HDBStudio

6.5.10 SESSION_USER

语法：

SESSION_USER

描述：

返回当前会话的用户名。

例子：

-- example showing basic function operation using SYSTEM user

SELECT SESSION_USER "session user"FROM DUMMY;--SYSTEM

SYSUUID

语法：

6.5.11 SYSUUID

描述：

返回 SAP HANA 链接实例的 SYSUUID。

例子：

SELECT SYSUUID FROM DUMMY;--557A323598FE12F4E20036775F49B32D

7 SQL 语句

本章描述 SAP HANA 数据库支持的 SQL 语句。

 Schema Definition and Manipulation Statements Schema操纵语句

 Data Manipulation Statements 数据操纵语句

 System Management Statements 系统管理语句

 Session Management Statements 会话管理语句

 Transaction Management Statements 事务管理语句

 Access Control Statements 访问控制语句

 Data Import Export Statements 数据导入导出语句

7.1数据定义语句

7.1.1 ALTER AUDIT POLICY

语法：

ALTER AUDIT POLICY <policy_name> <audit_mode>

语法元素：

<policy_name> ::= <identifier>

被改变的审计策略名：

<audit_mode> ::= ENABLE | DISABLE

Audit_mode 启用或禁用审计策略。

ENABLE：启用审计策略。

DISABLE：禁用审计策略。

描述：

ALTER AUDIT POLICY 语句启用或禁用审计策略。 <policy_name>必须定义一个已存在的审计策略名。

只有拥有系统权限 AUDIT ADMIN 的数据库用户容许改变审计策略。每一个拥有该权限的数据库用户能够修改任意的审计策略，不管是否由该用户建立。

新建的审计策略默认为禁用，而且不会发生任何审计。所以，必须启动该审计策略来执行审计。

审计策略能够视须要禁用和启用。

配置参数：

如下审计的配置参数存储在文件 global.ini，在审计配置部分：

global_auditing_state ( 'true' / 'false' )

不管启动的审计策略数量多少，审计只会在配置参数 global_auditing_state 设置为 true 时启用，默认值 false。

default_audit_trail_type ( 'SYSLOGPROTOCOL' / 'CSVTEXTFILE' ) 指定如何存储审计结果。

SYSLOGPROTOCOL：使用系统 syslog。

CSVTEXTFILE：审计信息值以逗号分隔存储在一个文本文件中。

default_audit_trail_path

指定 CSVTEXTFILE 存储的文件路径。

若是用户拥有须要的系统权限，参数能够在监控视图 M_INIFILE_CONTENTS 中选择。这些只有在显示设置的状况下才可见。

系统表和监控视图：

AUDIT_POLICY：显示全部审计策略和状态。

M_INIFILE_CONTENTS：显示数据库系统配置参数。

只有拥有系统权限 CATALOG READ, DATA ADMIN 或 INIFILE ADMIN 的用户能够查看

M_INIFILE_CONTENTS 视图中的内容，对于其余用户则为空。

例子：

该例子中你须要先利用以下语句建立名为 priv_audit 的审计权限：

CREATE AUDIT POLICY priv_audit AUDITING SUCCESSFUL GRANT PRIVILEGE, REVOKE PRIVILEGE, GRANT ROLE, REVOKE ROLE LEVEL CRITICAL;

如今你能够启用审计策略：

ALTER AUDIT POLICY priv_audit ENABLE;

你也能够禁用该审计策略：

ALTER AUDIT POLICY priv_audit DISABLE;

7.1.2 ALTER FULLTEXT INDEX

语法：

ALTER FULLTEXT INDEX <index_name> <alter_fulltext_index_option>

语法元素：

<index_name> ::= <identifier>

被修改的全文索引标识符：

<alter_fulltext_index_option> ::= <fulltext_parameter_list> | <queue_command> QUEUE

定义了全文索引的参数或者全文索引队列的状态是否应该修改。后者只对异步显式全文索引可见。

<fulltext_parameter_list> ::= <fulltext_parameter> [, ...]

修改的全文索引参数列表：

<fulltext_parameter> ::= FUZZY SEARCH INDEX <on_off>

| PHRASE INDEX RATIO <index_ratio>

| <change_tracking_elem>

<on_off> ::= ON | OFF

FUZZY SEARCH INDEX

使用模糊搜索索引。

PHRASE INDEX RATIO

定义短语索引比率。

<index_ratio> ::= <float_literal>

定义短语索引比率的百分比，值必须为 0.0 与 1.0 之间。

SYNC[HRONOUS]

改变全文索引至同步模式。

ASYNC[HRONOUS]

改变全文索引至异步模式。

<flush_queue_elem> ::= EVERY <integer_literal> MINUTES

| AFTER <integer_literal> DOCUMENTS

| EVERY <integer_literal> MINUTES OR AFTER <integer_literal>

DOCUMENTS

当使用异步索引时，你能够利用 flush_queue_elem 定义更新全文索引的时间。

<queue_command> ::= FLUSH | SUSPEND | ACTIVATE

FLUSH

利用正在处理队列的文件更新全文索引。

SUSPEND

暂停全文索引处理队列。

ACTIVATE

激活全文索引处理队列。

描述：

使用该命令，你能够修改全文索引的参数或者索引处理队列的状态。队列是用来激活全文索引以

异步方式工做的机制，例如插入操做被阻塞，直到文件处理完。

ALTER FULLTEXT INDEX <index_name> <fulltext_elem_list>语句修改全文索引的参数。

ALTER FULLTEXT INDEX <index_name> <queue_parameters>语句修改异步全文索引的处理队列状

态。

例子：

ALTER FULLTEXT INDEX i1 PHRASE INDEX RATIO 0.3 FUZZY SEARCH INDEX ON

在上述例子中，对于全文索引’i1’，短文索引比率设为 30,，而且启用了模糊搜索索引。

ALTER FULLTEXT INDEX i2 SUSPEND QUEUE

暂停全文索引’i2’的队列

ALTER FULLTEXT INDEX i2 FLUSH QUEUE

利用队列中已处理的文件更新全文索引’i2’。

7.1.3 ALTER INDEX

ALTER INDEX <index_name> REBUILD

语法元素：

<index_name>::= <identifier>

定义重建的索引名。

描述：

ALTER INDEX 语句重建索引。

例子：

如下例子重建索引 idx。

ALTER INDEX idx REBUILD;

7.1.4 ALTER SEQUENCE

语法：

ALTER SEQUENCE <sequence_name> [<alter_sequence_parameter_list>]

[RESET BY <reset_by_subquery>]

语法元素：

<sequence_name> ::= <identifier>

被修改的序列名。

<alter_sequence_parameter_list> ::= <alter_sequence_parameter>, ...

<alter_sequence_parameter> ::= <sequence_parameter_restart_with>

| <basic_sequence_parameter>

<sequence_parameter_restart_with> ::= RESTART WITH <restart_value>

<basic_sequence_parameter> ::= INCREMENT BY <increment_value>

| MAXVALUE <maximum_value>

| NO MAXVALUE

| MINVALUE <minimum_value>

| NO MINVALUE

| CYCLE

| NO CYCLE

RESTART WITH

序列的起始值。若是你没有指定 RESTART WITH 子句的值，将使用当前序列值。

<restart_value> ::= <integer_literal>

由序列生成器提供的第一个值为 0 至 4611686018427387903 之间的整数。

INCREMENT BY

序列增量值。

<increment_value> ::= <integer_literal>

利用一个整数增长或者减小序列的值。

MAXVALUE

定义序列生成的最大值。

<maximum_value> ::= <integer_literal>

一个正整数定义序列可生成的最大数值，必须为 0 至 4611686018427387903 之间。

NO MAXVALUE

使用 NO MAXVALUE 指令，递增序列的最大值将为 4611686018427387903，递减序列的最大值为-1。

MINVALUE

定义序列生成的最小值。

<minimum_value> ::= <integer_literal>

一个正整数定义序列可生成的最小数值，必须为 0 至 4611686018427387903 之间。

NO MINVALUE

使用 NO MINVALUE 指令，递增序列的最小值将为 1，递减序列的最小值为-

4611686018427387903。

CYCLE

使用 CYCLE 指令，序列在到达最大值或最小值后将会从新开始。

NO CYCLE

使用 NO CYCLE 指令，序列在到达最大值或最小值后将不会从新开始。

<reset_by_subquery> ::= <subquery>

系统重启期间，系统自动执行 RESET BY 语句，而且将用 RESET BY 子查询肯定的值重启序列。

关于子查询的详情，请参阅 Subquery。

描述：

ALTER SEQUENCE 语句用来修改序列生成器的参数。

例子：

在下面的例子中，你把序列 seq 的起始序列值改成 2。

ALTER SEQUENCE seq RESTART WITH 2;

在下面的例子中，你把序列 seq 的最大值改成 100，而且没有最小值。

ALTER SEQUENCE seq MAXVALUE 100 NO MINVALUE;

在下面的例子中，你把序列 seq 的增量改成 2，而且限制为"no cycle"。

ALTER SEQUENCE seq INCREMENT BY 2 NO CYCLE;

在下面的例子中，你首先建立表 r，有一列 a。而后你将序列 seq 的 reset-by 子查询修改成列 a 包

含的最大值。

CREATE TABLE r (a INT);

ALTER SEQUENCE seq RESET BY SELECT MAX(a) FROM r;

7.1.5 ALTER TABLE

语法：

ALTER TABLE [<schema_name>.]<table_name>{

<add_column_clause>

| <drop_column_clause>

| <alter_column_clause>

| <add_primary_key_clause>

| <drop_primary_key_clause>

| <preload_clause>

| <table_conversion_clause>

| <move_clause>

| <add_range_partition_clause>

| <move_partition_clause>

| <drop_range_partition_clause>

| <partition_by_clause>

| <disable_persistent_merge_clause>

| <enable_persistent_merge_clause>

| <enable_delta_log>

| <disable_delta_log>

| <enable_automerge>

| <disable_automerge>

}

语法元素：

<add_column_clause> ::= ADD ( <column_definition> [<column_constraint>], ...)

<drop_column_clause> ::= DROP ( <column_name>, ... )

<alter_column_clause> ::= ALTER ( <column_definition> [<column_constraint>], ... )

<column_definition> ::= <column_name> <data_type> [<column_store_data_type>][<ddic_data_type>] [DEFAULT <default_value>] [GENERATED ALWAYS AS <expression>]

<default_value> ::= NULL | <string_literal> | <signed_numeric_literal> | <unsigned_numeric_literal>

DEFAULT：DEFAULT 定义了 INSERT 语句没有为列提供值状况下，默认分配的值。

GENERATED ALWAYS AS：指定在运行时生成的列值的表达式。

NULL | NOT NULL：NOT NULL 禁止列的值为 NULL。若是指定了 NULL，将不被认为是常量，其表示一列可能含有空值，默认为 NULL。

UNIQUE：指定为惟一键的列。一个惟一的复合键指定多个列做为惟一键。有了 unique 约束，多行不能在同一列中具备相同的值。

PRIMARY KEY：主键约束是 NOT NULL 约束和 UNIQUE 约束的组合，其禁止多行在同一列中具备相同的值。

BTREE | CPBTREE：指定索引类型。当列的数据类型为字符串、二进制字符串、十进制数或者约束是一个组合键，或非惟一键，默认的索引类型为 CPBTREE，不然

使用 BTREE。

为了使用 B+-树索引，必须使用 BTREE 关键字；对于 CPB+-树索引，需使用 CPBTREE 关键字。

B+-树是维护排序后的数据进行高效的插入、删除和搜索记录的树。

CPB+-树表示压缩前缀 B+-树，是基于 pkB-tree 树。 CPB+树是一个很是小的索引，由于它使用“部分键”，只是索引节点所有键的一部分。对于更大的键，

CPB+-树展示出比 B+-树更好的性能。

若是省略了索引类型， SAP HANA 数据库将考虑列的数据类型选择合适的索引。

ALTER时，增长一列的长度是能够作到的。当在列式存储中尝试修改列的定义，不会返回错误，由于在数据库中没有作任何的检查。错误可能发生在选择列时，数据不符合新定义的数据类型。 ALTER 仍未遵守数据类型转换规则。

将 NOT NULL 约束添加到已存在的列是能够的，若是表为空或者表有数据时定义了默认值

<add_primary_key_clause> ::= ADD [CONSTRAINT <constraint_name>] PRIMARY KEY( <column_name>, ... )

ADD PRIMARY KEY：增长一列主键。

PRIMARY KEY：主键约束是 NOT NULL 约束和 UNIQUE 约束的组合，其禁止多行在同一列中具备相同的值。

CONSTRAINT：指定约束名。

<drop_primary_key_clause> ::= DROP PRIMARY KEY

DROP PRIMARY KEY：删除主键约束。

<preload_clause> ::= PRELOAD ALL | PRELOAD ( <column_name> ) | PRELOAD NONE

PRELOAD：设置/移除给定表或列的预载标记。 PRELOAD ALL 为表中全部列设置预载标记， PRELOAD( <column_name> )为指定的列设置标记， PRELOAD NONE 移除

全部列的标记。其结果是这些表在索引服务器启动后自动加载至内存中。预载标记的当前状态在系统表 TABLES，列 PRELOAD 中可见，可能值为('FULL', 'PARTIALLY',

'NO')；在系统表 TABLE_COLUMNS，列 PRELOAD,可能值为('TRUE','FALSE')。

<table_conversion_clause> ::= [ALTER TYPE] {ROW [THREADS <number_of_threads>] | COLUMN[THREADS <number_of_threads> [BATCH <batch_size>]]}

ALTER TYPE ROW | COLUMN：该命令用于将表存储类型从行转换为列或从列转换为行。

THREADS <number_of_threads>：指定进行表转换的并行线程数。线程数目的最佳值应设置为可用的 CPU 内核的数量。

Default：默认值为 param_sql_table_conversion_parallelism，即在 ndexserver.ini 文件中定义的 CPU内核数。

BATCH <batch_size>：指定批插入的行数，默认值为最佳值 2,000,000。插入表操做在每一个<batch_size>记录插入后当即提交，能够减小内存消耗。 BATCH 可选项只

能够在表从行转换为列时使用。然而，大于 2,000,000的批大小可能致使高内存消耗，所以不建议修改该值。经过复制现有的表中的列和数据，能够从现有的表

建立一个不一样存储类型的新表。该命令用来把表从行转换为列或从列转换为行。若是源表是行式存储，则新建的表为列式存储。

<move_clause> ::= MOVE [PARTITION <partition_number>] TO [LOCATION ]<host_port> [PHYSICAL] |MOVE [PARTITION <partition_number>] PHYSICAL

MOVE 将表移动至分布式环境中的另外一个位置。端口号是内部索引服务器的端口号， 3xx03。若是你有一个分区表，你能够经过指定可选的分区号只移动个别部

分，移动分区表时，没有指定分区号会致使错误。

PHYSICAL 关键字只适用列式存储表。行式存储表老是物理移动。若是指定了可选关键字 PHYSICAL，持久存储当即移动至目标主机。不然，此举将建立一个新主机

里面的持久层连接指向旧主机持久层。该连接若是没有 TO<host_port>部分，将在下次合并或者移动中删除。PHYSICAL 移动操做没有指定 TO <host_port>时，将移

除从上次移动中仍然存在的持久层连接。

LOCATION 仅支持向后兼容

<add_range_partition_clause> ::= ADD PARTITION <lower_value> <= VALUES < <upper_value>| PARTITION <value_or_values> = <target_value>| PARTITION OTHERS

ADD PARTITION：为一个分区表添加分区，使用 RANGE, HASH RANGE, ROUNDROBIN RANGE 关键字。当添加分区至一张按范围分区的表时，若是须要的话，能够对

其他分区进行从新分区。

<drop_range_partition_clause> ::= DROP PARTITION <lower_value> <= VALUES < <upper_value>| PARTITION <value_or_values> = <target_value>| PARTITION OTHERS

DROP PARTITION：删除根据 RANGE, HASH RANGE, ROUNDROBIN RANGE 分区的表的分区。

<partition_clause> ::= PARTITION BY <hash_partition> [,<range_partition> | ,<hash_partition>]| PARTITION BY <range_partition>| PARTITION BY <roundrobin_partition>

[,<range_partition>]

<hash_partition> ::=HASH (<partition_expression>[, ...]) PARTITIONS { <num_partitions> |GET_NUM_SERVERS() }

<range_partition> ::= RANGE ( <partition_expression> ) ( <range_spec> )

<roundrobin_partition> ::= ROUNDROBIN PARTITIONS {<num_partitions> |GET_NUM_SERVERS()}

<range_spec> ::= {<from_to_spec> | <single_spec>[,...] } [, PARTITION OTHERS]

<from_to_spec> ::= PARTITION <lower_value> <= VALUES < <upper_value>

<single_spec> ::= PARTITION VALUE <single_value>

<partition_expression> ::= <column_name>| YEAR(<column_name>) | MONTH(<column_name>)

PARTITION BY：使用 RANGE, HASH RANGE, ROUNDROBIN RANGE 对表进行分区。关于表分区自居，请参见 CREATE TABLE。

<merge_partition_clause> ::= MERGE PARTITIONS

MERGE PARTITIONS：合并分区表的全部部分至非分区表。

<disable_persistent_merge_clause> ::= DISABLE PERSISTENT MERGE

DISABLE PERSISTENT MERGE：指导合并管理器对于给定表，使用内存进行合并而非持久合并。

<enable_persistent_merge_clause> ::= ENABLE PERSISTENT MERGE

ENABLE PERSISTENT MERGE：指导合并管理器对于给定表使用持久合并。

<enable_delta_log> ::= ENABLE DELTA LOG

启动表日志记录。启用以后，你必须执行一个保存点以确保全部的数据都保存，而且你必须执行数据备份，不然你不能恢复这些数据。

<enable_delta_log> ::= DISABLE DELTA LOG

DISABLE DELTA LOG：禁用表日志记录。若是禁用，不会记录该表的日志。当完成一个保存点对于该表的修改只会写到数据域，这会致使当索引服务器终止时，提

交的事务丢失。

仅在初次加载中使用该命令！

<enable_delta_log> ::= ENABLE AUTOMERGE

指导合并管理器处理表。

<enable_delta_log> ::= DISABLE AUTOMERGE

DISABLE AUTOMERGE：指导合并管理器忽略该表。

例子：

表 t 已建立，列 b 的默认值设为 10。

CREATETABLE t (a INT, b INT);

ALTERTABLE t ALTER (b INTDEFAULT 10);

列 c 添加至表 t。

ALTERTABLE t ADD (c NVARCHAR(10) DEFAULT'NCHAR');

建立表 t 的主键约束 prim_key。

ALTERTABLE t ADDCONSTRAINT prim_key PRIMARYKEY (a, b);

表 t 类型转换为列式 (COLUMN)。

ALTERTABLE t COLUMN;

设置列 b 和 c 的预载标记

ALTERTABLE t PRELOAD (b, c);

表 t 使用 RANGE 分区，而且添加另外一分区。

ALTERTABLE t PARTITIONBY RANGE (a) (PARTITIONVALUE = 1, PARTITION OTHERS);

ALTERTABLE t ADDPARTITION 2 <= VALUES < 10;

表 t 的会话类型改成 HISTORY

ALTERTABLE t CREATEHISTORY;

禁用表 t 的日志记录。

ALTERTABLE t DISABLEDELTALOG;

7.1.6 CREATE AUDIT POLICY

语法：

CREATE AUDIT POLICY <policy_name> AUDITING <audit_status_clause> <audit_action_list> LEVEL <audit_level>

语法元素：

<audit_status_clause> ::= SUCCESSFUL | UNSUCCESSFUL | ALL

<audit_action_list> ::= <audit_action_name>[,<audit_action_name>]...

<audit_level> ::=EMERGENCY| ALERT| CRITICAL| WARNING| INFO

描述：

CREATE AUDIT POLICY 语句建立新的审计策略。该审计策略能够稍后启动，并将致使指定的审计活动发生的审计。

只有拥有系统权限 AUDIT ADMIN 用户才能够新建审计策略。

指定的审计策略名必须和已有的审计策略名不一样。

审计策略定义将被审计的审计活动。现有的审计策略须要被激活，从而进行审计。

<audit_status_clause>定义，成功或不成功或执行指定的审计活动进行审核。

如下的审计活动是可供使用的。它们被分在不一样的组里。一组审计活动能够组合成一个审计策略，不一样组的审计行动不能组合成审计策略。

GRANT PRIVILEGE                                           1              审计授予用户或角色的权限
REVOKE PRIVILEGE                                          1              审计撤销用户或角色的权限
GRANT STRUCTURED PRIVILEGE               1              审计授予用户的结构/分析权限
REVOKE STRUCTURED PRIVILEGE              1              审计撤销用户的结构/分析权限
GRANT ROLE                                                      1              审计授予用户或角色的角色
REVOKE ROLE                                                    1              审计撤销用户或角色的角色
GRANT ANY                                                        1              审计授予用户或角色的权限、结构/分析权限或角色
REVOKE ANY                                                      1              审计撤销用户或角色的权限、结构/分析权限或角色
CREATE USER                                                     2              审计用户建立
DROP USER                                                         2             审计用户删除
CREATE ROLE                                                     2              审计角色建立
DROP ROLE                                                         2              审计角色删除
CONNECT                                                            3              审计链接到数据库的用户
SYSTEM CONFIGURATION CHANGE         4              审计系统配置的更改(e.g. INIFILE)
ENABLE AUDIT POLICY                                   5              审计审核策略激活
DISABLE AUDIT POLICY                                  5             审计审核策略停用
CREATE STRUCTURED PRIVILEGE               6             审计结构化/分析权限建立
DROP STRUCTURED PRIVILEGE                  6              审计结构化/

ALTER STRUCTURED PRIVILEGE                  6              审计结构化/分析权限更改
SET SYSTEM LICENSE                                       7              审计许可证安装
UNSET SYSTEM LICENSE                                7              审计许可证删除

每个审计分配分配至审计级别，可能的值按照重要性递减有：EMERGENCY, ALERT, CRITICAL, WARNING, INFO

为了使得审计活动发生，审计策略必须创建并启动， global_auditing_state（见下文）必须设置为true。

配置参数：

目前，审计的配置参数存储在 global.ini，部分审计配置以下：

global_auditing_state ( 'true' / 'false' )激活/关闭全部审计，不管有多少审计策略可用和启动。默认为 false，表明没有审计会发生。

default_audit_trail_type ( 'SYSLOGPROTOCOL' / 'CSVTEXTFILE' )定义如何存储审计结果。

SYSLOGPROTOCOL 为默认值。

CSVTEXTFILE 应只用于测试目的。

default_audit_trail_path 指定存储文件的位置， CSVTEXTFILE 已经选定的状况下。

对于全部的配置参数，能够在视图 M_INIFILE_CONTENTS 中选择，若是当前用户具备这样作所需的权限。可是目前这些参数只有在被显式设置后才可见。这意味着，它们将对新安装的数据库实例不可见。

系统和监控视图

AUDIT_POLICY：显式全部审计策略和其状态

M_INIFILE_CONTENTS：显示审计有关的配置参数

只有数据库用户具备 CATALOG READ, DATA ADMIN 或 INIFILE ADMIN 权限能够在视图M_INIFILE_CONTENTS 查看任意信息，对于其余用户，该视图为空。

例子

新建的名为 priv_audit 的审计策略将审计有关成功授予和撤销权限和角色的命令，该审计策略有中等审计级别 CRITICAL.。

该策略必须显式启动(见 alter_audit_policy)，使得审计策略的审计发生。

CREATEAUDIT POLICY priv_audit AUDITING SUCCESSFUL GRANT PRIVILEGE, REVOKE PRIVILEGE, GRANT ROLE, REVOKE ROLE LEVEL CRITICAL;

7.1.7 CREATE FULLTEXT INDEX

语法：

CREATE FULLTEXT INDEX <index_name> ON <tableref> '(' <column_name> ')' [<fulltext_parameter_list>]

定义全文索引名：

<fulltext_parameter_list> ::= <fulltext_parameter> [, ...]

<fulltext_parameter> ::= LANGUAGE COLUMN <column_name>

| LANGUAGE DETECTION '(' <string_literal_list> ')'

| MIME TYPE COLUMN <column_name>

| <change_tracking_elem>

| FUZZY SEARCH INDEX <on_off>

| PHRASE INDEX RATIO <on_off>

| CONFIGURATION <string_literal>

| SEARCH ONLY <on_off>

| FAST PREPROCESS <on_off>

<on_off> ::= ON | OFF

LANGUAGE COLUMN：指定文件语言的列

LANGUAGE DETECTION：语言检测设置的语言集合。

MIME TYPE COLUMN：指定文件 mime-type 的列

FUZZY SEARCH INDEX：指定是否使用模糊搜索

PHRASE INDEX RATIO：指定短语索引比率的百分比，值必须为 0.0 和 1.0 之间。

CONFIGURATION：自定义配置文件的文本分析路径。

SEARCH ONLY：若是设为 ON，将不存储原始文件内容。

FAST PREPROCESS：若是设为 ON，将使用快速处理，例如语言搜索将不可用。

<change_tracking_elem> ::= SYNC[HRONOUS]| ASYNC[HRONOUS] [FLUSH [QUEUE]<flush_queue_elem>]

SYNC：指定是否建立同步全文索引

ASYNC：指定是否建立异步全文索引

<flush_queue_elem> ::= EVERY <integer_literal> MINUTES| AFTER <integer_literal> DOCUMENTS| EVERY <integer_literal> MINUTES OR AFTER <integer_literal> DOCUMENTS

指定若是使用异步索引，更新全文索引的时机。

描述：

CREATE FULLTEXT INDEX 语句对给定表建立显式全文索引。

例子：

CREATE FULLTEXT INDEX i1 ON A(C) FUZZY SEARCH INDEXOFF

SYNC

LANGUAGE DETECTION ('EN','DE','KR')

上面的例子在表 A 的列 C 建立名为‘i1’的全文索引，未使用模糊搜索索引，语言检测设置的语言集合由'EN','DE' 和 'KR'组成。

7.1.8 CREATE INDEX

语法：

CREATE [UNIQUE] [BTREE | CPBTREE] INDEX [<schema_name>.]<index_name> ON <table_name>(<column_name_order>, ...) [ASC | DESC]

语法元素：

<column_name_order> ::= <column_name> [ASC | DESC]

UNIQUE：用来建立惟一性索引。当建立索引和记录添加到表中将进行重复检查。

BTREE | CPBTREE：用来选择使用的索引类型。当列的数据类型为字符串、二进制字符串、十进制数或者约束是一个组合键，或非惟一键，默认的索引类型为 CPBTREE，不然使用 BTREE。

为了使用 B+-树索引，必须使用 BTREE 关键字；对于 CPB+-树索引，需使用 CPBTREE 关键字。

B+-树是维护排序后的数据进行高效的插入、删除和搜索记录的树。

CPB+-树表示压缩前缀 B+-树，是基于 pkB-tree 树。 CPB+树是一个很是小的索引，由于它使用“部分键”，只是索引节点所有键的一部分。对于更大的键， CPB+-树展示出比 B+-树更好的性能。

若是省略了索引类型， SAP HANA 数据库将考虑列的数据类型选择合适的索引。

ASC | DESC：指定以递增或递减方式建立索引。

这些关键字只能在 btree 索引使用，而且对每一列只能使用一次。

描述：

CREATE INDEX 语句建立索引。

例子：

表 t 建立后，以递增方式对表 t 的 b 列建立 CBPTREE 索引 idx。

CREATETABLE t (a INT, b NVARCHAR(10), c NVARCHAR(20));

CREATEINDEX idx ON t(b);

以递增方式对表 t 的 a 列建立 CBPTREE 索引 idx，以递减顺序对 b 列建立：

CREATE CPBTREE INDEX idx1 ON t(a, b DESC);

以递减方式对表 t 的 a 列和 c 列建立 CPBTREE 索引 idx2。

CREATEINDEX idx2 ON t(a, c) DESC;

以递增顺序对表 t 的 b 列和 c 列建立惟一性 CPBTREE 索引 idx3。

CREATEUNIQUEINDEX idx3 ON t(b, c);

以递增顺序对表 t 的 a 列建立惟一性 BTREE 索引 idx4。

CREATEUNIQUEINDEX idx4 ON t(a);

7.1.9 CREATE SCHEMA

语法：

CREATE SCHEMA <schema_name> [OWNED BY <user_name>]

OWNED BY：指定Schema全部者名字。若是省略，当前用户将为Schema全部者。

描述：

CREATE SCHEMA 语句在当前数据库建立Schema。

例子：

CREATESCHEMA my_schema OWNED BYsystem;

7.1.10 CREATE SEQUENCE

语法：

CREATE SEQUENCE <sequence_name> [<common_sequence_parameter_list>] [RESET BY <subquery>]

语法元素：

<common_sequence_parameter_list> ::= <common_sequence_parameter>, ...

<common_sequence_parameter> ::= START WITH n | <basic_sequence_parameter>

INCREMENT BY：定义上个分配值递增到下一个序列值的量（即递增递减间隔值），默认值为 1。指定一个负的值来生成一个递减的序列。 INCREMENT BY 值为 0，将返回错误。

START WITH：定义起始序列值。若是未定义 START WITH 子句值，递增序列将使用 MINVALUE，递减序列将使用MAXVALUE。

MAXVALUE：定义序列可生成的最大数值，必须为 0 至 4611686018427387903 之间。

NO MAXVALUE：使用 NO MAXVALUE 指令，递增序列的最大值将为 4611686018427387903，递减序列的最大值为-1。

MINVALUE：定义序列可生成的最小数值，必须为 0 至 4611686018427387903 之间。

NO MINVALUE：使用 NO MINVALUE 指令，递增序列的最小值将为 1，递减序列的最小值为-4611686018427387903。

CYCLE：使用 CYCLE 指令，序列在到达最大值或最小值后将会从新开始。

NO CYCLE：使用 NO CYCLE 指令，序列在到达最大值或最小值后将不会从新开始。

RESET BY：系统重启期间，系统自动执行 RESET BY 语句，而且将用 RESET BY 子查询肯定的值重启序列。

若是未指定 RESET BY，序列值将持久地存储在数据库中。在数据库重启过程当中，序列的下一个值将由已保存的序列值生成。

描述：

CREATE SEQUENCE 语句用来建立序列。

序列用来为多个用户生成惟一整数。 CURRVAL 用来获取序列的当前值，NEXTVAL 则用来获取序列的下一个值。 CURRVAL 只有在会话中调用 NEXTVAL 才有效。

例子：

例子 1：

序列 seq 已建立，使用 CURRVAL 和 NEXTVAL 从序列中读取值。

CREATESEQUENCE seq START WITH 11;

NEXTVAL 返回 11:

SELECT seq.NEXTVAL FROM DUMMY;--11

CURRVAL 返回 11:

SELECT seq.CURRVAL FROM DUMMY;--11

例子 2：

若是序列用来在表 R 的 A 列上建立惟一键，在数据库重启后，经过自动分配列 A 的最大值到序列，建立一个惟一键值，语句以下：

CREATETABLE r (a INT);

CREATESEQUENCE s RESETBYSELECTIFNULL(MAX(a), 0) + 1 FROM r;

SELECT s.NEXTVAL FROM DUMMY;--1

7.1.11 CREATE SYNONYM

语法：

CREATE [PUBLIC] SYNONYM <synonym_name> FOR <object_name>

语法元素：

<object_name> ::= <table_name>| <view_name>| <procedure_name>| <sequence_name>

描述：

CREATE SYNONYM 为表、视图、存储过程或者序列建立备用名称。

你可使用同义词把函数和存储过程从新指向不一样的表、视图或者序列，而不须要重写函数或者过程。

可选项 PUBLIC 容许建立公用同义词。任何用户能够访问公用同义词，但只有拥有基本对象合适权限的用户能够访问基本对象。

例子：

CREATESYNONYM t_synonym FOR t;

7.1.12 CREATE TABLE

语法：

CREATE [<table_type>] TABLE [<schema_name>.]<table_name> <table_contents_source>[<logging_option> | <auto_merge_option> | <partition_clause> | <location_clause>]

语法元素：

<table_type> ::= COLUMN| ROW| HISTORY COLUMN| GLOBAL TEMPORARY| LOCAL TEMPORARY

COLUMN, ROW：若是大多数的访问是经过大量元组，而只选择少数几个属性，应使用基于列的存储。若是大多数访问选择一些记录的所有属性，使用基于行的存储是最好的。 SAP HANA 数据库使用组合启用两种方式的的存储和解释。你能够为每张表指定组织类型，默认值为 ROW。

HISTORY COLUMN：利用特殊的事务会话类型称为’HISTORY’建立表。具备会话类型’HISTORY’的表支持“时间旅行”，对历史状态的数据库查询的执行是可能的。

时间旅行能够以以下方式完成：

会话级别时间旅行：

SET HISTORY SESSION TO UTCTIMESTAMP = <utc_timestamp>

SET HISTORY SESSION TO COMMIT ID = <commit_id>

<utc_timestamp> ::= <string_literal>

<commit_id> ::= <unsigned_integer>

数据库会话能够设置回到一个特定时间点。该语句的 COMMIT ID 变量接受 commitid 做为参数。commitid 参数的值必须存在系统表 SYS.TRANSACTION_HISTORY 的 COMMIT_ID 列，不然将抛出异常。 COMMIT_ID 在使用用户定义的快照时是有用的。用户自定义的快照能够经过存储在提交阶段分配至事务的 commitid 来得到。 Commitid 能够经过在事务提交后执行如下查询来读取：

SELECT LAST_COMMIT_ID FROM M_TRANSACTIONS WHERE CONNECTION_ID = CURRENT_CONNECTION;

该语句的 TIMESTAMP 变量接受时间戳做为参数。在系统内部，时间戳用来在系统表SYS.TRANSACTION_HISTORY，commit_time 接近给定的时间戳的地方，查询一对(commit_time,commit_id)，准确的说，选择最大 COMMIT_TIME 小于等于给定时间戳的对；若是没有找到这样的对，将会抛出异常。而后会话将使用 COMMIT_ID 变量肯定的 commit-id 恢复。要终止恢复会话切换到当前会话中，必须在数据库链接上执行明确的 COMMIT 或 ROLLBACK。

语句级别时间旅行：

<subquery> AS OF UTCTIMESTAMP <utc_timestamp>

<subquery> AS OF COMMIT ID <commit_id>

为了能使 commitid 与提交时间关联，需维护系统表 SYS.TRANSACTION_HISTORY，存储每一个为历史表提交数据的事务的额外信息。有关设置会话级别时间旅行的详细信息，请参阅 SET HISTORY SESSION，关于<subquery>的信息，请参阅 Subquery。

注意：

当会话恢复时，自动提交必须关闭（不然会抛出包含相应错误消息的异常）。

非历史表在恢复会话中总显示其当前快照。

只有数据查询语句(select)能够在恢复会话中使用。

历史表必须有主键。

会话类型能够经过系统表 SYS.TABLES 的 SESSION_TYPE 列检查。

GLOBAL TEMPORARY：

表定义全局可见，但数据只在当前会话中可见。表在会话结束后截断。

全局临时表的元数据是持久的，表示该元数据一直存在直到表被删除，元数据在会话间共享。临时表中的数据是会话特定的，表明只有全局临时表的全部者才容许插入、读取、删除数据，存在于会话持续期间，而且当会话结束时，全局临时表中的数据会自动删除。全局临时表只有当表中没有任何数据才能被删除。全局临时表支持的操做：

1. Create without a primary key

2. Rename table

3. Rename column

4. Truncate

5. Drop

6. Create or Drop view on top of global temporary table

7. Create synonym

8. Select

9. Select into or Insert

10. Delete

11. Update

12. Upsert or Replace

LOCAL TEMPORARY：

表的定义和数据只在当前会话可见，该表在会话结束时被截断。

元数据在会话间共享，而且是会话特定的，表明只有本地临时表的全部者才容许查看。临时表中的数据是会话特定的，表明只有本地临时表的全部者才容许插入、读取、删除数据，存在于会话持续期间，而且当会话结束时，本地临时表中的数据会自动删除。

本地临时表支持的操做：

1. Create without a primary key

2. Truncate

3. Drop

4. Select

5. Select into or Insert

6. Delete

7. Update

8. Upsert or Replace

<table_contents_source> ::= (<table_element>, ...)| <like_table_clause> [WITH [NO] DATA]| [(<column_name>, ...)] <as_table_subquery> [WITH [NO] DATA]]

<table_element> ::= <column_definition> [<column_constraint>]| <table_constraint> (<column_name>, ... )

<column_definition> ::= <column_name> <data_type> [<column_store_data_type>] [<ddic_data_type>][DEFAULT <default_value>] [GENERATED ALWAYS AS

<expression>]

<default_value> ::= NULL | <string_literal> | <signed_numeric_literal>| <unsigned_numeric_literal>

DEFAULT：DEFAULT 定义了 INSERT 语句没有为列提供值状况下，默认分配的值。

GENERATED ALWAYS AS：指定在运行时生成的列值的表达式。

NULL | NOT NULL：NOT NULL 禁止列的值为 NULL。若是指定了 NULL，将不被认为是常量，其表示一列可能含有空值，默认为 NULL。

UNIQUE：指定为惟一键的列。一个惟一的复合键指定多个列做为惟一键。有了 unique 约束，多行不能在同一列中具备相同的值。

PRIMARY KEY：主键约束是 NOT NULL 约束和 UNIQUE 约束的组合，其禁止多行在同一列中具备相同的值。

BTREE | CPBTREE：指定索引类型。当列的数据类型为字符串、二进制字符串、十进制数或者约束是一个组合键，或非惟一键，默认的索引类型为 PBTREE，

不然使用 BTREE。为了使用 B+-树索引，必须使用 BTREE 关键字；对于 CPB+-树索引，需使用 CPBTREE 关键字。B+-树是维护排序后的数据进行高效的插入、删除和搜索记录的树。CPB+-树表示压缩前缀 B+-树，是基于 pkB-tree 树。 CPB+树是一个很是小的索引，由于它使用“部分键”，只是索引节点所有键的一部分。对于更大的键， CPB+-树展示出比 B+-树更好的性能。若是省略了索引类型， SAP HANA 数据库将考虑列的数据类型选择合适的索引。

<table_constraint> ::= UNIQUE [BTREE | CPBTREE]| PRIMARY KEY [BTREE | CPBTREE]

定义了表约束可使用在表的一列或者多列上。

<like_table_clause> ::= LIKE <table_name>

建立与 like_table_name 定义相同的表。表中全部列的定义和默认值拷贝自 like_table_name。当提供了可选项 WITH DATA，数据将从指定的表填充，不过，默认值为 WITH NO DATA。

<as_table_subquery> ::= AS '(<subquery>)

建立表而且用<subquery>计算的数据填充。使用该子句只拷贝 NOT NULL 约束。若是指定了column_names，该指定的 column_names 将覆盖<subquery>中的列名。WITH [NO] DATA 指定数据拷贝自<subquery> 或 <like_table_clause>。

<logging_option> ::= LOGGING| NO LOGGING [RETENTION <retention_period>]

<retention_period> ::= <unsigned_integer>

LOGGING | NO LOGGING：LOGGING (默认值)指定激活记录表日志。NO LOGGING 指定停用记录表日志。一张 NO LOGGING 表意味表定义是持久的且全局可见的，数据则为临时和全局的。

RETENTION：指定以秒为单位，NO LOGGING 列式表的保留时间。在指定的保留期限已过，若是使用物理内存的主机达到 80%，上述表将被删除。

<auto_merge_option> ::= AUTO MERGE | NO AUTO MERGE

AUTO MERGE | NO AUTO MERGE：AUTO MERGE (默认值)指定触发自动增量合并。

<partition_clause> ::= PARTITION BY <hash_partition> [, <range_partition> | , <hash_partition>]| PARTITION BY <range_partition>| PARTITION BY <roundrobin_partition>

[,<range_partition>]

<hash_partition> ::= HASH (<partition_expression> [, ...]) PARTITIONS {<num_partitions> |GET_NUM_SERVERS()}

<range_partition> ::= RANGE (<partition_expression>) (<range_spec>, ...)

<roundrobin_partition> ::= ROUNDROBIN PARTITIONS {<num_partitions> | GET_NUM_SERVERS()} [,<range_partition>]

<range_spec> ::= {<from_to_spec> | <single_spec>} [, ...] [, PARTITION OTHERS]

<from_to_spec> ::= PARTITION <lower_value> <= VALUES < <upper_value>

<single_spec> ::= PARTITION VALUE <target_value>

<lower_value> ::= <string_literal> | <numeric_literal>

<upper_value> ::= <string_literal> | <numeric_literal>

<target_value> ::= <string_literal> | <numeric_literal>

<partition_expression> ::= <column_name> | YEAR(<column_name>) | MONTH(<column_name>)

<num_partitions> ::= <unsigned_integer>

GET_NUM_SERVERS()函数返回服务器数量。

PARTITION OTHERS 表示分区定义中未指定的其他值成为一个分区。

肯定分区建立所在的索引服务器是可能的。若是你指定了 LOCATION，在这些实例中循环建立分区。列表中的重复项将被移除。若是你在分区定义中精确指定实例数为分区数，则每一个分区将分配至列表中各自实例。全部索引列表中的服务器必须属于同一个实例。若是指定了 no location，将随机建立分区。若是分区数与服务器数匹配-例如使用

GET_NUM_SERVERS()-能够确保多个 CREATE TABLE 调用以一样的方式分配分区。对于多级别分区的状况，其适用于第一级的分区数。这个机制是颇有用的，若是建立彼此语义相关的多张表。

<location_clause> ::= AT [LOCATION] {'<host>:<port>' | ('<host>:<port>', ...)}

AT LOCATION：表能够建立在 host:port 指定的位置，位置列表能够在建立分配至多个实例的分区表时定义。当位置列表没有提供<partition_clause>，表将建立至指定的第一个位置中。若是没有提供位置信息，表将自动分配到一个节点中。此选项可用于在分布式环境中的行存储和列存储表

描述：

CREATE TABLE 建立一张表。表中未填充数据，除了当<as_table_subquery> 或 <like_table_clause>和WITH DATA 可选项一块儿使用。

例子：

建立了表 A，整数列 A 和 B。列 A 具备主键约束。

CREATETABLE A (A INTPRIMARYKEY, B INT);

建立了分区表 P1，日期列 U。列 U 具备主键约束而且做为 RANGE 分区列使用。

CREATECOLUMNTABLE P1 (U DATEPRIMARYKEY) PARTITIONBY RANGE (U) (PARTITION'2010-02-03'<= VALUES < '2011-01-01', PARTITIONVALUE = '2011-05-01');

建立了分区表 P2，整数列 I，J 和 K。列 I，J 组成键约束，而且做为哈希分区列使用。列 K 则为子哈希分区列。

CREATECOLUMNTABLE P2 (I INT, J INT, K INT, PRIMARYKEY(I, J)) PARTITIONBY HASH (I, J) PARTITIONS 2, HASH (K) PARTITIONS 2;

建立表 C1，与表 A 的定义相同，记录也相同。

CREATECOLUMNTABLE C1 LIKE A WITH DATA;

建立表 C2，与表 A 的列数据类型和 NOT NULL 约束相同。表 C2 没有任何数据。

CREATETABLE C2 AS (SELECT * FROM A) WITHNO DATA;

7.1.13 CREATE TRIGGER

语法：

CREATE TRIGGER <trigger_name> <trigger_action_time> <trigger_event> ON <subject_table_name> [REFERENCING <transition_list>][<for_each_row>]

BEGIN

[<trigger_decl_list>]

[<proc_handler_list>]

<trigger_stmt_list>

END

语法元素：

<trigger_name> ::= <identifier> 你建立的触发器名称。

<subject_table_name> ::= <identifier> 你建立的触发器所在表的名称。

<trigger_action_time> ::= BEFORE | AFTER 指定触发动做发生的时间。

BEFORE：操做主题表以前执行触发。

AFTER：操做主题表以后执行触发。

<trigger_event> ::= INSERT | DELETE | UPDATE 定义激活触发器活动的数据修改命令

<transition_list> ::= <transition> | <transition_list> , <transition>

当声明了触发器转变变量，触发器能够访问 DML 正在修改的记录。

当执行了行级别触发器， <trans_var_name>.<column_name>表明触发器正在修改的记录的相应列。

这里， <column_name>为主题表的列名。参见转换变量的例子。

<trigger_transition_old_or_new> ::= OLD | NEW

<trigger_transition_var_or_table> ::= ROW

OLD

你能够访问触发器 DML 的旧记录，取而代之的是更新的旧记录或删除的旧记录。

UPDATE 触发器和 DELETE 触发器能够有 OLD ROW 事务变量。

NEW

你能够访问触发器 DML 的新记录，取而代之的是插入的新记录或更新的新记录。

UPDATE 触发器和 DELETE 触发器能够有 NEW ROW 事务变量。

只支持事务变量。

事务表不被支持。

若是你将’TABLE’做为<trigger_transition_var_or_table>，你将看到不支持功能错误。

<for_each_row> ::= FOR EACH ROW

触发器将以逐行方式调用。

默认模式为执行行级别触发器，没有 FOR EACH ROW 语法。

目前，逐语句触发不被支持。

<trigger_decl_list> ::= DECLARE <trigger_decl>| <trigger_decl_list> DECLARE <trigger_decl>

<trigger_decl> ::= <trigger_var_decl> | <trigger_condition_decl>

<trigger_var_decl> ::= <var_name> CONSTANT <data_type> [<not_null>] [<trigger_default_assign>] ;| <var_name> <data_type> [NOT NULL] [<trigger_default_assign>] ;

<trigger_default_assign> ::= DEFAULT <expression>| := <expression>

<trigger_condition_decl> ::= <condition_name> CONDITION ;| <condition_name> CONDITION FOR <sql_error_code> ;

<sql_error_code> ::= SQL_ERROR_CODE <int_const>

trigger_decl_list

你能够声明触发器变量或者条件。

声明的变量能够在标量赋值中使用或者在 SQL 语句触发中引用。

声明的条件名能够在异常处理中引用。

CONSTANT

当指定了 CONSTANT 关键字，你不能够在触发器执行时修改变量。

<proc_handler_list> ::= <proc_handler>| <proc_handler_list> <proc_handler>

<proc_handler> ::= DECLARE EXIT HANDLER FOR <proc_condition_value_list> <trigger_stmt>

<proc_condition_value_list> ::= <proc_condition_value>| <proc_condition_value_list> , <proc_condition_value>

<proc_condition_value> ::= SQLEXCEPTION
| SQLWARNING
| <sql_error_code>
| <condition_name>
异常处理能够声明捕捉已存的 SQL 异常，特定的错误代码或者条件变量声明的条件名称。
<trigger_stmt_list> ::= <trigger_stmt>| <trigger_stmt_list> <trigger_stmt>
<trigger_stmt> ::= <proc_block>
| <proc_assign>
| <proc_if>
| <proc_loop>
| <proc_while>
| <proc_for>
| <proc_foreach>
| <proc_signal>
| <proc_resignal>
| <trigger_sql>
触发器主体的语法是过程体的语法的一部分。
参见 SAP HANA Database SQLScript guide 中的 create procedure 定义。
触发器主体的语法遵循过程体的语法，即嵌套块(proc_block)，标量变量分配(proc_assign)， if 块
(proc_if),， loop 块(proc_loop)， for 块(proc_for)， for each 块(proc_foreach)， exception
signal(proc_signal)， exception resignal(proc_resignal)，和 sql 语句(proc_sql)。
<proc_block> ::= BEGIN
[<trigger_decl_list>]
[<proc_handler_list>]
<trigger_stmt_list>
END ;
你能够以嵌套方式添加另外的'BEGIN ... END;'块。
<proc_assign> ::= <var_name> := <expression> ;
var_name 为变量名，应该事先声明。
<proc_if> ::= IF <condition> THEN <trigger_stmt_list>
[<proc_elsif_list>]
[<proc_else>]
END IF ;
<proc_elsif_list> ::= ELSEIF <condition> THEN <trigger_stmt_list>

<proc_else> ::= ELSE <trigger_stmt_list>
关于 condition 的说明，参见 SELECT 的<condition>。
你可使用 IF ... THEN ... ELSEIF... END IF 控制执行流程与条件。
<proc_loop> ::= LOOP <trigger_stmt_list> END LOOP ;
<proc_while> ::= WHILE <condition> DO <trigger_stmt_list> END WHILE ;
<proc_for> ::= FOR <column_name> IN [<reverse>] <expression> <DDOT_OP> <expression>
DO <trigger_stmt_list>
END FOR ;
<column_name> ::= <identifier>
<reverse> ::= REVERSE
<DDOT_OP> ::= ..
<proc_foreach> ::= FOR <column_name> AS <column_name> [<open_param_list>] DO
<trigger_stmt_list>
END FOR ;
<open_param_list> ::= ( <expr_list> )
<expr_list> ::= <expression> | <expr_list> , <expression>
<proc_signal> ::= SIGNAL <signal_value> [<set_signal_info>] ;
<proc_resignal> ::= RESIGNAL [<signal_value>] [<set_signal_info>] ;
<signal_value> ::= <signal_name> | <sql_error_code>
<signal_name> ::= <identifier>
<set_signal_info> ::= SET MESSEGE_TEXT = '<message_string>'
<message_string> ::= <identifier>
SET MESSEGE_TEXT
若是你为本身的消息设置 SET MESSEGE_TEXT，当触发器执行时指定的错误被抛出，消息传递给用
户。
SIGNAL 语句显式抛出一个异常。
用户定义的范围（ 10000〜19999）将被容许发行错误代码。
RESIGNAL 语句在异常处理中对活动语句抛出异常。
若是没有指定错误代码， RESIGNAL 将抛出已捕捉的异常。

<trigger_sql> ::= <select_into_stmt>
| <insert_stmt>
| <delete_stmt>
| <update_stmt>
| <replace_stmt>
| <upsert_stmt>
对于 insert_stmt 的详情，参见 INSERT。
对于 delete_stmt 的详情，参见 DELETE。
对于 update_stmt 的详情，参见 UPDATE。
对于 replace_stmt 和 upsert_stmt 的详情，参见 REPLACE | UPSERT。
<select_into_stmt> ::= SELECT <select_list> INTO <var_name_list>
<from_clause >
[<where_clause>]
[<group_by_clause>]
[<having_clause>]
[{<set_operator> <subquery>, ... }]
[<order_by_clause>]
[<limit>]
<var_name_list> ::= <var_name> | <var_name_list> , <var_name>
<var_name> ::= <identifier>
关于 select_list, from_clause, where_clause, group_by_clause, having_clause,set_operator, subquery,
order_by_clause, limit 的详情，参见 SELECT。
var_name 是预先声明的标量变量名。
你能够分配选中项至标量变量中。
描述：
CREATE TRIGGER 语句建立触发器。
触发器是一种特殊的存储过程，在对表发生事件时自动执行。
CREATE TRIGGER 命令定义一组语句，当给定操做(INSERT/UPDATE/DELETE)发生在给定对象(主题表)
上执行。
只有对于给定的<subject_table_name>拥有 TRIGGER 权限的数据库用户容许建立表的触发器。
当前触发器限制描述以下：
l不支持 INSTEAD_OF 触发器。
l访问触发器定义的主题表在触发器主体中是不容许的，这表明对于触发器所在的表的任何
insert/update/delete/replace/select

l只支持行级别触发器，不支持语句级别触发器。行级别触发器表示触发活动只有在每次行改
变时执行。语句级别触发器表明触发活动在每次语句执行时运行。语法'FOR EACH ROW’表示
行式执行触发，为默认模式；即时没有指定'FOR EACH ROW’，仍然为行级别触发器。
l不支持事务表(OLD/NEW TABLE)。当触发 SQL 语句想要引用正在被触发器触发事件如
insert/update/delete 修改的数据，事务变量/表将是触发器主体中 SQL 语句访问新数据和旧数
据的方式。事务变量只在行级别触发器中使用，而事务表则在语句级别触发器中使用。
l不支持从节点到多个主机或表中的分区表上执行触发器。
l表只能为每一个 DML 操做有一个触发器，多是插入触发器、更新触发器和删除触发器，而且
它们三个能够一块儿激活。
所以，一张表总共最多有三个触发器。
l不支持的触发器动做（而存储过程支持）：
resultset assignment(select resultset assignment to tabletype),
exit/continue command(execution flow control),
cursor open/fetch/close(get each record data of search result by cursor and access record in loop),
procedure call(call another proecedure),
dynomic sql execution(build SQL statements dynamically at runtime of SQLScript),
return(end SQL statement execution)
系统和监控视图：
TRIGGER 为触发器的系统视图：
系统视图 TRIGGER 显示：
SCHEMA_NAME, TRIGGER_NAME, TRIGGER_OID, OWNER_NAME,
OWNER_OID,SUBJECT_TABLE_SCHEMA,SUBJECT_TABLE_NAME, TRIGGER_ACTION_TIME,
TRIGGER_EVENT, TRIGGERED_ACTION_LEVEL,DEFINITION
例子：
你先须要触发器定义的表：
CREATETABLE TARGET ( A INT);
你也须要表触发访问和修改：
CREATETABLE SAMPLE ( A INT);
如下为建立触发器的例子：

CREATE TRIGGER TEST_TRIGGER AFTERINSERTON TARGET FOR EACH ROW

BEGIN

DECLARE SAMPLE_COUNT INT;

SELECTCOUNT(*) INTO SAMPLE_COUNT FROM SAMPLE;

IF :SAMPLE_COUNT = 0 THEN

INSERTINTO SAMPLE VALUES(5);

ELSEIF :SAMPLE_COUNT = 1 THEN

INSERTINTO SAMPLE VALUES(6);

ENDIF;

END;

触发器 TEST_TRIGGER 将在任意记录插入至 TARGET 表后执行。因为在第一次插入中，表 SAMPLE 记录数为 0，触发器 TEST_TRIGGER 将插入 5 至表中。
在第二次插入 TARGET 表时，触发器插入 6，由于其计数为 1。
INSERTINTO TARGET VALUES (1);

SELECT * FROM SAMPLE;--5

INSERTINTO TARGET VALUES (2);

SELECT * FROM SAMPLE;--5 6

7.1.14 CREATE VIEW

语法：

CREATE VIEW [<schema_name>.]<view_name> [(<column_name>, ... )] AS <subquery>

描述：

CREATE VIEW 能够有效地根据 SQL 结果建立虚拟表，这不是真正意义上的表，由于它自己不包含数据。

当列名一块儿做为视图的名称，查询结果将以列名显示。若是列名被省略，查询结果自动给出一个适当的列名。列名的数目必须与从<subquery>返回的列数目相同。

支持视图的更新操做，若是知足如下条件：

视图中的每一列必须映射到单个表中的一列。

若是基表中的一列有 NOT NULL 约束，且没有默认值，该列必须包含在可插入视图的列中。更新操做没有该条件。

例如在 SELECT 列表，必须不包含聚合或分析的功能，如下是不容许的：

. 在 SELECT 列表中的 TOP, SET, DISTINCT 操做

. GROUP BY, ORDER BY 子句

在 SELECT 列表中必须不能含有子查询。

必须不能包含序列值(CURRVAL, NEXTVAL)。

必须不能包含做为基视图的列视图。

若是基视图或表是可更新的，符合上述条件的基础上，基视图或表的视图是可更新的。

例子：

选择表 a 中的全部数据建立视图 v：

CREATEVIEW v ASSELECT * FROM a;

7.1.15 DROP AUDIT POLICY

语法：

DROP AUDIT POLICY <policy_name>

描述：

DROP AUDIT POLICY 语句删除审计策略。 <policy_name>必须指定已存在的审计策略。

只有拥有系统权限 AUDIT ADMIN 的数据库用户容许删除审计策略。每一个拥有该权限的数据库用户能够删除任意的审计策略，不管是否由该用户建立。

即便审计策略被删除了，可能发生的是，定义在已删除的审计策略中的活动将被进一步审计；若是也启用了其余审计策略和定义了审计活动。

暂时关闭审计策略时，能够禁用而不用删除。

系统和监控视图：

AUDIT_POLICY：显示全部审计策略和状态。

M_INIFILE_CONTENTS：显示数据库系统配置参数。

只有拥有系统权限 CATALOG READ, DATA ADMIN 或 INIFILE ADMIN 的用户能够查看M_INIFILE_CONTENTS 视图中的内容，对于其余用户则为空。

例子：

假设使用以下语句前，审计策略已建立：

CREATEAUDIT POLICY priv_audit AUDITING SUCCESSFUL GRANT PRIVILEGE, REVOKE PRIVILEGE, GRANT ROLE, REVOKE ROLE LEVEL CRITICAL;

如今，该审计策略必须删除：

DROPAUDIT POLICY priv_audit;

7.1.16 DROP FULLTEXT INDEX

语法：

DROP FULLTEXT INDEX <fulltext_index_name>

描述：

DROP FULLTEXT INDEX 语句移除全文索引。

例子：

DROP FULLTEXT INDEX idx;

7.1.17 DROP INDEX

语法：

DROP INDEX <index_name>

描述：

DROP INDEX 语句移除索引。

例子：

DROPINDEX idx;

7.1.18 DROP SCHEMA

语法：

DROP SCHEMA <schema_name> [<drop_option>]

语法元素：

<drop_option> ::= CASCADE | RESTRICT

Default = RESTRICT

有限制的删除操做将删除对象当其没有依赖对象时。若是存在依赖对象，将抛出错误。

CASCADE级联删除：将删除对象以及其依赖对象。

描述：

DROP SCHEMA 语句移除schema。

例子：

建立集合 my_schema，表 my_schema.t，而后 my_schema 将使用 CASCADE 选项删除。

CREATESCHEMA my_schema;

CREATETABLE my_schema.t (a INT);

DROPSCHEMA my_schema CASCADE;

7.1.19 DROP SEQUENCE

语法：

DROP SEQUENCE <sequence_name> [<drop_option>]

语法元素：

<drop_option> ::= CASCADE | RESTRICT

Default = RESTRICT

级联删除将删除对象以及其依赖对象。当未指定 CASCADE 可选项，将执行非级联删除对象，不会删除依赖对象，而是使依赖对象 (VIEW, PROCEDURE) 无效。

无效的对象能够从新验证当一个对象有一样的集合，而且已建立了对象名。对象 ID，集合名以及对象名为从新验证依赖对象而保留。

有限制的删除操做将删除对象当其没有依赖对象时。若是存在依赖对象，将抛出错误。

描述：

DROP SEQUENCE 语句移除序列。

例子：

DROPSEQUENCE s;

7.1.20 DROP SYNONYM

语法：

DROP [PUBLIC] SYNONYM <synonym_name> [<drop_option>]

语法元素：

<drop_option> ::= CASCADE | RESTRICT

Default = RESTRICT

级联删除将删除对象以及其依赖对象。当未指定 CASCADE 可选项，将执行非级联删除操做，不会删除依赖对象，而是使依赖对象 (VIEW, PROCEDURE) 无效。

无效的对象能够从新验证当一个对象有一样的集合，而且已建立了对象名。对象 ID，集合名以及对象名为从新验证依赖对象而保留。

有限制的删除操做将删除对象当其没有依赖对象时。若是存在依赖对象，将抛出错误。

描述：

DROP SYNONYM 删除同义词。可选项 PUBLIC 容许删除公用同义词。

例子：

表 a 已建立，而后为表 a 建立同义词 a_synonym 和公用同义词 pa_synonym：

CREATETABLE a (c INT);

CREATESYNONYM a_synonym FOR a;

CREATEPUBLICSYNONYM pa_synonym FOR a;

删除同义词 a_synonym 和公用同义词 pa_synonym

DROPSYNONYM a_synonym;

DROPPUBLICSYNONYM pa_synonym;

7.1.21 DROP TABLE

语法：

DROP TABLE [<schema_name>.]<table_name> [<drop_option>]

语法元素：

<drop_option> ::= CASCADE | RESTRICT

Default = RESTRICT

级联删除将删除对象以及其依赖对象。当未指定 CASCADE 可选项，将执行非级联删除操做，不会删除依赖对象，而是使依赖对象 (VIEW, PROCEDURE) 无效。

无效的对象能够从新验证当一个对象有一样的集合，而且已建立了对象名。对象 ID，集合名以及对象名为从新验证依赖对象而保留。

有限制的删除操做将删除对象当其没有依赖对象时。若是存在依赖对象，将抛出错误。

描述：

DROP TABLE 语句删除表。

例子：

建立表 A，而后删除。

CREATETABLE A(C INT);

DROPTABLE A;

7.1.22 DROP TRIGGER

DROP TRIGGER <trigger_name>

描述：

DROP TRIGGER 语句删除一个触发器。

只有在触发器所做用表上有 TRIGGER 权限的数据库用户才容许删除该表的触发器。

例子：

对于这个例子，你须要先建立一个名为 test_trigger 的触发器，以下：

CREATETABLE TARGET ( A INT);

CREATETABLE SAMPLE ( A INT);

CREATE TRIGGER TEST_TRIGGER AFTERUPDATEON TARGET

BEGIN

INSERTINTO SAMPLE VALUES(3);

END;

如今你能够删除触发器：

DROP TRIGGER TEST_TRIGGER;

7.1.23 DROP VIEW

语法：

DROP VIEW [<schema_name>.]<view_name> [<drop_option>]

语法元素：

<drop_option> ::= CASCADE | RESTRICT

Default = RESTRICT

级联删除将删除对象以及其依赖对象。当未指定 CASCADE 可选项，将执行非级联删除操做，不会删除依赖对象，而是使依赖对象 (VIEW, PROCEDURE) 无效。

无效的对象能够从新验证当一个对象有一样的集合，而且已建立了对象名。对象 ID，集合名以及对象名为从新验证依赖对象而保留。

有限制的删除操做将删除对象当其没有依赖对象时。若是存在依赖对象，将抛出错误。

描述：

DROP VIEW 语句删除视图。

例子：

表 t 已建立，而后选择表 a 中的全部数据建立视图 v：

CREATETABLE t (a INT);

CREATEVIEW v ASSELECT * FROM t;

删除视图 v：

DROPVIEW v;

7.1.24 RENAME COLUMN

语法：

RENAME COLUMN <table_name>.<old_column_name> TO <new_column_name>

描述：

RENAME COLUMN 语句修改列名：

例子：

建立表 B:

CREATETABLE B (A INTPRIMARYKEY, B INT);

显示表 B 中列名的列表：

SELECT COLUMN_NAME, POSITION FROM TABLE_COLUMNS WHERE SCHEMA_NAME =CURRENT_SCHEMA AND TABLE_NAME = 'B'ORDERBYPOSITION;

列 A 重名为 C：

RENAMECOLUMN B.A TO C;

7.1.25 RENAME INDEX

语法：

RENAME INDEX <old_index_name> TO <new_index_name>

描述：

RENAME INDEX 语句重命名索引名。

例子：

表 B 已建立，而后索引 idx 创建在表 B 的列 B：

CREATETABLE B (A INTPRIMARYKEY, B INT);

CREATEINDEX idx on B(B);

显示表 B 的索引名列表：

SELECT INDEX_NAME FROM INDEXES WHERE SCHEMA_NAME = CURRENT_SCHEMA AND TABLE_NAME='B';

索引 idx 重名为 new_idx：

RENAMEINDEX idx TO new_idx;

7.1.26 RENAME TABLE

语法：

RENAME TABLE <old_table_name> TO <new_table_name>

描述：

RENAME TABLE 语句在同一个Schema下，将表名修改成 new_table_name。

例子：

在当前集合建立表 A：

CREATETABLE A (A INTPRIMARYKEY, B INT);

显示当前集合下表名的列表：

SELECT TABLE_NAME FROM TABLES WHERE SCHEMA_NAME = CURRENT_SCHEMA;

表 A 重命名为 B：

RENAMETABLE A TO B;

SCHEMA mySchema 已建立，而后建立表 mySchema.A：

CREATESCHEMA mySchema;

CREATETABLE mySchema.A (A INTPRIMARYKEY, B INT);

显示模式 mySchema 下表名的列表：

SELECT TABLE_NAME FROM TABLES WHERE SCHEMA_NAME = 'MYSCHEMA';

表 mySchema.A 重命名为 B：

RENAMETABLE mySchema.A TO B;注：修改后B仍是在mySchema里

7.1.27 ALTER TABLE ALTER TYPE

语法：

<table_conversion_clause> ::= [ALTER TYPE] { ROW [THREADS <number_of_threads>] | COLUMN [THREADS <number_of_threads> [BATCH <batch_size>]] }

语法元素：

<number_of_threads> ::= <numeric_literal>

指定进行表转换的并行线程数。线程数目的最佳值应设置为可用的 CPU 内核的数量。

<batch_size> ::= <numeric_literal>

指定批插入的行数，默认值为最佳值 2,000,000。插入表操做在每一个<batch_size>记录插入后当即提交，能够减小内存消耗。 BATCH 可选项只能够在表从行转换为列时使用。然而，大于 2,000,000的批大小可能致使高内存消耗，所以不建议修改该值。

描述：

经过复制现有的表中的列和数据，能够从现有的表建立一个不一样存储类型的新表。该命令用来把表从行转换为列或从列转换为行。若是源表是行式存储，则新建的表为列式存储。

配置参数:

用于表转换的默认线程数在 indexserver.ini 的[sql]部分定义， table_conversion_parallelism =<numeric_literal> (初始值为 8)。

例子：

对于这个例子，你须要先建立欲进行转换的表：

CREATECOLUMNTABLE col_to_row (col1 INT, col2 INT)

CREATEROWTABLE row_to_col (col1 INT, col2 INT)

表 col_to_row 将以列式存储方式建立，表 row_to_col 则为行式存储。

如今你能够将表 col_to_row 的存储类型从列转为行：

ALTERTABLE col_to_row ALTERTYPEROW

你也能够将表 row_to_col 的存储类型从行转为列：

ALTERTABLE row_to_col ALTERTYPECOLUMN

为了使用批量转换模式，你须要在语句结尾处添加批选项：

ALTERTABLE row_to_col ALTERTYPECOLUMN BATCH 10000

7.1.28 TRUNCATE TABLE

语法：

TRUNCATE TABLE <table_name>

描述：

删除表中全部记录。当从表中删除全部数据时， TRUNCATE 比 DELETE FROM 快，可是 TRUNCATE没法回滚。要回滚删除的记录，应使用"DELETE FROM <table_name>"。

HISTORY 表能够经过执行该语句像正常表同样删除。历史表的全部部分(main, delta, history main and history delta)将被删除而且内容会丢失。

7.2数据操纵语句

7.2.1 DELETE

语法：

DELETE [HISTORY] FROM [<schema_name>.]<table_name> [WHERE <condition>]

关于谓词的详情，请参阅 Predicates。

描述：

DELETE 语句当知足条件时，从表中删除全部记录。若是省略了 WHERE 子句，将删除表中全部记录。

DELETE HISTORY

DELETE HISTORY 将标记选中的历史表中历史记录进行删除。这表示执行完该语句后，引用已删除记录的时间旅行查询语句可能仍然能够查看这些数据。为了在物理上删除这些记录，必须执行下面的语句：

ALTER SYSTEM RECLAIM VERSION SPACE; MERGE HISTORY DELTA of <table_name>;

请注意：在某些状况中，即便执行了上述两条语句，仍没法从物理上删除。

欲检查记录是否已从物理上删除，如下语句会有帮助：

SELECT * FROM <table_name> WHERE <condition> WITH PARAMETERS ('REQUEST_FLAGS'=('ALLCOMMITTED','HISTORYONLY'));

注意： “WITH PARAMETERS ('REQUEST_FLAGS'= ('ALLCOMMITTED','HISTORYONLY'))”子句可能只适用于验证 DELETE HISTORY 语句的执行结果。

例子：

CREATETABLE T (KEYINTPRIMARYKEY, VAL INT);

INSERTINTO T VALUES (1, 1);

INSERTINTO T VALUES (2, 2);

INSERTINTO T VALUES (3, 3);

在下面的例子中，将删除一条记录：

DELETEFROM T WHEREKEY = 1;

7.2.2 EXPLAIN PLAN

语法：

EXPLAIN PLAN [SET STATEMENT_NAME = <statement_name>] FOR <sql_subquery>

语法元素：

<statement_name> ::= string literal used to identify the name of a specific executi on plan in the output table for a given SQL statement.

若是未指定 SET STATEMENT_NAME，则将设为 NULL。

描述：

EXPLAIN PLAN 语句用来评估 SAP HANA 数据库遵循的执行 SQL 语句的执行计划。评估的结果存在视图 EXPLAIN_PLAN_TABLE，以便稍后的用户检查。

SQL 语句必须是数据操纵语句，所以Schema定义语句不能在 EXPLAIN STATEMENT 中使用。

你能够从 EXPLAIN_PLAN_TABLE 视图中获得 SQL 计划，该视图为全部用户共享。这里是从视图读取 SQL 计划的例子：

SELECT * FROM EXPLAIN_PLAN_TABLE;

EXPLAIN_PLAN_TABLE 视图中的列：表 1：列名和描述

EXPLAIN_PLAN_TABLE 视图中的 OPERATOR_NAME 列。表 2： OPERATOR_NAME 列显示的列式引擎操做符列表：

COLUMN SEARCH 为列式引擎操做符起始位置标记， ROW SEARCH 为行式引擎操做符起始位置标记。在如下的例子中， COLUMN SEARCH (ID 10)生成的中间结果被 ROW SEARCH (ID 7)使用， ROWSEARCH (ID 7) 被另外一个 COLUMN SEARCH (ID 1)使用。位于 COLUMN SEARCH (ID 10) 最底层的操做符解释了 COLUMN SEARCH (ID 10) 是如何执行的。 ROW SEARCH (ID 7) 和 COLUMN SEARCH (ID 10) 之间的操做符说明了 ROW SEARCH (ID 7) 如何处理由 COLUMN SEARCH (ID 10) 生成的中间结果。位于COLUMN SEARCH (ID 1) 和 ROW SEARCH (ID 7)顶层的操做符解释了顶层 COLUMN SEARCH (ID 1) 是如何处理由 ROW SEARCH (ID 7)生成的中间结果。

SQL 计划解释例子。

该语句来自语 TPC-H 基准。例子中的全部表都是行式存储。

setschema hana_tpch;

DELETEFROM explain_plan_table WHERE statement_name = 'TPC-H Q10';

EXPLAINPLANSET STATEMENT_NAME = 'TPC-H Q10'FOR

SELECT TOP 20 c_custkey,c_name,SUM(l_extendedprice * (1 - l_discount)) AS revenue,

c_acctbal,

n_name,

c_address,

c_phone,

c_comment

FROM

customer,

orders ,

lineitem,

nation

WHERE

c_custkey = o_custkey

AND l_orderkey = o_orderkey

AND o_orderdate >= '1993-10-01'

AND o_orderdate < ADD_MONTHS('1993-10-01',3)

AND l_returnflag = 'R'

AND c_nationkey = n_nationkey

GROUPBY

c_custkey,

c_name,

c_acctbal ,

c_phone,

n_name,

c_address ,

c_comment

ORDERBY revenue DESC;

SELECT operator_name, operator_details , table_name FROM explain_plan_table WHERE statement_name = 'TPC-H Q10';

如下是对这个查询语句的计划解释：

7.2.3 INSERT

语法:

INSERT INTO [ <schema_name>. ]<table_name> [ <column_list_clause> ] { <value_list_clause> | <subquery> }

语法元素：

<column_list_clause> ::= ( <column_name>, ... )

<value_list_clause> ::= VALUES ( <expression>, ... )

描述：

INSERT 语句添加一条到表中。返回记录的子查询能够用来插入表中。若是子查询没有返回任何结果，数据库将不会插入任何记录。可使用 INSERT 语句指定列的列表。不在列表中的列将显示默认值。若是省略了列的列表，数据库插入全部记录到表中。

例子：

CREATETABLE T (KEYINTPRIMARYKEY, VAL1 INT, VAL2 NVARCHAR(20));

在如下的例子中，你能够插入值：

INSERTINTO T VALUES (1, 1, 'The first');

你能够将值插入到指定的列：

INSERTINTO T (KEY) VALUES (2);

你也可使用子查询：

INSERTINTO T SELECT 3, 3, 'The third'FROM DUMMY;

7.2.4 LOAD

语法：

LOAD <table_name> {DELTA | ALL | (<column_name>, ...)}

描述：

LOAD 语句明确地加载列式（注：Load只支持列式存储，对于行式存储不能使用）存储表的数据至内存中，而非第一次访问时加载。

DELTA

使用 DELTA，列式表的一部分将加载至内存。因为列式存储对于读操做作了优化和压缩，增量用来优化插入或更新。全部的插入被传递给一个增量。

ALL

主要的和增量的列存储表中全部数据加载到内存中。

例子：

如下的例子加载整张表 a_table 至内存中。

LOAD a_table all;

如下的例子加载列 a_column 和表 a_table 列 another_column 至内存中。

LOAD a_table (a_column,another_column);

表加载状态能够查询：

select loaded from m_cs_tables where table_name = '<table_name>'

7.2.5 MERGE DELTA

语法：

MERGE [HISTORY] DELTA OF [<schema_name>.]<table_name> [PART n] [WITH PARAMETERS (<parameter_key_value>, ...)]

语法元素：

WITH PARAMETERS (<parameter_list>):

<parameter_list> ::= <parameter>,<parameter_list>

<parameter_name> ::= 'SMART_MERGE' | 'MEMORY_MERGE'

<parameter_setting> ::= 'ON' | 'OFF'

当前参数： 'SMART_MERGE' = 'ON' | 'OFF'。当 SMART_MERGE 为 ON，数据库执行智能合并，这表明数据库基于 Indexserver 配置中定义的合并条件来决定是否合并。'MEMORY_MERGE' = 'ON' | 'OFF' 数据库只合并内存中表的增量部分，不会被持久化。

描述：

使用 DELTA，列式表的一部分将加载至内存。因为列式存储对于读操做作了优化和压缩，增量用来优化插入或更新。全部的插入被传递至一个增量部分。

HISTORY 能够指定合并历史表增量部分到临时表的主要历史部分。

PART-能够指定合并历史表增量部分到临时表的主要历史部分，该表已分区。

例子：

MERGEDELTAOF A;

Merges the column store table delta part to its main part.

MERGEDELTAOF A WITH PARAMETERS('SMART_MERGE' = 'ON');

Smart merges the column store table delta part to its main part.

MERGEDELTAOF A WITH PARAMETERS('SMART_MERGE' = 'ON', 'MEMORY_MERGE' = 'ON');

Smart merges the column store table delta part to its main part non-persistent, in memory only.

MERGEDELTAOF A PART 1;

Merge the delta of partition no. 1 of table with name "A" to main part of partion no. 1.

MERGEHISTORYDELTAOF A;

Merge the history delta part of table with name "A" into its history main part.

MERGEHISTORYDELTAOF A PART 1;

Merges the column store table delta part of the history of table with name "A" to its history main part.

7.2.6 REPLACE | UPSERT

语法：

UPSERT [ <schema_name>. ]<table_name> [ <column_list_clause> ] { <value_list_clause> [ WHERE <condition> | WITH PRIMARY KEY ] | <subquery> }

REPLACE [ <schema_name>. ]<table_name> [ <column_list_clause> ] { <value_list_clause> [ WHERE <condition> | WITH PRIMARY KEY ] | <subquery> }

语法元素：

<column_list_clause> ::= ( <column_name>, ... )

<value_list_clause> ::= VALUES ( <expression>, ... )

有关谓词的详情，请参阅 Predicates。

描述：

没有子查询的 UPSERT 或者 REPLACE 语句与 UPDATE 类似。惟一的区别是当 WHERE 子句为假（或没有Where子句）时，该语句像 INSERT 同样添加一条新的记录到表中。

对于表有 PRIMARY KEY 的状况，主键列必须包含在列的列表中。没有默认设定，由 NOT NULL 定义的列也必须包含在列的列表中。

有子查询的 UPSERT 或者 REPLACE 语句与 INSERT 同样，除了若是表中旧记录与主键的新记录值相同，则旧记录将被子查询返回的记录所修改。除非表有一个主键，不然就变得等同于 INSERT（即若是表没有设定主键，则为INSERT？），由于没有使用索引来判断新记录是否与旧记录重复。

有'WITH PRIMARY KEY'的 UPSERT 或 REPLACE 语句与有子查询的语句相同。其在 PRIMARY KEY 基础上工做。

例子：

CREATETABLE T (KEYINTPRIMARYKEY, VAL INT);

你能够插入一条新值：

UPSERT T VALUES (1, 1);--没有Where与子查询，直接插入

若是 WHERE 子句中的条件为假，将插入一条新值：

UPSERT T VALUES (2, 2) WHEREKEY = 2; --没有就插入

你能够更新列"VAL"的第一条记录

UPSERT T VALUES (1, 9) WHEREKEY = 1;--有就更新

或者你可使用"WITH PRIMARY KEY" 关键字

UPSERT T VALUES (1, 8) WITHPRIMARYKEY;--根据主键进行更新，若是不存在，则插入

你可使用子查询插入值：

UPSERT T SELECTKEY + 2, VAL FROM T;--将子查询的结果插入，若是存在，则更新

UPSERT T VALUES (5, 1) WITHPRIMARYKEY;--根据主键查询时不存在，则插入

UPSERT T SELECT 5,3 from dummy;--存在，则更新

7.2.7 SELECT

语法：

<select_statement> ::= <subquery> [ <for_update> | <time_travel> ]| ( <subquery> ) [ <for_update> | <time_travel> ]

<subquery> ::= <select_clause> <from_clause> [<where_clause>] [<group_by_clause>] [<having_clause>] [{<set_operator> <subquery>, ... }] [<order_by_clause>] [<limit>]

语法元素：

SELECT 子句：

SELECT 子句指定要返回给用户或外部的 select 子句一个输出，若是存在的话。

<select_clause> ::= SELECT [TOP <integer>] [ ALL | DISTINCT ] <select_list>

<select_list> ::= <select_item>[, ...]

<select_item> ::= [<table_name>.] *| <expression> [ AS <column_alias> ]

TOP n：TOP n 用来返回 SQL 语句的前 n 条记录。

DISTINCT 和 ALL：可使用 DISTINCT 返回重复的记录，每一组选择只有一个副本。使用 ALL 返回选择的全部记录，包括全部重复记录的拷贝。默认值为 ALL。

Select_list：select_list 容许用户定义他们想要从表中选择的列。

*：*能够从 FROM 子句中列出的表或视图中选择全部列。若是集合名和表名或者表名带有星号(*)，其用来限制结果集至指定的表。

column_alias：column_alias 能够用于简单地表示表达式。

FROM：FROM 子句中指定输入值，如表、视图、以及将在 SELECT 语句中使用的子查询。

<from_clause> ::= FROM {<table>, ... }

<joined_table> ::= <table> [<join_type>] JOIN <table> ON <predicate> | <table> CROSS JOIN <table> | <joined_table>

<join_type> ::= INNER | { LEFT | RIGHT | FULL } [OUTER]

table alias：表别名能够用来简单地表示表或者子查询。

join_type 定义了将执行的联接类型， LEFT 表示左外联接， RIGHT 表示右外联接， FULL 表示全外联接。执行联接操做时， OUT 可能或者可能不使用。

ON <predicate>：ON 子句定义联接谓词。

CROSS JOIN：CROSS 表示执行交叉联接，交叉联接生成两表的交叉积结果。

WHERE 子句

WHERE 子句用来指定 FROM 子句输入的谓词，使用户能够检索所需的记录。

<where_clause> ::= WHERE <condition>

<comparison_predicate> ::= <expression> { = | != | <> | > | < | >= | <= } [ ANY | SOME | ALL ] ({<expression_list> | <subquery>})

<range_predicate> ::= <expression> [NOT] BETWEEN <expression> AND <expression>

<in_predicate> ::= <expression> [NOT] IN ( { <expression_list> | <subquery> } )

<exist_predicate> ::= [NOT] EXISTS ( <subquery> )

<like_predicate> ::= <expression> [NOT] LIKE <expression> [ESCAPE <expression>]

<null_predicate> ::= <expression> IS [NOT] NULL

<expression_list> ::= {<expression>, ... }

GROUP BY 子句

<group_by_clause> ::=GROUP BY { { <expression>, ... } | <grouping_set> }

<grouping_set> ::= { GROUPING SETS | ROLLUP | CUBE }[BEST <integer>] [LIMIT <integer>[OFFSET <integer>] ] [WITH SUBTOTAL] [WITH BALANCE] [WITH TOTAL]

[TEXT_FILTER <filterspec> [FILL UP [SORT MATCHES TO TOP]]] [STRUCTURED RESULT [WITH OVERVIEW] [PREFIX <string_literal>] | MULTIPLE RESULTSETS] ( <grouping_expression_list> )

<grouping_expression_list> ::= { <grouping_expression>, ... }

<grouping_expression> ::=<expression>| ( <expression>, ... ) | ( ( <expression>, ... ) <order_by_clause> )

GROUP BY 用来对基于指定列值选定的行进行分组。

GROUPING SETS

在一条语句中，生成多个特定数据分组结果。若是没有设置例如 best 和 limit 的可选项，结果将和 UNION ALL 每一个指定组的聚合值相同。例如：

"select col1, col2, col3, count(*) from t groupbygrouping sets ( (col1, col2), (col1, col3) )"与" select col1, col2, NULL, count(*) from t groupby col1, col2 unionallselect col1, NULL, col3,count(*) from t groupby col1, col3"相同。在 grouping-sets 语句中，

每一个(col1, col2) 和(col1, col3)定义了分组。

ROLLUP

在一条语句中，生成多级聚合结果。例如， "rollup (col1, col2,col3)"与有额外聚合，但没有分组的"grouping sets ( (col1, col2, col3), (col1, col2), (col1) )"结果相同。所以，结果集所包含的分组的数目是 ROLLUP 列表中的列加上一个最后聚合的数目，若是没有额外的选项。

CUBE

在一条语句中，生成多级聚合的结果。例如， "cube (col1, col2,col3)" 与有额外聚合，但没有分组的"grouping sets ( (col1, col2, col3), (col1, col2), (col1, col3), (col2, col3), (col1), (col2),(col3) )"结果相同。所以，结果集所包含分组的数目与全部可能排列在 CUBE 列表的列加上一个最后聚合的数目是相同的，若是没有附加的选项。

BEST n

返回每一个以行聚合数降序排列的分组集中前 n 个分组集（返回的是某个分组里的全部记录，而不是某几条）。 n 能够是任意零，正数或负数。当 n 为零时，做用和没有 BEST 选项同样。当 n 为负数表示以升序排序。

LIMIT n1 [OFFSET n2]

返回每一个分组集中（取每一个组中的部分行）第一个 N1 分组记录跳过 N2 个后的结果。

WITH SUBTOTAL

返回每一个分组集中由 OFFSET 或者 LIMIT 控制的返回结果的分类汇总。除非设置了 OFFSET 和LIMIT，返回值将和 WITH TOTAL 相同。

WITH BALANCE

返回每一个分组集中 OFFSET 或者 LIMIT 没有返回的其他结果值。

WITH TOTAL

返回每一个分组集中额外的合计总值行。 OFFSET 和 LIMIT 选项不能修改该值。

TEXT_FILTER <filterspec>

执行文本过滤或者用<filterspec>高亮分组列， <filterspec>为单引号字符串，语法以下：

<filterspec> ::= '[<prefix>]<element>{<subsequent>, ...}'

<prefix> ::= + | - | NOT

<token> ::= !! Unicode letters or digits

<phrase> ::= !! double-quoted string that does not contain double quotations inside

<prefix_subsequent> ::= + | - | NOT | AND | AND NOT | OR

<filterspec>定义的过滤是由与逻辑操做符 AND, OR 和 NOT 链接的标记/词组或者短语组成。一个标记相匹配的字符串，其中包含对应不区分大小写的单词， 'ab' 匹配 'ab cd' 和 'cd Ab' ，但不匹配'abcd'。一个标记能够包含通配字符’，匹配任何字符串， ’匹配任意字母。可是在词组内， ’和’不是通配符。逻辑运算符 AND， OR 和 NOT 能够与标记，词组一块儿使用。因为 OR 是默认操做符， 'ab cd' 和'ab OR cd'意义同样。注意，逻辑运算符应该大写。做为一种逻辑运算符，前缀'+' 和 '-'各自表示包含(AND) 和不包含 (AND NOT)。例如， 'ab -cd' 和 'ab AND NOT cd'意义相同。若是没有 FILL UP 选项，只返回含有匹配值的分组记录。须要注意的是一个过滤器仅被运用到每一个分组集的第一个分组列。

FILL UP

不只返回匹配的分组记录，也包含不匹配的记录。 text_filter 函数对于识别哪个匹配是颇有用的。参阅下面的'Related Functions’。

SORT MATCHES TO TOP

返回匹配值位于非匹配值前的分组集。该选项不能和 SUBTOTAL, BALANCE 和 TOTAL 一块儿使用。

STRUCTURED RESULT

结果做为临时表返回。对于每个分组集建立一个临时表，若是设置 WITH OVERVIEW 选项，将为分组集的总览建立额外的临时表，该临时表的名字由 PREFIX 选项定义。

WITH OVERVIEW

将总览返回至单独的额外一张表中。

PREFIX 值

使用前缀命名临时表。必须以"#"开始，表明是临时表。若是省略，默认前缀为"#GN"，而后，链接该前缀值和一个非负整数，用做临时表的名称，好比"#GN0", "#GN1" 和 "#GN2"。

MULTIPLE RESULTSETS

返回多个结果集中的结果。

7.2.8 UNLOAD

语法：

UNLOAD <table_name>

描述：

UNLOAD 语句从内存中卸载列存储表，以释放内存。表将在下次访问时从新加载。

例子：

在下面的例子中，表 a_table 将从内存中卸载。

UNLOAD a_table;

卸载表的状态能够经过如下语句查询：

select loaded from m_cs_tables where table_name = 't1';

7.2.9 UPDATE

语法

UPDATE [<schema_name>.]<table_name> [ AS <alias_name> ] <set_clause> [ WHERE <condition> ]

<set_clause> ::= SET {<column_name> = <expression>},...

关于表达式的详情，请参见 Expressions。

关于谓词的详情，请参见 Predicates。

描述：

UPDATE 语句修改知足条件的表中记录的值。若是 WHERE 子句中条件为真，将分配该列至表达式的结果中。若是省略了 WHERE 子句，语句将更新表中全部的记录。

例子：

CREATETABLE T (KEYINTPRIMARYKEY, VAL INT);

INSERTINTO T VALUES (1, 1);

INSERTINTO T VALUES (2, 2);

若是 WHERE 条件中的条件为真，记录将被更新。

UPDATE T SET VAL = VAL + 1 WHEREKEY = 1;

若是省略了 WHERE 子句，将更新表中全部的记录。

UPDATE T SET VAL = KEY + 10;

7.3系统管理语句

7.3.1 SET SYSTEM LICENSE

语法：

SET SYSTEM LICENSE '<license key>'

描述：

安装许可证密钥的数据库实例。许可证密钥(<license key>="">) 将从许可证密钥文件中复制黏贴。

执行该命令须要系统权限 LICENSE ADMIN。

例子：

SETSYSTEM LICENSE '----- Begin SAP License -----

SAPSYSTEM=HD1

HARDWARE-KEY=K4150485960

INSTNO=0110008649

BEGIN=20110809

EXPIRATION=20151231

LKEY=...

SWPRODUCTNAME=SAP-HANA

SWPRODUCTLIMIT=2147483647

SYSTEM-NR=00000000031047460'

7.3.2 ALTER SYSTEM ALTER CONFIGURATION

语法：

ALTER CONFIGURATION (<filename>, <layer>[, <layer_name>]) SET | UNSET <parameter_key_value_list> [ WITH RECONFIGURE]

语法元素：

行存储引擎配置的状况下，文件名是'indexserver.ini'。所使用的文件名必须是一个位于’DEFAULT’层的 ini 文件。若是选择文件的文件名在所需的层不存在，该文件将用 SET 命令建立。

设置配置变化的目标层。该参数能够是'SYSTEM'或'HOST'。 SYSTEM 层为客户设置的推荐层。 HOST层应该通常仅可用于少许的配置，例如， daemon.ini 包含的参数。

<layer_name> ::= <string_literal>

若是上述的层设为’HOST’， layer_name 将用于设置目标 tenant 名或者目标主机名。例如，

'selxeon12' 为目标 'selxeon12' 主机名。

SET

SET 命令更新键值，若是该键已存在，或者须要的话插入该键值。

UNSET

UNSET 命令删除键及其关联值。

<parameter_key_value_list> ::={(<section_name>,<parameter_name>) = <parameter_value>},...

指定要修改的 ini 文件的段、键和值语句以下：

<section_name> ::= <string_literal>

将要修改的参数段名：

<parameter_name> ::= <string_literal>

将要修改的参数名：

<parameter_value> ::= <string_literal>

将要修改的参数值。

WITH RECONFIGURE

当指定了 WITH RECONFIGURE，配置的修改将直接应用到 SAP HANA 数据库实例。

当未指定 WITH RECONFIGURE，新的配置将写到文件 ini 中，然而，新的值将不会应用到当前运行系统中，只在数据库下次的启动时应用。这意味 ini 文件中的�

1. Hana SQL
2. HANA SQLScript
3. HANA SQL参考及Oracle对照
4. SAP HANA 用户管理(SAP HANA User Management)
5. SAP HANA ROWID (SAP HANA “$rowid$“)
6. 【SAP HANA】SAP HANA开篇（1）
7. HANA Create View
8. hana ytd计算
9. SAP HANA
10. SAP HANA Hint简介
更多相关文章...
• SQL WHERE 子句 - SQL 教程
• SQL UNIQUE 约束 - SQL 教程
• 三篇文章了解 TiDB 技术内幕 —— 说计算
• 三篇文章了解 TiDB 技术内幕——说存储