DDL

DDL语句用于创建数据库对象，包括库、表、视图和索引等；用户在进行DDL操作时，系统首先判断用户是否拥有执行此项操作的权限。

ADD COLUMN

在表内添加一个新列，ADD COLUMN是ALTER TABLE的子命令，用于ADD COLUMN向现有表添加列。

所需权限

用户必须有表的CREATE权限。

语法图

AlterTableStmt
AddColumnStmt
ColQualification

参数介绍

参数	说明
`table_name`	需要添加列的表
`column_name`	需要添加列的名称（必须满足命名规则，且在表内唯一，但可与索引、约束同名）
`typename`	需要添加新列的数据类型
`col_qualification`	列定义的可选列表，可能包括列级约束，排序规则或列族分配。需要注意，无法直接添加具有外键约束的列。可以添加没有约束的列，然后使用`CREATE INDEX`索引列，再使用`ADD CONSTRAINT`将外键约束添加到列。

创建表

create table cust (cust_id int);

添加单列

alter  table cust add column age int;

添加多列

alter  table cust add column address string,add column iphone_number int;

添加具有NOT NULL约束和DEFAULT值的列

alter table cust add column money decimal not null default (decimal '123456789');

添加带有UNIQUE约束列，并且值非空

alter table cust add column tel decimal unique not null;

添加带有排序规则的列

alter table cust add column email string collate en;

添加一列并将其分给新的列族，用CREATE FAMILY语句

alter table cust add column creat_time date create family new_time;

添加一列分给现有列族

alter table cust add column time string family new_time;

如果列族不存在，则添加列并创建列族

alter table cust add column new_time string create if not exists family n_time;

查看建表语句

show create table cust;

  table_name |                                    create_statement
-------------+-----------------------------------------------------------------------------------------
  cust       | CREATE TABLE public.cust (
             |     cust_id INT8 NULL,
             |     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
             |     age INT8 NULL,
             |     address STRING NULL,
             |     iphone_number INT8 NULL,
             |     money DECIMAL NOT NULL DEFAULT 123456789:::DECIMAL,
             |     tel DECIMAL NOT NULL,
             |     email STRING COLLATE en NULL,
             |     creat_time DATE NULL,
             |     "time" STRING NULL,
             |     new_time STRING NULL,
             |     CONSTRAINT "primary" PRIMARY KEY (rowid ASC),
             |     UNIQUE INDEX cust_tel_key (tel ASC),
             |     FAMILY "primary" (cust_id, rowid, age, address, iphone_number, money, tel, email),
             |     FAMILY new_time (creat_time, "time"),
             |     FAMILY n_time (new_time)
             | )

ADD CONSTRAINT

用于为列添加约束：

Check
Foreign Keys
UNIQUE

主键的NOT NULL约束只能通过CREATE TABLE创建，DEFAULT约束通过ALTER COLUMN管理。要将主键约束添加到表中，应该在创建表时显式定义主键。要替换现有的主键，可以使用ADD CONSTRAINT ... PRIMARY KEY。

所需权限

需要有表的CREATE权限。

语法图

AlterConstraintStmt
Con_Name
Con_Elem

参数介绍

参数	说明
`table_name`	包含要约束的列的表的名称
`constraint_name`	约束的名称，它必须对其表唯一并遵循这些标识符规则
`constraint_elem`	要添加的`CHECK`， `foreign key`约束。添加、更改约束是通过. 不支持通过添加、更改表格；它只能在表创建期间指定。

查看架构更改

此架构更改语句已注册为作业。您可以使用SHOW JOBS查看长时间运行的作业。

更改主键ADD CONSTRAINT ... PRIMARY KEY

当您使用更改主键时ALTER TABLE ... ALTER PRIMARY KEY，现有的主键索引将变为二级索引。创建的二级索引ALTER PRIMARY KEY会占用节点内存，并且会降低集群的写入性能。

如果满足以下条件之一，可以使用ADD CONSTRAINT ... PRIMARY KEY向现有表添加主键：

在创建表时没有明确定义主键。在这种情况下，表是使用默认主键rowid创建的。使用DROP CONSTRAINT ... PRIMARY KEY删除默认主键并用新的主键替换它。
在同一事务中，DROP CONSTRAINT语句在ADD CONSTRAINT ... PRIMARY KEY语句之前。具体信息，请参阅下文删除并添加主键约束。

建表语句

create table shop
(id int,
name varchar(20),
balance  DECIMAL(10,2)
);

添加UNIQUE约束

要求该列的每一个值都是唯一的，NULL除外

alter table shop add constraint id_unique unique (id);

添加约束：check语法

alter table shop add constraint balance_check check (balance > 0);

在添加约束的过程中Hubble将运行一个后台作业来验证现有的表数据，如果Hubble在验证步骤中发现了违反约束的行，则ADD CONSTRAINT语句将失败。

在以下情况下，将回滚整个事务，包括添加的任何新列：

如果发现现有列包含违反新约束的值。
如果新列具有默认值或者是包含违反新约束的值的计算列。
查看约束

show  constraints from shop;

  table_name | constraint_name | constraint_type |        details        | validated
-------------+-----------------+-----------------+-----------------------+------------
  shop       | balance_check   | CHECK           | CHECK ((balance > 0)) |   true
  shop       | id_unique       | UNIQUE          | UNIQUE (id ASC)       |   true

添加FOREIGN KEY约束

在添加FOREIGN KEY约束前，该列必须已添加索引。如果该列未索引，使用CREATE INDEX来创建索引，然后再通过ADD CONSTRAINT 添加 FOREIGN KEY 约束

create table customers (
      id int primary key,
      name string,
      email string
  );

create table shipments (
      tracking_number uuid default gen_random_uuid() primary key,
      carrier string,
      status string,
      customer_id int
    );

alter table shipments add constraint fk_customers foreign key (customer_id) references customers(id);

删除并添加主键约束

比如：要添加name到cust_info表的复合主键，而不创建现有主键的二级索引。

建表语句如下：

create table cust_info (
                  id UUID NOT NULL,
                  city VARCHAR NOT NULL,
                  name VARCHAR NULL,
                  address VARCHAR NULL,
                  credit_card VARCHAR NULL,
                  CONSTRAINT cust_info_pkey PRIMARY KEY (city ASC, id ASC)
              );

首先，使用向列添加NOT NULL约束。

ALTER TABLE cust_info ALTER COLUMN name set not null;

然后，在同一个事务中，DROP现有主键约束和ADD新约束：

begin;
alter table cust_info DROP CONSTRAINT cust_info_pkey;
alter table cust_info ADD  CONSTRAINT cust_info_pkey PRIMARY KEY (city, name, id);
commit;

show create table cust_info;

 table_name |                            create_statement
-------------+--------------------------------------------------------------------------
  cust_info  | CREATE TABLE public.cust_info (
             |     id UUID NOT NULL,
             |     city VARCHAR NOT NULL,
             |     name VARCHAR NOT NULL,
             |     address VARCHAR NULL,
             |     credit_card VARCHAR NULL,
             |     CONSTRAINT cust_info_pkey PRIMARY KEY (city ASC, name ASC, id ASC),
             |     FAMILY "primary" (id, city, name, address, credit_card)
             | )

CREATE DATABASE

