暂无图片
暂无图片
暂无图片
暂无图片
暂无图片
首页 / openGauss查询语句

openGauss查询语句

原创 酷哥 2022-04-15
424

查看对象

  • 查询所有数据库
\l

示例如下。

openGauss=# \l
                          List of databases
   Name    | Owner | Encoding  | Collate | Ctype | Access privileges
-----------+-------+-----------+---------+-------+-------------------
 mydb      | omm   | GBK       | C       | C     |
 postgres  | omm   | SQL_ASCII | C       | C     |
 template0 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
 template1 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
(4 rows)
  • 查询当前数据库中的所有表
\dt

示例如下。

openGauss=# \dt
                              List of relations
 Schema |      Name       | Type  | Owner |             Storage
--------+-----------------+-------+-------+----------------------------------
 public | customer_t1     | table | omm   | {orientation=row,compression=no}
 public | customer_t1_bak | table | omm   | {orientation=row,compression=no}
(2 rows)
  • 查看表结构
\d tablename

例如，查看表customer_t1的表结构。

openGauss=# \d customer_t1
        Table "public.customer_t1"
    Column     |     Type     | Modifiers
---------------+--------------+-----------
 c_customer_sk | integer      |
 c_customer_id | character(5) |
 c_first_name  | character(6) |
 c_last_name   | character(8) |
 amount        | integer      |


读取数据

SELECT语句用于从表或视图中取出数据，结果被存储在一个结果表中，称为结果集。

SELECT语句就像叠加在数据库表上的过滤器，利用SQL关键字从数据表中过滤出用户需要的数据。

语法格式

SELECT 
{ * | [column, ...] }
[ FROM from_item [, ...] ];

参数说明

  • SELECT列表

    指定查询表中列名，可以是部分列或者是全部，通配符*表示全部列。

    列名可以用下面两种形式表达：

    • 手动输入列名，多个列之间用英文逗号（,）分隔。
    • 可以是FROM子句里面计算出来的字段。

  • FROM子句

    为SELECT声明一个或者多个源表。FROM子句涉及多个元素，常见元素如下。

    • table_name

      表名或视图名，名称前可加上模式名，如：schema_name.table_name。表名为最常见的元素。

    • subquery

      FROM子句中可以出现子查询，创建一个临时表保存子查询的输出。

    • alias

      给表或复杂的表引用起一个临时的表别名，以便被其余的查询引用。

    • join_type

      有5种类型。

示例

  • 读取表customer_t1中所有的数据。

openGauss=# SELECT * FROM customer_t1;
c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          3869 | hello         | Grace        |             |   1000
          3869 | hello         | Grace        |             |   1000
          3869 |               | Grace        |             |
          3869 | hello         |              |             |
          3869 | hello         |              |             |
               |               |              |             |
          6985 | maps          | Joes         |             |   2200
          9976 | world         | James        |             |   5000
          4421 | Admin         | Local        |             |   3000
(9 rows)

  • 读取表customer_t1中指定字段c_customer_sk、c_customer_id。

openGauss=# SELECT c_customer_sk,c_customer_id FROM customer_t1;
c_customer_sk | c_customer_id
---------------+---------------
          3869 | hello
          3869 | hello
          3869 |
          3869 | hello
          3869 | hello
               |
          6985 | maps
          9976 | world
          4421 | Admin
(9 rows)


获取指定条件的数据

当我们需要根据指定条件从表中查询数据时，就可以在SELECT语句中添加WHERE子句，从而过滤掉我们不需要数据。WHERE子句构成一个行选择表达式，用于指定条件而获取的数据，如果给定的条件满足，才返回从表中的具体数值。

语法格式

SELECT 
{ * | [column, ...] }
[ FROM from_item [, ...] ]
[ WHERE condition ];

参数说明

  • WHERE子句

    WHERE子句构成一个行选择表达式，用来缩小SELECT查询的范围。在WHERE子句中可以使用比较运算符或逻辑运算符，例如 >, <, =, LIKE, NOT 等等。

  • condition

    condition是返回值为布尔型的任意表达式，任何不满足该条件的行都不会被检索。

示例

使用逻辑运算符读取表customer_t1。

  • AND

    找到c_customer_id为hello且c_customer_sk为3869的行。

openGauss=# SELECT * FROM customer_t1 WHERE  c_customer_sk = 3869 AND c_customer_id = 'hello';
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          3869 | hello         | Grace        |             |   1000
          3869 | hello         | Grace        |             |   1000
          3869 | hello         |              |             |
          3869 | hello         |              |             |
(4 rows)

  • OR

找到c_customer_sk大于6985或者c_customer_id为hello的行。

openGauss=# SELECT * FROM customer_t1 WHERE  c_customer_sk > 6985 OR c_customer_id = 'hello';
c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          3869 | hello         | Grace        |             |   1000
          3869 | hello         | Grace        |             |   1000
          3869 | hello         |              |             |
          3869 | hello         |              |             |
          9976 | world         | James        |             |   5000
(5 rows)

  • NOT NULL

找到customer_t1中c_last_name字段不为空的行。

openGauss=# SELECT * FROM customer_t1 WHERE  c_last_name IS NOT NULL;
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
(0 rows)

  • BETWEEN

找到c_customer_sk在4000和9000之间的行。

openGauss=# SELECT * FROM customer_t1 WHERE  c_customer_sk  BETWEEN 4000 AND 9000;
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          6985 | maps          | Joes         |             |   2200
          4421 | Admin         | Local        |             |   3000
(2 rows)


对查询结果进行排序

ORDER BY对对SELECT语句检索得到的一列或者多列数据进行升序（ASC）或者降序（DESC）排列。

语法格式

SELECT 
{ * | [column, ...] }
[ FROM from_item [, ...] ]
[ ORDER BY {expression [ ASC | DESC ] }];

参数说明

  • ORDER BY子句

    对SELECT语句检索得到的数据进行升序或降序排序。对于ORDER BY表达式中包含多列的情况：

    • 首先根据最左边的列进行排序，如果这一列的值相同，则根据下一个表达式进行比较，依此类推。
    • 如果对于所有声明的表达式都相同，则按随机顺序返回。

示例

  • 对结果根据c_customer_sk字段值进行升序排列。

openGauss=# SELECT * FROM customer_t1 ORDER BY c_customer_sk ASC;
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          3869 | hello         | Grace        |             |   1000
          3869 | hello         | Grace        |             |   1000
          3869 |               | Grace        |             |
          3869 | hello         |              |             |
          3869 | hello         |              |             |
          4421 | Admin         | Local        |             |   3000
          6985 | maps          | Joes         |             |   2200
          9976 | world         | James        |             |   5000
               |               |              |             |
(9 rows)

  • 对结果根据c_customer_sk字段值进行降序排列。

openGauss=# SELECT * FROM customer_t1 ORDER BY c_customer_sk DESC;
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
               |               |              |             |
          9976 | world         | James        |             |   5000
          6985 | maps          | Joes         |             |   2200
          4421 | Admin         | Local        |             |   3000
          3869 | hello         | Grace        |             |   1000
          3869 | hello         |              |             |
          3869 | hello         | Grace        |             |   1000
          3869 |               | Grace        |             |
          3869 | hello         |              |             |
(9 rows)

去除重复记录

DISTINCT关键字与SELECT语句一起使用，用于去除重复记录，只获取唯一的记录。

当一个表中有多个重复记录，当提取这样的记录时，DISTINCT关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。

语法格式

SELECT  DISTINCT [ ON ( expression [, ...] ) ] ]
{ * | [column, ...] }
[ FROM from_item [, ...] ];

参数说明

  • DISTINCT [ ON ( expression [, …] ) ]

从SELECT的结果集中删除所有重复的行，使结果集中的每行都是唯一的。

ON ( expression [, …] ) 只保留那些在给出的表达式上运算出相同结果的行集合中的第一行。

示例

在表customer_t1中插入两条数据：