该CREATE DATABASE语句用于创建一个新的数据库。

所需权限

只有admin角色成员才能创建新数据库。

语法图

CreateDatabaseStmt
IfNotExists
DBName
DatabaseOptionListOpt

参数介绍

范围	参数
`IF NOT EXISTS`	仅当不存在同名数据库时才创建新数据库；如果确实存在，则不返回错误。
`DBname`	要创建的数据库的名称，它必须是唯一的并遵循这些标识符规则。

创建数据库(判断数据库是否存在)

create database if not exists hubble_database;

创建数据库(不判断数据库是否存在)

create database  hubble_db;

SQL不会生成错误，而是会响应，CREATE DATABASE即使没有创建新数据库也是如此。

切换到数据库hubble_db

use  hubble_db;

创建多区域数据库

如果在集群启动时设置了区域，可以在集群中创建使用集群区域的多区域数据库。

使用以下命令在创建数据库时指定区域和生存目标：

CREATE DATABASE bank PRIMARY REGION "center1" REGIONS "center1", "center2", "center3" SURVIVE REGION FAILURE;

show regions from database bank;

 database | region  | primary | zones
-----------+---------+---------+--------
  bank     | center1 |  true   | {}
  bank     | center2 |  false  | {}
  bank     | center3 |  false  | {}

CREATE TABLE

该CREATE TABLE语句在数据库中创建一个新表。

所需权限

要创建表，用户必须具备以下条件之一：

admin集群角色的成员资格。
数据库所有者角色的成员身份。
数据库的CREATE权限。

语法图

CreateTableStmt
Temporary
IfNotExists
TableName
CreateTableOpt
FamilyOpt
PartitionOpt

参数介绍

参数	详情
`if not exists`	仅当数据库中不存在同名表时才创建新表; 如果确实存在，则不返回错误
`table_name`	要创建的表的名称，在其数据库中必须是唯一的，并遵循定义规则. 如果没有设置默认父数据库，则必须将名称格式设置为`database.name`。
`TEMPORARY`	将表定义为会话范围的临时表。
`familyOpt`	可选项，定义列族的逗号分隔列表。列族名称在表中必须是唯一的，但可以与列，约束或索引具有相同的名称。列族是一组列，它们作为单个键值对存储在基础键值存储中。 Hubble自动将列分组到列族中，以确保有效的存储和性能。但是，有时你可能希望手动将列分配给族，更多详细信息，请参见列族文档。
`partition_opt`	允许你在行级别定义表分区。你可以按列表或按`range`定义表分区。

支持范围

Hubble支持以下列限定条件：

列级约束
排序规则
列族分配
DEFAULT表达式
标识列(序列填充的列)

像现有表一样创建表

支持CREATE TABLE LIKE基于现有表的模式创建新表的语法。

支持以下选项：

添加CHECK源表中的所有约束。
添加DEFAULT源表中的所有列表达式。
添加源表中的所有计算列表达式。
添加源表中的所有索引。
包括上述所有说明符。

CREATE TABLE LIKE语句不能从现有表中复制列族、分区和外键约束。如果希望在新表中使用这些列限定条件，则必须手动重新创建它们。

支持LIKE的说明符也可以与普通CREATE TABLE说明符混合使用。例如：

CREATE TABLE t1 (a INT PRIMARY KEY, b INT NOT NULL DEFAULT 3 CHECK (b > 0), INDEX(b));

CREATE TABLE t2 (LIKE table1 INCLUDING ALL EXCLUDING CONSTRAINTS, c INT, INDEX(b,c));

在此示例中，使用t1的索引和默认值创建t2。

创建表

创建定义主键的表

create table cust_info (
        id UUID PRIMARY KEY,
        city STRING,
        name STRING,
        address STRING,
        credit_card STRING,
        dl STRING,
        index(name)
);

show index from cust_info;

 table_name |     index_name     | non_unique | seq_in_index | column_name | direction | storing | implicit
-------------+--------------------+------------+--------------+-------------+-----------+---------+-----------
  cust_info  | cust_info_name_idx |    true    |            1 | name        | ASC       |  false  |  false
  cust_info  | cust_info_name_idx |    true    |            2 | id          | ASC       |  false  |   true
  cust_info  | primary            |   false    |            1 | id          | ASC       |  false  |  false

创建不定义主键的表，在Hubble中，每个表都需要一个主键。如果未明确定义，则会自动添加一个INT类型的名为rowid的列作为主键，并使用unique_rowid()函数确保新行始终默认为唯一的rowid值。自动为主键创建索引。

create table my_table1(
    user_id int,
    cre_date date
  );

严格地说，主键的唯一索引并没有创建，它是由数据储存层的key来区分的，因此不需要额外的空间。但是，在使用show index等命令时，它会显示为正常的唯一索引。

show index from my_table1;

table_name|index_name|non_unique|seq_in_index|column_name|direction|storing|implicit
----------+----------+----------+------------+-----------+---------+-------+--------
my_table1 |  primary |  false   |           1|   rowid   |ASC      | false | false 
(1 row)

创建表并且定义主键，例如：我们创建一个包含三列的表。一列是主键，另一列是唯一约束，第三列没有约束。具有唯一约束的主键和列将自动创建索引。

create table my_table2 (
    user_id int primary key,
    user_email string unique,
    logoff_date date
  );

show columns from  my_table2;

  column_name | data_type | is_nullable | column_default | generation_expression |              indices               | is_hidden
--------------+-----------+-------------+----------------+-----------------------+------------------------------------+------------
  user_id     | INT8      |    false    | NULL           |                       | {my_table2_user_email_key,primary} |   false
  user_email  | STRING    |    true     | NULL           |                       | {my_table2_user_email_key}         |   false
  logoff_date | DATE      |    true     | NULL           |                       | {}                                 |   false

show index from my_table2;

+---------+---------------------+------+---+----------+--------+-------+--------+
| Table   |        Name         |Unique|Seq|  Column  |irection|Storing|Implicit|
+---------+---------------------+------+---+----------+--------+-------+--------+
|my_table2|primary              |true  |  1|user_id   | ASC    | false | false  |
|my_table2|logoff_user_email_key|true  |  1|user_email| ASC    | false | false  |
|my_table2|logoff_user_email_key|true  |  2|user_id   | ASC    | false | true   |
+---------+---------------------+------+---+----------+--------+-------+--------+
(3 rows)

创建具有自动生成的唯一行ID的表

要自动生成唯一的行标识符，请使用具有UUID的列作为默认值

create  table user_info (
        id UUID NOT NULL DEFAULT gen_random_uuid(),
        city STRING NOT NULL,
        name STRING NULL,
        id_card STRING NULL,
        CONSTRAINT "primary" PRIMARY KEY (city ASC, id ASC),
        FAMILY "primary" (id, city, name,  id_card)
);

生成的ID都是128位的，足够大，几乎不可能生成非唯一值。

创建具有外键约束的表

外键约束保证列只使用它引用的列中已经存在的值，这些值必须来自另一个表。此约束强制两个表之间的引用完整性。

create  table users (
        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
        city STRING,
        name STRING,
        address STRING,
        credit_card STRING,
        dl STRING UNIQUE CHECK (LENGTH(dl) < 8)
);

create  table orders (
        id UUID NOT NULL DEFAULT gen_random_uuid(),
        city STRING NOT NULL,
        types STRING,
        order_id UUID REFERENCES users(id) ON DELETE CASCADE,
        creation_time TIMESTAMP,
        status STRING,
        current_location STRING,
        ext JSONB,
        CONSTRAINT "primary" PRIMARY KEY (city ASC, id ASC)
);

创建带有检查约束的表

在此示例中，我们创建了custs_info表，但带有一些列约束。一列是主键，另一列被赋予唯一约束和限制字符串长度的检查约束。主键列和具有唯一约束的列会自动建立索引。

create  table custs_info (
        cust_id UUID PRIMARY KEY,
        city STRING,
        cust_name STRING,
        address STRING,
        credit_card STRING,
        dl STRING UNIQUE CHECK (LENGTH(dl) > 4)
);

创建一个映射键值存储的表

Hubble是一个分布式SQL数据库，建立在事务性和强一致性键值存储之上。尽管无法直接访问键值存储，但您可以使用包含两列的简单的表来镜像直接访问，其中一组作为主键：

create  table kv (k INT PRIMARY KEY, v BYTES);

创建具有计算列的表

该full_name列是从first_name和last_name列计算的

create  table users_info (
        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
        city STRING,
        first_name STRING,
        last_name STRING,
        full_name STRING AS (CONCAT(first_name, ' ', last_name)) STORED
);

CREATE TABLE AS

该CREATE TABLE ... AS语句选择查询创建一个新表。

语法图

CreateTableAsStmt

AsSelopt

参数介绍

参数	详情
`if not exists`	仅当数据库中不存在同名表时，才创建新表；如果存在，不返回错误。请注意，`if not exists`仅检查表名，不检查现有表是否具有新表的相同列，索引，约束等。
`table_name`	要创建的表的名称，与其数据库中必须是唯一的，并遵循标识符规则。如果未设置默认父数据库，则必须将名称格式设置为`database.name` `UPSERT`和`INSERT ON CONFLICT`语句使用名为`excluded`的临时表来处理执行期间的唯一性冲突。因此，建议不要使用表名`excluded`。
`column_name`	您要使用的列的名称，而不是来自的列的名称`select_stmt`
`create_as_col_qual_list`	一个可选的列定义，它可能包括主键约束和列族分配
`family_def`	一个可选的列族定义，列族名称在表中必须是唯一的，但可以与列、约束或索引同名

使用create table ... as 创建的表的主键不是从查询结果派生的；与其他表一样，创建后无法添加或更改主键；而且这些表不与其他表交错；列族的默认规则适用。

SELECT查询创建表

例如：

create table logtable ( 
    user_id INT PRIMARY KEY, 
    user_name STRING UNIQUE, 
    log_date DATE NOT NULL 
);

create table logtable_copy AS TABLE logtable;

show create table logtable_copy;

   table_name   |                      create_statement
----------------+--------------------------------------------------------------
  logtable_copy | CREATE TABLE public.logtable_copy (
                |     user_id INT8 NULL,
                |     user_name STRING NULL,
                |     log_date DATE NULL,
                |     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
                |     CONSTRAINT "primary" PRIMARY KEY (rowid ASC),
                |     FAMILY "primary" (user_id, user_name, log_date, rowid)
                | )

该示例说明主键，唯一和非空约束不会派生到新的表。

不过可以在CREATE TABLE ... AS 之后创建二级索引 :

create index logtable_copy_id_idx ON logtable_copy ( user_id );
show create table logtable_copy;

   table_name   |                      create_statement
----------------+--------------------------------------------------------------
  logtable_copy | CREATE TABLE public.logtable_copy (
                |     user_id INT8 NULL,
                |     user_name STRING NULL,
                |     log_date DATE NULL,
                |     rowid INT8 NOT VISIBLE NOT NULL DEFAULT unique_rowid(),
                |     CONSTRAINT "primary" PRIMARY KEY (rowid ASC),
                |     FAMILY "primary" (user_id, user_name, log_date, rowid)
                | )

更改列名

此语句创建现有表的副本，但列名已更改：

create table t2 (user_id, user_name) AS SELECT id, name FROM t1;

指定主键

可以指定从选择查询创建的新表的主键：

CREATE TABLE t2 (id, city, name PRIMARY KEY) AS SELECT id, city, name FROM t1 WHERE city = 'shanghai';

定义列族

可以定义从选择查询创建的新表的列族：

CREATE TABLE t2 (id PRIMARY KEY FAMILY ids, name, city FAMILY locs, address, credit_card FAMILY payments) AS SELECT id, name, city, address, credit_card FROM t1 WHERE city = 'beijing';

CREATE INDEX

CREATE INDEX语句为表创建索引，通过帮助SQL定位数据而无需查看表的每一行来提高数据库的性能。

其中，PRIMARY KEY和UNIQUE列将会自动创建索引。查询表时，Hubble使用最快的索引。

以下类型不能包含在索引键中:

JSONB
ARRAY
计算类型

所需权限

要求拥有表的CREATE权限。

语法图

CreateIndexStmt
IndexLimit
IndexTypeOpt
IfNotExists
IndexTypeOpt
IndexOptList
IndexType
ColumnName
IndexNameList
KeyOrIndex

参数介绍

参数	说明
`UNIQUE`	将`UNIQUE`约束应用于索引列
`INVERTED`	对指定列中的无模式数据创建索引，您还可以使用与PostgreSQL兼容的语法。
`IF NOT EXISTS`	仅当不存在同名索引时才创建新索引；如果确实存在，则不返回错误。
`index_name`	要创建的索引的名称，必须对其表唯一并遵循这些标识符规则
`TableName`	要在其上创建索引的表的名称

创建表

create table cust_info (
    id int default unique_rowid(),
    name string,
    core_id int,
    region string,
    address jsonb
);

创建索引

create index on cust_info (core_id);

创建多列索引

create index on cust_info (name, region);

创建唯一索引

create unique index on cust_info (name);

或者

alter table cust_info add constraint cust_name_id_key unique (name, id);

JSONB类型的字段可以创建倒排索引

create inverted index on cust_info (address);

show columns from cust_info;

  column_name | data_type | is_nullable | column_default | generation_expression |                                                       indices                                                       | is_hidden
--------------+-----------+-------------+----------------+-----------------------+---------------------------------------------------------------------------------------------------------------------+------------
  id          | INT8      |    true     | unique_rowid() |                       | {cust_name_id_key}                                                                                                  |   false
  name        | STRING    |    true     | NULL           |                       | {cust_info_name_key,cust_info_name_region_idx,cust_name_id_key}                                                     |   false
  core_id     | INT8      |    true     | NULL           |                       | {cust_info_core_id_idx}                                                                                             |   false
  region      | STRING    |    true     | NULL           |                       | {cust_info_name_region_idx}                                                                                         |   false
  address     | JSONB     |    true     | NULL           |                       | {cust_info_address_idx}                                                                                             |   false
  rowid       | INT8      |    false    | unique_rowid() |                       | {cust_info_address_idx,cust_info_core_id_idx,cust_info_name_key,cust_info_name_region_idx,cust_name_id_key,primary} |   true

更改列排序顺序

要按降序对列进行排序，必须在创建索引时显式设置该选项。

create index on cust_info (name, region desc);

CREATE VIEW