openGauss=# INSERT INTO customer_t1 (c_customer_sk, c_customer_id, c_first_name,Amount) VALUES 
    (6881, 'maps', 'Lily',1000),
    (4320, 'tpcds', 'Lily',2000);

现在数据如下：

openGauss=# SELECT * FROM customer_t1 ;
 c_customer_sk | c_customer_id | c_first_name | c_last_name | amount
---------------+---------------+--------------+-------------+--------
          3869 | hello         | Grace        |             |   1000
          3869 | hello         | Grace        |             |   1000
          3869 |               | Grace        |             |
          3869 | hello         |              |             |
          3869 | hello         |              |             |
               |               |              |             |
          6985 | maps          | Joes         |             |   2200
          9976 | world         | James        |             |   5000
          4421 | Admin         | Local        |             |   3000
          6881 | maps          | Lily         |             |   1000
          4320 | tpcds         | Lily         |             |   2000
(11 rows)

查询customer_t1表中所有的c_first_name。其中存在两个Lily和三个Grace。

openGauss=# SELECT c_first_name  FROM customer_t1 ;
 c_first_name
--------------
 Grace
 Grace
 Grace



 Joes
 James
 Local
 Lily
 Lily
(11 rows)

在SELECT语句中使用DISTINCT关键字。从结果中可以发现，重复数据已经被删除。

openGauss=# SELECT DISTINCT c_first_name  FROM customer_t1 ;
 c_first_name
--------------
 James
 Grace
 Local

 Joes
 Lily
(6 rows)

对相同的数据进行分组

GROUP BY语句和SELECT语句一起使用，用来对相同的数据进行分组。您可以对一列或者多列进行分组，但是被分组的列必须存在。

语法格式

SELECT 
{ * | [column, ...] }
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY grouping_element [, ...] ]
[ ORDER BY {expression [ ASC | DESC ] }];

参数说明

  • GROUP BY子句

    将查询结果按某一列或多列的值分组，值相等的为一组。

    GROUP BY在一个SELECT语句中，放在WHRER子句的后面，ORDER BY 句的前面。

示例

表customer_t1中存在重复的c_first_name，根据c_first_name字段分组，并求和Amount。

openGauss=# SELECT c_first_name, sum(Amount)  FROM customer_t1 GROUP BY c_first_name;
 c_first_name | sum
--------------+------
 James        | 5000
 Grace        | 1000
 Local        | 3000
              |
 Joes         | 2200
 Lily         | 3000
(6 rows)

筛选分组后的各组数据

HAVING子句可以让我们筛选分组后的各组数据。

WHERE子句在所选列上设置条件，而HAVING子句则在由GROUP BY子句创建的分组上设置条件。

语法格式

SELECT 
{ * | [column, ...] }
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY grouping_element [, ...] ]
[ HAVING condition [, ...] ]
[ ORDER BY {expression [ ASC | DESC ] }];

参数说明

  • HAVING子句

    与GROUP BY子句配合用来选择特殊的组。HAVING子句将组的一些属性与一个常数值比较，只有满足HAVING子句中的逻辑表达式的组才会被提取出来。

示例

下面实例将找出根据c_first_name字段值进行分组，并且c_first_name字段的计数少于 2 数据：

openGauss=# SELECT c_first_name FROM customer_t1 GROUP BY c_first_name HAVING count(c_first_name) < 2;

结果如下。

 c_first_name
--------------
 James
 Local

 Joes
(4 rows)

下面实例将找出根据c_first_name字段值进行分组，并且名称的计数大于1数据：

openGauss=# SELECT c_first_name FROM customer_t1 GROUP BY c_first_name HAVING count(c_first_name) > 1;

结果如下。

 c_first_name
--------------
 Grace
 Lily
(2 rows)













opengauss查询语法
「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」
关注作者
【版权声明】本文为墨天轮用户原创内容，转载时必须标注文章的来源（墨天轮），文章链接，文章作者等基本信息，否则作者和墨天轮有权追究责任。如果您发现墨天轮中有涉嫌抄袭或者侵权的内容，欢迎发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

评论