CREATE VIEW语句创建一个新视图，它是一个表示为虚拟表的存储查询。

所需权限

用户必须对父数据库具有CREATE权限，并且对视图引用的表具有SELECT权限。

语法图

CreateViewStmt
OrReplace
ViewAlgorithm
ViewSelectStmt

参数介绍

参数	详情
`ViewName`	要创建的视图的名称，该视图的名称在其数据库中必须是唯一的，并遵循标识符规则。如果未设置默认父数据库，则必须将名称格式设置为`database.name`。
`MATERIALIZED`	创建物化视图
`IF NOT EXISTS`	仅当不存在同名视图时才创建新视图，请注意，`IF NOT EXISTS`仅检查视图名称。
`OR REPLACE`	如果不存在同名视图，则创建一个新视图。如果已存在同名视图，请替换该视图
`Sel_Stmt`	在请求视图时执行的选择查询。请注意，目前无法使用`*`来从引用的表或视图中选择所有列，你必须指定特定的列。

建表语句

create table cust_info (
    id int ,
    name string,
    core_id int,
    region string
);
insert into cust_info values(100,'assir',130234,'beijing');

创建视图

create view cust_view as select id, name from cust_info;

查看视图

select * from cust_view ;

  id  | name
------+--------
  100 | assir

目前暂不支持CREATE VIEW .. AS SELECT * FROM ...,需要手动指定字段名。

查看创建视图

show create view cust_view;

  table_name |                                   create_statement
-------------+---------------------------------------------------------------------------------------
  cust_view  | CREATE VIEW public.cust_view (id, name) AS SELECT id, name FROM ora.public.cust_info

CREATE SEQUENCE

该CREATE SEQUENCE语句在数据库中创建一个新序列，使用序列自动递增表中的整数。

所需权限

执行此操作需要用户拥有CREATE权限。

语法图

CreateSequenceStmt
IfNotExists
TableName
CreateSequenceOptionListOpt
SequenceOption

参数介绍

参数	详情
`seq_name`	要创建的序列的名称，在其数据库中必须是唯一的，并且遵循标识符规则。当父数据库未设置为默认值时，名称的格式必须为`database.seq_name`
`INCREMENT`	序列递增的值，负数创建一个降序，正数创建升序，默认`1`
`MINVALUE`	序列的最小值，如果未指定或输入，则应用默认值`NO MINVALUE`。升序`1`，默认值：降序默认值`MININT`
`START`	序列的第一个值升序 `1`，默认值：降序默认值`-1`
`NO CYCLE`	目前，所有序列都设置为`NO CYCLE`并且序列不会换行
`CACHE`	要在内存中缓存以在会话中重用的序列值的数量。缓存大小为`1`表示没有缓存，小于缓存大小的缓存`1`无效。
`OWNED BY column_name`	将序列与特定列相关联，如果删除该列或其父表，则该序列也将被删除。
`Opt_Temp`	将序列定义为会话范围的临时序列。

序列函数

SEQUENCE支持以下函数操作:

nextval('seq_name')
currval('seq_name')
lastval()
setval('seq_name',value,is_called)

临时序列

Hubble支持会话范围的临时序列。与持久序列不同，临时序列只能从创建它们的会话中访问，并且在会话结束时被删除。可以在持久表和临时表上创建临时序列。

细节:

临时序列会在会话结束时自动删除。
临时序列只能从创建它的会话中访问。
临时序列在同一会话中的事务中持续存在。
临时序列不能转换为持久序列。
创建临时序列

将TEMP/TEMPORARY添加到CREATE SEQUENCE语句中。

SET experimental_enable_temp_tables=on;

CREATE TEMP SEQUENCE temp_seq START 1 INCREMENT 1;

查询当前数据库中的SEQUENCES情况

select * from information_schema.sequences;

创建SEQUENCE

create sequence userid_seq;

show create userid_seq;

table_name |    create_statement
-----------+------------------------------
userid_seq | CREATE SEQUENCE userid_seq 
           | MINVALUE 1 
           | MAXVALUE 9223372036854775807 
           | INCREMENT 1 
           | START 1

建表时指定主键根据sequence自动增长

create table user_table(
  user_id int PRIMARY KEY DEFAULT nextval('userid_seq'),
  phone_number string,
  create_date date
);

插入几条测试数据

insert into user_table (phone_number, create_date)
values
('13900010002','2018-10-01'),
('13654559807','2018-12-01'),
('18800001111','2016-10-01');

select * from user_table;

  user_id | phone_number |         cre_date           
+---------+--------------+---------------------------+
        1 | 13900010002  | 2018-10-01 00:00:00+00:00  
        2 | 13654559807  | 2018-12-01 00:00:00+00:00  
        3 | 18800001111  | 2016-10-01 00:00:00+00:00

使用SEQUENCE比使用内置函数gen_random_uuid()、uuid_v4()、unique_rowid()自动生成的唯一ID要慢。

当数据被删除之后，仍然可以从删除的位置的序列值自增

truncate table user_table;

select * from user_table;

  user_id | phone_number | create_date
----------+--------------+--------------
(0 rows)

insert into user_table (phone_number, create_date)
                           values
                           ('13900010002','2018-10-01'),
                           ('13654559807','2018-12-01'),
                           ('18800001111','2016-10-01');

select * from user_table;

  user_id | phone_number | create_date
----------+--------------+--------------
        4 | 13900010002  | 2018-10-01
        5 | 13654559807  | 2018-12-01
        6 | 18800001111  | 2016-10-01

查看序列的当前值

要查看当前值而不增加序列，请使用：

select * from userid_seq;

设置序列的下一个值

在项目中，往往从导入后数据的最大值的下一个值开始新增数据，比如说现在一个表test有1000条数据，则从第1001条数据开始递增。

create sequence userid_seq 
           MINVALUE 1 
           MAXVALUE 9223372036854775807 
           INCREMENT 1 
           START 1001;

create table test(
  user_id int PRIMARY KEY DEFAULT nextval('userid_seq'),
  phone_number string,
  create_date date
);

使用用户定义的设置创建序列

在此示例中，我们创建了一个从1开始并以2为增量递减的序列。

create sequence desc_customer_list START 1 INCREMENT -2;

列出所有序列

show sequences;

在内存中缓存序列值

为了提高性能，使用CACHE关键字在内存中缓存序列值。

例如，在内存中缓存5个序列值：

create sequence cust_seq_id CACHE 5;

CREATE TYPE

该CREATE TYPE语句在数据库中创建一个新的枚举数据类型。

所需权限

要创建类型，用户必须具有数据库的CREATE权限。

语法图

CreateTypeStmt
Enum_List

参数介绍

参数	详情
`type_name`	类型的名称。您可以使用数据库和模式名称来限定名称`db.typename`，但是在创建类型之后，它只能从包含该类型的数据库中引用。
`IF NOT EXISTS`	仅当数据库中不存在同名类型时才创建新类型；如果确实存在，则不返回错误。
`opt_enum_val_list`	构成类型枚举集的值列表。

创建类型

create type status as enum ('open', 'closed', 'inactive');

创建与类型相关的表，并插入数据

create table account (
        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
        balance DECIMAL,
        status status
);

insert into account(balance,status) values (500.50,'open'), (0.00,'closed'), (1.25,'inactive');

查看数据

select * from account;

                   id                  | balance |  status
---------------------------------------+---------+-----------
  3848e36d-ebd4-44c6-8925-8bf24bba957e |  500.50 | open
  60928059-ef75-47b1-81e3-25ec1fb6ff10 |    0.00 | closed
  71ae151d-99c3-4505-8e33-9cda15fce302 |    1.25 | inactive

查看建表结构

show create table account;

 table_name |                create_statement
-------------+--------------------------------------------------
  account    | CREATE TABLE public.account (
             |     id UUID NOT NULL DEFAULT gen_random_uuid(),
             |     balance DECIMAL NULL,
             |     status public.status NULL,
             |     CONSTRAINT account_pkey PRIMARY KEY (id ASC)
             | )

DROP DATABASE

DROP DATABASE语句会删除Hubble中的一个数据库和数据库中的所有对象。

所需权限

用户必须拥有要删除数据库和数据库中所有表的DROP 权限。

删除数据库与数据库中的对象（CASCADE）

对于client端会话，DROP DATABASE默认使用CASCADE，会删除数据库中的所有表与视图，同时也会删除所有依赖表的对象，例如CONSTRAINT和view。

禁止删除一个非空的数据库（RESTRICT）

语法图

DropDatabaseStmt
IfExists
LimitConditions

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`NAME`	您要删除的数据库的名称。如果将数据库设置为当前数据库或如果`sql_safe_updates = true`
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。

防止删除非空数据库

当一个数据库不是空的时候，RESTRICT会阻止数据库的删除。

drop  database ora restrict;

ERROR: database "ora" is not empty and RESTRICT was specified

删除数据库及其对象

对于非交互式会话(例如，客户端应用程序)，默认DROP DATABASE应用该选项，这将删除数据库中的所有表和视图以及依赖于这些表的所有对象(例如约束和视图)。

drop  database ora CASCADE;

DROP TABLE

从数据库中删除一张表，包括表的数据与索引。

所需权限

用户必须对要删除的表拥有drop权限。

语法图

DropTableStmt
IfExists

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`TableName`	以逗号分隔的表名列表。要查找表名，请使用`SHOW TABLES`
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。

展示当前数据库的表

show tables;

  schema_name |          table_name           | type  | owner | estimated_row_count | locality
--------------+-------------------------------+-------+-------+---------------------+-----------
  public      | a                             | table | root  |                   1 | NULL
  public      | aa                            | table | root  |                   1 | NULL
  public      | b                             | table | root  |                   1 | NULL
  public      | customers                     | table | root  |                   2 | NULL
  public      | orders                        | table | root  |                   0 | NULL

删除表示例（无依赖关系）

drop table b;

删除表示例（有依赖关系）

create table customers (
      id int primary key,
      name string,
      email string
  );
  
create table shipments (
      tracking_number uuid default gen_random_uuid() primary key,
      carrier string,
      status string,
      customer_id int
    );

alter table shipments add constraint fk_customers foreign key (customer_id) references customers(id);

drop table customers ;

"customers" is referenced by foreign key from table "shipments"

此时，我们要用到CASCADE强制删除

drop table customers CASCADE;

CASCADE删除依赖于表的所有对象（例如外键约束和视图），为强制性删除语句，且CASCADE不会列出它掉落的对象，因此应谨慎使用。

DROP COLUMN

DROP COLUMN 语句是ALTER TABLE的一部分，会删除一张表中某些列。

所需权限

用户必须拥有CREATE权限。

语法图

DropColumnStmt
DropColumnSpec

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`TableName`	以逗号分隔的表名列表。要查找表名，请使用`SHOW TABLES`
`ColumnName`	要删除的列的名称。当删除带有`CHECK`约束的列时，该`CHECK`约束也将被删除
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。

当我们有变更表结构时，Hubble会将这个操作注册成一个job，可以通过SHOW JOBS查看。

删除列示例（表中有数据）

create table cust_info(
    cust_no       string primary key,
    cust_name     varchar(30) not null,
    cust_card_no  varchar(18),  
    cust_phoneno  decimal(15),
    cust_address  varchar(30),
    cust_type     varchar(10),
    index(cust_card_no)
 );

insert into cust_info values('14435550','王吉','12022519960321531X',15122511874,'天津武清','抵押');
insert into cust_info values('14435551','张贺','431256197306265320',15534343555,'山西临汾','质押');
insert into cust_info values('14435552','刘明','371452199303034312',18967756743,'陕西延安','信用');
insert into cust_info values('14435553','李华','52112119860621421X',15833355455,'湖北武汉','抵押');
insert into cust_info values('14435554','郑青','213456199102275341',13054546567,'江西南昌','质押');

删除cust_name

alter table cust_info drop column cust_name;

pq: rejected: ALTER TABLE DROP COLUMN will remove all data in that column (sql_safe_updates = true)

先将sql_safe_updates会话变量必须设置为false，在执行删除列语句

set sql_safe_updates=false;
alter table cust_info drop column cust_name;

set sql_safe_updates=true;

注意：删除完成后请还原sql_safe_updates为true

删除时有依赖：

create view cust_view as select cust_no,cust_card_no from cust_info;

alter table cust_info drop column cust_card_no RESTRICT;

cannot drop column "cust_card_no" because view "cust_view" depends on it

删除有对象依赖列（CASCADE）

如果要删除有对象依赖的列，使用CASCADE

alter table cust_info drop column cust_card_no CASCADE;

不要忘记删除完成后，还原sql_safe_updates为true

DROP INDEX

DROP INDEX语句会删除表中的索引。

所需权限

用户必须拥有表的CREATE权限。

语法图

DropIndexStmt
IfExists

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`TableName`	以逗号分隔的表名列表。要查找表名，请使用`SHOW TABLES`
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。
`index_name`	要删除的索引的名称。使用查找索引名称`SHOW INDEX`
`CONCURRENTLY`	用于PostgreSQL兼容性的可选无操作语法。

建表并查看索引

create table shipments (
      tracking_number uuid default gen_random_uuid() primary key,
      carrier string,
      status string,
      customer_id int,
      index(customer_id)
    );

create table customers (
      id int primary key,
      name string,
      email string,
      index(name)
  );
  
alter table shipments add constraint fk_customers foreign key (customer_id) references customers(id); 
  
show index from customers;

  table_name |     index_name     | non_unique | seq_in_index | column_name | direction | storing | implicit
-------------+--------------------+------------+--------------+-------------+-----------+---------+-----------
  customers  | customers_name_idx |    true    |            1 | name        | ASC       |  false  |  false
  customers  | customers_name_idx |    true    |            2 | id          | ASC       |  false  |   true
  customers  | primary            |   false    |            1 | id          | ASC       |  false  |  false

删除索引

格式：DROP INDEX table_name@index_name ，默认生成的索引会有表名作为前缀，如果自定义的索引名，则需要按此格式

drop  index customers@customers_name_idx;

如果一个表字段是外键类型时，删除索引时要加关键字CASCADE。

drop  index shipments@shipments_customer_id_idx CASCADE;

DROP VIEW

DROP VIEW语句删除数据库中的视图。

所需权限

用户必须拥有删除视图的权限。

语法图

DropViewStmt
CheckOpt

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`TableName`	以逗号分隔的表名列表。要查找表名，请使用`SHOW TABLES`
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。

创建表并创建视图

create table cust_info(
    cust_no       string primary key,
    cust_name     varchar(30) not null,
    cust_card_no  varchar(18),  
    cust_phoneno  decimal(15),
    cust_address  varchar(30),
    cust_type     varchar(10),
    index(cust_card_no)
 );
 
create view user_info
  as select  cust_no, cust_name,cust_card_no 
  from  cust_info;

查看视图

SELECT * FROM information_schema.tables WHERE table_type = 'VIEW';

  table_catalog | table_schema | table_name | table_type | is_insertable_into | version
----------------+--------------+------------+------------+--------------------+----------
  ora           | public       | user_info  | VIEW       | NO                 |       1

删除视图(无依赖)

drop view user_info;

强制删除（CASCADE）

警告：
CASCADE删除所有依赖视图而不列出它们，这可能会导致意外和难以恢复的损失。

drop view user_info CASCADE;

DROP SEQUENCE

删除数据库中的序列。

所需权限

用户必须拥有要删除序列的DROP权限。

语法图

DropSequenceStmt
IfExists
TableNameList

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`sequence_name`	您要删除的序列的名称。`SHOW CREATE`在使用序列的表上找到序列名称
`CASCADE`	删除数据库中的所有表和视图以及依赖于这些表的所有对象（例如约束和视图）
`RESTRICT`	如果数据库包含任何表或视图，请不要删除它。

删除有依赖的序列

如果有表依赖此序列不允许删除，且不建议用CASCADE强制删除

drop  sequence userid_seq;

pq: cannot drop sequence userid_seq because other objects depend on it

删除没有依赖的序列

create sequence cust_id;

drop  sequence cust_id;

DROP TYPE

该DROP TYPE语句从当前数据库中删除指定的枚举数据类型。

所需权限

用户必须是该类型的所有者。

DropTYPEStmt

参数介绍

参数	详情
`IF EXISTS`	如果存在则删除数据库；如果不存在，则不返回错误
`type_name_list`	要删除的类型名称或逗号分隔的类型名称列表

建表并创建类型

create type sta_type AS enum ('open');

create table cust (
        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
        balance DECIMAL,
        status sta_type
);

如果有表依赖所在的类型，则无法删除，需要先删除表

drop type sta_type;

ERROR: cannot drop type "sta_type" because other objects ([ora.public.cust]) still depend on it
SQLSTATE: 2BP01

首先删除相关的表

drop table accounts;

删除类型

drop type status;

DROP CONSTRAINT

DROP CONSTRAINT 语法是ALTER TABLE 的一部分，会删除列CHECK和FOREIGN KEY约束。

所需权限

用户必须拥有CREATE权限。

语法图

DropConstraintStmt
DropConstraint
IfExists

参数介绍

参数	详情
`table_name`	具有要删除的约束的表的名称。
`name`	要删除的约束的名称。

建表语句示例：

create table customers (
      id int primary key,
      name string,
      email string
  );
  
create table shipments (
      tracking_number uuid default gen_random_uuid() primary key,
      carrier string,
      status string,
      customer_id int
    );
    
alter table shipments add constraint fk_customers foreign key (customer_id) references customers(id);

show constraints from shipments;

  table_name | constraint_name | constraint_type |                      details                       | validated
-------------+-----------------+-----------------+----------------------------------------------------+------------
  shipments  | fk_customers    | FOREIGN KEY     | FOREIGN KEY (customer_id) REFERENCES customers(id) |   true
  shipments  | primary         | PRIMARY KEY     | PRIMARY KEY (tracking_number ASC)                  |   true

删除外键约束

alter table shipments drop constraint fk_customers;

show constraints from shipments;

  table_name | constraint_name | constraint_type |                      details                       | validated
-------------+-----------------+-----------------+----------------------------------------------------+------------
  shipments  | primary         | PRIMARY KEY     | PRIMARY KEY (tracking_number ASC)                  |   true

删除唯一约束

唯一约束不允许使用ALTER TABLE [tablename] DROP CONSTRAINT语句进行删除，通过删除索引及依赖对象方式来下降唯一约束。

create table login_info (
    login_id      int primary key,
    customer_id   int,
    login_date    timestamp,
    unique (customer_id)
  );
  
show constraints from login_info;

  table_name |      constraint_name       | constraint_type |          details           | validated
-------------+----------------------------+-----------------+----------------------------+------------
  login_info | login_info_customer_id_key | UNIQUE          | UNIQUE (customer_id ASC)   |   true
  login_info | primary                    | PRIMARY KEY     | PRIMARY KEY (login_id ASC) |   true

drop  index login_info@login_info_customer_id_key cascade;

RENAME DATABASE

用于更改数据库的名称

所需权限

要重命名数据库，用户必须是admin角色的成员，并且先关闭会话变量set sql_safe_updates = false,改名完成后再次set sql_safe_updates = true。

语法图

RenameDatabaseStmt

参数介绍

参数	详情
`database_name`	`database_name`代表的是数据库名称。

注意：如果数据库被视图引用，则无法重命名数据库

alter database db1 rename to db2;

RENAME TABLE

该RENAME TO语句是ALTER TABLE的一部分，用于修改表名称。

所需权限

用户必须具有表和数据库的DROP权限。用户必须同时拥有源数据库和目标数据库的CREATE权限。

语法图

RenameTableStmt

参数介绍

参数	详情
`IF EXISTS`	仅当具有当前名称的表存在时才重命名该表
`cur_name`	表的当前名称
`new_name`	表的新名称，在其数据库中必须是唯一的并遵循这些标识符规则。

展示数据库的表

show tables;

 schema_name | table_name  | type  | owner | estimated_row_count | locality
--------------+-------------+-------+-------+---------------------+-----------
  public      | cust_info   | table | root  |                   0 | NULL

重命名表名

alter table  cust_info rename to cust_user_info;

show tables;

 schema_name | table_name        | type  | owner | estimated_row_count | locality
--------------+------------------+-------+-------+---------------------+-----------
  public      | cust_user_info   | table | root  |                   0 | NULL

为避免表不存在时出现错误，语句可以包括IF EXISTS：

alter table if exists cust_info rename to cust_user_info;

RENAME COLUMN

RENAME COLUMN语句用于修改表的字段的名称。

所需权限

要求拥有表的CREATE权限。

语法图

RenameColumnStmt

参数介绍

参数	详情
`IF EXISTS`	仅当具有当前名称的表存在时才重命名该表
`table_name`	表的当前名称
`name`	表中列的名称，在其数据库中必须是唯一的并遵循这些标识符规则。

建表并更改列名

create table user_info (
    id int PRIMARY KEY,
    first_name string,
    last_name string
  );

alter  table user_info rename column last_name to name;

show create table user_info;

  table_name |                create_statement
-------------+-------------------------------------------------
  user_info  | CREATE TABLE public.user_info (
             |     id INT8 NOT NULL,
             |     first_name STRING NULL,
             |     name STRING NULL,
             |     CONSTRAINT "primary" PRIMARY KEY (id ASC),
             |     FAMILY "primary" (id, first_name, name)
             | )

以原子方式添加和重命名列

一些子命令可以在单个ALTER TABLE语句中组合使用。例如，假设创建了一个cust包含2列的表：

create table cust (
    id INT PRIMARY KEY,
    name STRING
  );

要为每个用户的名字、姓氏和全名使用不同的列，因此您执行一条ALTER TABLE语句，将重命名name为last_name和first_name连接的计算列和：

ALTER TABLE cust
    RENAME COLUMN name TO last_name,
    ADD COLUMN first_name STRING,
    ADD COLUMN name STRING
      AS (CONCAT(first_name, ' ', last_name)) STORED;

RENAME SEQUENCE

修改数据库的SEQUENCE名称。

所需权限

要求拥有库的CREATE权限。

语法图

RenameSequenceStmt

参数介绍

参数	详情
`name`	表中序列的名称。

创建序列

show create user_seq;

查看当前库中的SEQUENCE：

select * from information_schema.sequences;

修改SEQUENCE：

alter sequence user_seq rename to cust_seq;

需要确认是否有表依赖于此SEQUENCE，如果依赖不允许重命名。只有没有依赖的SEQUENCE才可以重命名。

RENAME CONSTRAINT

该RENAME CONSTRAINT语句用于修改表中约束名称。

所需权限

要求拥有表的CREATE权限。

语法图

RenameConstraintStmt

参数介绍

参数	详情
`IF EXISTS`	仅当具有当前名称的表存在时才重命名该表
`table_name`	表的当前名称
`name`	表中约束的名称。

建表并查看约束：

create table login_info (
    login_id  int primary key,
    cust_id   int,
    login_date   timestamp,
    unique (cust_id)
  );

show constraints from login_info;

 table_name |    constraint_name     | constraint_type |          details           | validated
-------------+------------------------+-----------------+----------------------------+------------
  login_info | login_info_cust_id_key | UNIQUE          | UNIQUE (cust_id ASC)       |   true
  login_info | primary                | PRIMARY KEY     | PRIMARY KEY (login_id ASC) |   true

修改表的约束名称：

alter table  login_info rename constraint login_info_cust_id_key TO unique_id;

show constraints from login_info;

  table_name | constraint_name | constraint_type |          details           | validated
-------------+-----------------+-----------------+----------------------------+------------
  login_info | primary         | PRIMARY KEY     | PRIMARY KEY (login_id ASC) |   true
  login_info | unique_id       | UNIQUE          | UNIQUE (cust_id ASC)       |   true

SHOW DATABASES

SHOW DATABASES语句查看集群包含的所有数据库。

所需权限

用户必须被授予特定数据库的CONNECT权限才能在Hubble集群中列出这些数据库。

语法图

ShowDatabasesStmt

查看数据库

show databases;

或者

\l;

显示带有注释的数据库

可以使用COMMENT ON在数据库上添加注释

comment on database hdb is '这是一个测试库';

查看数据库的注释：

show databases with comment;

  database_name |                              comment
+---------------+-------------------------------------------------------------------+
  defaultdb     | NULL
  hdb           | 这是一个测试库
  postgres      | NULL
  startrek      | NULL
  system        | NULL

SHOW TABLES

该SHOW TABLES语句列出了模式或数据库中表或视图的模式、表名、表类型、所有者和行数。

所需权限

需要有相关表的数据库的CONNECT权限。

语法图

ShowTablesStmt

参数介绍

参数	详情
`database_name`	要为其显示表的数据库的名称

表现

要优化SHOW TABLES语句的性能可以执行以下操作：

通过在执行SHOW TABLES语句之前将sql.show_tables.estimated_row_count.enabled=false来禁用表行计数显示。
避免SHOW TABLES在具有大量表（例如超过 10000个表）的数据库上运行。

查看当前数据库的表

show tables;

或者

\dt;

查看指定数据库的表

show tables from ora;

显示带有注释的表

show tables from ora with comment;

SHOW COLUMNS

SHOW COLUMNS语句显示有关表中列的详细信息，包括每列的名称、类型、默认值以及它是否可以为空。

所需权限

需要对相关表的数据库的CONNECT权限。

语法图

ShowColumnsStmt

参数介绍

参数	详情
`table_name`	要为其显示列的表的名称

返回参数

参数	详情
`column_name`	列的名称
`data_type`	列的数据类型
`is_nullable`	该列是否接受`NULL` 可能的值：`true`或`false`
`column_default`	列的默认值，或计算结果为默认值的表达式。
`generation_expression`	用于计算列的表达式
`indices`	列所涉及的索引列表，作为一个数组
`is_hidden`	列是否隐藏。可能的值：`true`或`false`

查看一张表中列的详细信息，包括列名、类型、默认值以及是否非空

show columns from  cust_info with comment;

  column_name  |  data_type  | is_nullable | column_default | generation_expression |               indices                | is_hidden |   comment
---------------+-------------+-------------+----------------+-----------------------+--------------------------------------+-----------+---------------
  cust_no      | STRING      |    false    | NULL           |                       | {cust_info_cust_card_no_idx,primary} |   false   | 客户号
  cust_name    | VARCHAR(30) |    false    | NULL           |                       | {}                                   |   false   | 客户姓名
  cust_card_no | VARCHAR(18) |    true     | NULL           |                       | {cust_info_cust_card_no_idx}         |   false   | 客户身份证号
  cust_phoneno | DECIMAL(15) |    true     | NULL           |                       | {}                                   |   false   | 客户手机号
  cust_address | VARCHAR(30) |    true     | NULL           |                       | {}                                   |   false   | 客户所在地
  cust_type    | VARCHAR(10) |    true     | NULL           |                       | {}                                   |   false   | 客户授信类型

显示表中的列

show columns from  cust_info;

或者

\d  cust_info;

SHOW TYPES

该SHOW TYPES语句列出了当前数据库中用户定义的数据类型。

所需权限

需要对相关表的数据库的权限CONNECT。

语法图

ShowTypesStmt

列出了当前数据库中用户定义的数据类型。

show types;

 schema |  name  | owner
---------+--------+--------
  public | status | root

SHOW GRANTS

该SHOW GRANTS声明列出了以下内容之一：

授予集群中用户的角色。
授予用户对数据库、模式、表或用户定义类型的权限。

所需权限

查看授予用户的权限不需要任何权限。

对于SHOW GRANTS ON ROLES，用户必须具有系统表的SELECT权限

语法图

ShowGrantsStmt

参数介绍

参数	详情
`targets`	以逗号分隔的数据库、模式、表或用户定义的类型名称列表
`schema_name`	要为其显示表的模式的名称

列出当前数据库及其表上所有用户和角色的所有授权

show grants;

显示特定用户或角色的授权

create user roc with password roc;

grant all on database ora to roc with grant option;

show grants for roc;

显示数据库的授权

show grants on database ora;

显示所有角色的所有成员

show grants on role;

展示具体表，所有用户和角色

show grants on table cust;

展示所有表、所有用户和角色

show grants on table *;

SHOW INDEX

该SHOW INDEX语句返回表或数据库的索引信息。

所需权限

用户必须对目标表或数据库具有任何特权。

别名

在Hubble中，以下是SHOW INDEX的别名：

SHOW INDEXES
SHOW KEYS

语法图

ShowIndexsStmt

参数介绍

参数	详情
`table_name`	要为其显示索引的表的名称。
`name`	要为其显示表的数据库的名称

返回响应

参数	详情
`table_name`	表的名称。
`index_name`	索引的名称
`non_unique`	索引列中的值是否唯一。可能的值：`true`或`false`
`seq_in_index`	列在索引中的位置，以`1`开头
`column_name`	索引列
`direction`	列在索引中的排序方式。可能的值：`ASC`或`DESC`用于索引列；`N/A`对于存储的列
`storing`	该子句是否在索引创建`STORING`期间用于索引列。可能的值：`true`或`false`

查看表cust_info的索引信息

show index from cust_info;

显示数据库的索引

show index from database ora;

SHOW SCHEMAS

该SHOW SCHEMAS语句列出了数据库中的所有模式。

所需权限

需要数据库CONNECT权限才能列出数据库中的模式。

语法图

ShowSchemasStmt

参数介绍

参数	详情
`name`	要为其显示架构的数据库的名称

查看一个数据库中所有的schemas信息

show schemas;

SHOW SEQUENCE

该SHOW SEQUENCES语句列出了数据库中的所有序列。

所需权限

列出数据库中的序列不需要任何特权。

语法图

ShowSequencesStmt

参数介绍

参数	详情
`name`	要为其显示架构的数据库的名称，省略时，将列出当前数据库中的序列

显示当前可用的SEQUENCE

show  sequences;

SHOW CONSTRAINT

该SHOW CONSTRAINTS语句列出了表上的所有命名约束。

所需权限

用户必须对目标表具有任何特权。

别名

SHOW CONSTRAINT的别名是SHOW CONSTRAINTS。

语法图

ShowConstraintsStmt

参数介绍

参数	详情
`table_name`	要显示约束的表的名称

返回响应

参数	详情
`table_name`	要显示约束的表的名称
`constraint_name`	约束的名称
`constraint_type`	约束的类型
`details`	约束的定义，包括它适用的列
`validated`	列中的值是否与约束匹配

建表语句如下

create table cust_info(
    cust_no       string primary key,
    cust_name     varchar(30) not null,
    cust_card_no  varchar(18),  
    cust_phoneno  decimal(15),
    cust_address  varchar(30),
    cust_type     varchar(10),
    index(cust_card_no)
 );

显示表的约束情况

show  constraint from cust_info;

SHOW PARTITIONS

使用该SHOW PARTITIONS语句查看有关现有分区的详细信息。

所需权限

列出分区不需要特权。

语法图

ShowPartitionsStmt

参数介绍

参数	详情
`database_name`	要为其显示分区的数据库的名称
`table_name`	要显示分区的表的名称
`index_name`	要显示分区的索引的名称

分区表的建立

CREATE TABLE cust_info (
       cust_id INT NOT NULL,
       city VARCHAR(10) NOT NULL,
       cust_name VARCHAR(10) NULL,
       address VARCHAR(10) NULL,
       cust_card VARCHAR(10) NULL,
       CONSTRAINT "primary" PRIMARY KEY (city ASC, cust_id ASC),
       FAMILY "primary" (cust_id, city, cust_name, address, cust_card)
        ) PARTITION BY LIST (city) (
          PARTITION p1 VALUES IN (('shanghai'), ('nanjing')),
          PARTITION p2 VALUES IN (('beijing'), ('tangshan') ),
          PARTITION p3 VALUES IN (('xian'), ('xining')),
          PARTITION DEFAULT VALUES IN (default)
        );

展示分区表

show partitions from table cust_info;

按数据库显示分区

show partitions  from database ora;

SHOW DEFAULT PRIVILEGES

显示默认权限

SHOW DEFAULT PRIVILEGES语句列出了当前数据库中用户或角色创建的对象的默认权限。

所需权限

要显示默认权限，用户、角色必须对当前数据库具有任何权限。

语法图

ShowPrivilegesStmt

参数介绍

参数	详情
`FOR ROLE name/FOR USER name`	列出特定用户、角色创建的对象的默认权限，或用户、角色列表
`FOR ALL ROLES`	列出任何用户、角色创建的对象的默认权限
`role_list`	角色名称

查看默认权限(当前用户)

show default privileges;

显示由任何用户角色创建的对象的默认权限

show default privileges for all roles;

显示由特定用户角色创建的对象的默认权限

show default privileges for  role role_test;

显示特定架构中对象的默认权限

CREATE SCHEMA role_test;

ALTER DEFAULT PRIVILEGES IN SCHEMA test GRANT SELECT ON TABLES TO role_test;

SHOW DEFAULT PRIVILEGES IN SCHEMA role_test;

SHOW ENUMS

该SHOW ENUMS语句列出了当前数据库中的枚举数据类型。

语法图

ShowEnumsStmt

参数介绍

参数	详情
`name/name.name`	从中显示枚举数据类型的模式的名称，或数据库和模式的名称

查看枚举

show  enums from ora.public;

SHOW RANGES

所需权限

要使用该SHOW RANGES语句，用户必须是角色的成员admin(用户默认root属于该角色)或已定义权限。

语法图

ShowRangesStmt

参数介绍

参数	详情
`table_name`	您想要范围信息的表的名称
`table_index_name`	您想要范围信息的索引的名称
`database_name`	您想要范围信息的数据库的名称

查看表的range分区情况

show ranges from table customers_by_range;

SHOW CREATE

该SHOW CREATE语句显示CREATE现有数据库、表、视图或序列的语句。

所需权限

用户必须对目标数据库、表、视图或序列具有任何特权。

语法图

ShowCreateStmt
AllObj

参数介绍

参数	详情
`object_name`	`CREATE`要为其显示语句的数据库、表、视图或序列的名称。
`ALL TABLES`	显示`CREATE`当前数据库中所有表、视图和序列的语句。
`ALL SCHEMAS`	显示当前数据库中所有模式`CREATE`的语句。
`ALL TYPES`	显示当前数据库中所有类型`CREATE`的语句。

SHOW CREATE TABLE，显示创建表的语句

show create table <table_name>;

SHOW CREATE VIEW，显示创建view的create view语句

show create view <viewname>;

SHOW CREATE SEQUENCE，显示特定序列的创建语句

show create sequence <sequencesName>;

显示在当前数据库中重新创建所有表、视图和序列所需的语句

show create all tables;

显示CREATE DATABASE数据库的语句

show create database ora;

显示CREATE SCHEMA数据库中所有模式的语句

show  all schemas;

ALTER TABLE

子命令

参数	详情
`ADD COLUMN`	向表中添加列
`ADD CONSTRAINT`	向列添加约束
`ALTER COLUMN`	更改现有列
`DROP COLUMN`	您想要范围信息的表的名称
`DROP CONSTRAINT`	从表中删除列
`EXPERIMENTAL_AUDIT`	从列中删除约束
`OWNER TO`	更改表的所有者
`PARTITION BY`	对表进行分区、重新分区或取消分区
`RENAME COLUMN`	更改列的名称
`RENAME CONSTRAINT`	更改约束列
`RENAME TO`	更改表的名称
`SET SCHEMA`	更改表的架构
`SPLIT AT`	强制在表中的指定行进行范围拆分
`UNSPLIT AT`	删除表中指定行的范围拆分强制
`VALIDATE CONSTRAINT`	检查列中的值是否与列上的约束匹配
`SET (storage parameter)`	在表上设置存储参数