Impala 简明教程

Impala - Quick Guide

Impala - Introduction

What is Impala?

Impala 是一个 MPP（大规模并行处理）SQL 查询引擎，用于处理存储在 Hadoop 集群中的海量数据。它是一个用 C++ 和 Java 编写的开源软件。与其他用于 Hadoop 的 SQL 引擎相比，它提供了高性能和低延迟。

换句话说，Impala 是性能最高的 SQL 引擎（提供了类似 RDBMS 的体验），它提供了访问存储在 Hadoop 分布式文件系统中的数据的最快方式。

Why Impala?

Impala 通过利用 HDFS、HBase、元存储、YARN 和 Sentry 等标准组件，将传统分析数据库的 SQL 支持和多用户性能与 Apache Hadoop 的可扩展性和灵活性相结合。

使用 Impala，用户可以用 SQL 查询的方式与 HDFS 或 HBase 通信，与 Hive 等其他 SQL 引擎相比，速度更快。
Impala 可以读取 Hadoop 使用的几乎所有文件格式，如 Parquet、Avro、RCFile。

Impala 使用与 Apache Hive 相同的元数据、SQL 语法（Hive SQL）、ODBC 驱动程序和用户界面（Hue Beeswax），为面向批处理或实时查询提供了一个熟悉且统一的平台。

与 Apache Hive 不同， Impala is not based on MapReduce algorithms 。它实现了一个基于 daemon processes 的分布式架构，负责查询执行的所有方面，这些方面在同一台机器上运行。

因此，它减少了利用 MapReduce 的延迟，这使得 Impala 比 Apache Hive 更快。

Advantages of Impala

以下是 Cloudera Impala 的一些公认优点。

使用 Impala，你可以使用传统的 SQL 知识以闪电般的速度处理存储在 HDFS 中的数据。
由于数据处理会在数据所在的位置（在 Hadoop 集群）执行，因此，在使用 Impala 时，无需对存储在 Hadoop 上的数据进行数据转换和数据移动。
使用 Impala，您可以访问存储在 HDFS、HBase 和 Amazon s3 中的数据，而无需学习 Java（MapReduce 作业）。您可以使用基本的 SQL 查询概念来访问。
要在业务工具中编写查询，必须通过复杂的提取-转换-加载 (ETL) 周期来处理数据。但是，使用 Impala，这个过程被缩短了。借助于 exploratory data analysis & data discovery 之类的新技术，加载和重新组织等耗时的阶段得以克服，从而加快了这一过程。
Impala 率先使用了 Parquet 文件格式，这是一种面向数据仓库方案中的大规模查询进行了优化的列式存储布局。

Features of Impala

下面给出 Cloudera Impala 的功能：

Impala 作为开源软件在 Apache 许可下免费提供。
Impala 支持内存数据处理，即它访问/分析存储在 Hadoop 数据节点上而不用移动数据的数据。
您可以使用类似于 SQL 的查询通过 Impala 来访问数据。
和其它 SQL 引擎相比，Impala 可以提供对 HDFS 中数据的更快访问。
使用 Impala，您可以将数据存储在 HDFS、Apache HBase 和 Amazon s3 等存储系统中。
您可以将 Impala 与 Tableau、Pentaho、Microstrategy 和 Zoom Data 等商业智能工具集成在一起。
Impala 支持 LZO、Sequence File、Avro、RCFile 和 Parquet 等各种文件格式。
Impala 使用 Apache Hive 中的元数据、ODBC 驱动程序和 SQL 语法。

Relational Databases and Impala

Impala 使用类似于 SQL 和 HiveQL 的查询语言。下表描述了 SQL 与 Impala 查询语言之间的部分主要差异。

Impala

Relational databases

Impala 使用了类似于 HiveQL 的类似于 SQL 的查询语言。

关系数据库使用 SQL 语言。

在 Impala 中，您不能更新或删除单个记录。

在关系数据库中，可以更新或删除单个记录。

Impala 不支持事务。

Relational databases support transactions.

Impala 不支持索引。

Relational databases support indexing.

Impala 存储和管理海量数据（PB 级）。

与 Impala 相比，关系数据库处理较少量的数据（TB 级）。

Hive, Hbase, and Impala

虽然 Cloudera Impala 使用了与 Hive 相同的查询语言、元存储和用户界面，但它在某些方面与 Hive 和 HBase 不同。下表展示了 HBase、Hive 和 Impala 之间的对比分析。

HBase

Hive

Impala

HBase 是基于 Apache Hadoop 的宽列存储数据库。它使用 BigTable 的概念。

Hive 是一个数据仓库软件。我们可以使用它来访问和管理建立在 Hadoop 之上的大型分布式数据集。

Impala 是一个用于管理和分析存储在 Hadoop 之上的数据的工具。

HBase 的数据模型是宽列存储。

Hive follows Relational model.

Impala follows Relational model.

HBase 是使用 Java 语言开发的。

Hive 是使用 Java 语言开发的。

Impala 是使用 C++ 开发的。

HBase 的数据模型是无模式的。

Hive 的数据模型是基于模式的。

Impala 的数据模型是基于模式的。

HBase 提供了 Java、RESTful 和 Thrift API。

Hive 提供了 JDBC、ODBC、Thrift API。

Impala 提供 JDBC 和 ODBC API。

支持 C、C#、C++、Groovy、Java PHP、Python 和 Scala 等编程语言。

支持 C++、Java、PHP 和 Python 等编程语言。

Impala 支持所有支持 JDBC/ODBC 的语言。

HBase 支持触发器。

Hive 不支持任何触发器。

Impala 也不支持任何触发器。

全部这三个数据库 −

Are NOSQL databases.
Available as open source.
Support server-side scripting.
遵循 ACID 属性，例如，持久性和并发性。
Use sharding for partitioning.

Drawbacks of Impala

使用 Impala 的一些缺点如下 −

Impala 不支持序列化和反序列化。
Impala 只能读取文本文件，不能读取自定义二进制文件。
每当将新的记录/文件添加到 HDFS 中的数据目录时，都需要刷新表格。

Impala - Environment

本章介绍了安装 Impala 的前提条件，以及如何在系统中下载、安装和设置 Impala 。

与 Hadoop 及其生态系统软件类似，我们需要在 Linux 操作系统上安装 Impala。由于 Cloudera 装运了 Impala，因此可以与 Cloudera Quick Start VM. 一起使用。

本章描述了如何下载 Cloudera Quick Start VM 并启动 Impala。

Downloading Cloudera Quick Start VM

按照以下步骤下载 Cloudera QuickStartVM 的最新版本。

Step 1

打开 Cloudera 网站主页 http://www.cloudera.com/ 。你将获得如下所示的页面。

Step 2

单击 Cloudera 主页上的 Sign in 链接，该链接将重定向你到以下所示的登录页面。

如果你尚未注册，请单击 Register Now 链接，该链接将为你提供 Account Registration 表单。注册并登录到 Cloudera 帐户。

Step 3

登录后，通过单击以下快照中突出显示的 Downloads 链接打开 Cloudera 网站的下载页面。

Step 4 - Download QuickStartVM

通过单击以下快照中突出显示的 Download Now 按钮下载 Cloudera QuickStartVM 。

这将重定向你到 QuickStart VM 的下载页面。

单击 Get ONE NOW 按钮，接受许可协议，然后单击提交按钮，如下所示。

Cloudera 提供了与其 VM 兼容的 VMware、KVM 和 VIRTUALBOX。选择所需的版本。本教程中，我们将使用虚拟机演示 Cloudera QuickStartVM 设置，因此请单击 VIRTUALBOX DOWNLOAD 按钮，如以下快照所示。

这将开始下载一个名为 cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf 的文件，这是一个虚拟机映像文件。

Importing the Cloudera QuickStartVM

下载 cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf 文件后，我们需要使用虚拟机导入该文件。为此，首先，你需在你的系统中安装虚拟机。按照以下步骤操作以导入已下载的映像文件。

Step 1

从以下链接下载虚拟机并安装它 https://www.virtualbox.org/

Step 2

打开虚拟机软件。单击 File 并选择 Import Appliance ，如下所示。

Step 3

单击 Import Appliance 后，将获得导入虚拟设备窗口。选择下载的映像文件的位置，如下所示。

导入 Cloudera QuickStartVM 映像后，启动虚拟机。此虚拟机已安装 Hadoop、Cloudera Impala 和所有必需的软件。以下显示 VM 的快照。

Starting Impala Shell

要启动 Impala，可打开终端并执行以下命令。

[cloudera@quickstart ~] $ impala-shell

这将启动 Impala Shell，显示以下消息。

Starting Impala Shell without Kerberos authentication
Connected to quickstart.cloudera:21000
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build
0c891d79aa38f297d244855a32f1e17280e2129b)
********************************************************************************
 Welcome to the Impala shell. Copyright (c) 2015 Cloudera, Inc. All rights reserved.
(Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9 12:18:12 PST 2015)

Press TAB twice to see a list of available commands.
********************************************************************************
[quickstart.cloudera:21000] >

Note − 我们将在后面的章节中讨论所有 Impala Shell 命令。

Impala Query editor

除了 Impala shell 以外，你还可以使用 Hue 浏览器与 Impala 进行通信。在安装 CDH5 并启动 Impala 后，如果你打开你的浏览器，你将获得 Cloudera 主页，如下所示。

现在，单击书签 Hue 以打开 Hue 浏览器。单击后，你可以看到 Hue 浏览器的登录页面，使用 cloudera 和 cloudera 凭据登录。

一旦你登录到 Hue 浏览器，你就可以看到 Hue 浏览器的快速入门向导，如下所示。

单击 Query Editors 下拉菜单后，你将获得 Impala 支持的编辑器列表，如以下屏幕截图中所示。

单击下拉菜单中的 Impala 后，你将获得 Impala 查询编辑器，如下所示。

Impala - Architecture

Impala 是在 Hadoop 集群中的多个系统上运行的多重并行处理 (MPP) 查询执行引擎。Impala 与其存储引擎分离，这不同于传统存储系统。它有三个主要组件，分别是 Impala 守护程序 (Impalad)、Impala 状态存储和 Impala 元数据或元存储。

Impala daemon(Impalad)

Impala 守护程序（也称为 impalad ）在已安装 Impala 的每个节点上运行。它接受来自各种界面的查询，如 Impala shell、hue 浏览器等，并对其进行处理。

如果将某个查询提交给某个节点上的 Impala，该节点将充当该查询的“ coordinator node ”。由其他节点上运行的 Impala 处理多个查询。在接受查询后，Impala 读取和写入数据文件，并通过将工作分配给 Impala 群集中其他 Impala 节点来并行化查询。当查询在多个 Impala 实例上进行处理时，所有查询都将结果返回给中央协调节点。

根据需要，可以将查询提交到专用 Impala，也可以以负载平衡的方式提交到群集中的另外一个 Impala。

Impala State Store

Impala 有一个称为 Impala 状态存储的其他重要组件，负责检查每个 Impala 的运行状况，然后频繁地向其他守护程序转达每个 Impala 守护程序的运行状况。它可以在运行 Impala 服务器的同一节点或群集内的其他节点上运行。

Impala 状态存储守护程序进程的名称是状态存储。Impalad 将其运行状况报告给 Impala 状态存储守护程序（即状态存储）。

如果由于任何原因发生节点故障，状态存储会将此故障更新到所有其他节点，一旦其他 impalad 获得此类通知，没有其他 Impala 守护程序会将任何进一步的查询分配给受影响的节点。

Impala Metadata & Meta Store

Impala 元数据和元存储是另一个重要组件。Impala 使用传统的 MySQL 或 PostgreSQL 数据库来存储表定义。表和列信息和表定义等重要详细信息存储在称为元存储的集中式数据库中。

每个 Impala 节点都会在本地缓存所有元数据。在处理极大量的数据和/或大量分区时，获取特定表的元数据可能需要花费大量时间。因此，本地存储的元数据缓存有助于即时提供此类信息。

当表定义或表数据更新时，其他 Impala 守护程序必须通过在针对相关表发出新查询之前检索最新的元数据来更新它们的元数据缓存。

Query Processing Interfaces

为了处理查询，Impala 提供了以下三个接口。

Impala-shell − 使用 Cloudera VM 设置 Impala 之后，可以通过在编辑器中键入命令 impala-shell 来启动 Impala 外壳。我们将在后面的章节中讨论有关 Impala 外壳的更多信息。
Hue interface − 可以使用 Hue 浏览器处理 Impala 查询。在 Hue 浏览器中，提供了 Impala 查询编辑器，您可以在其中键入并执行 Impala 查询。要访问此编辑器，首先需要登录到 Hue 浏览器。
ODBC/JDBC drivers − 就像其他数据库一样，Impala 提供 ODBC/JDBC 驱动程序。使用这些驱动程序，可以通过支持这些驱动程序的编程语言连接到 Impala，并构建使用这些编程语言处理 Impala 中查询的应用程序。

Query Execution Procedure

每当用户使用所提供的任何接口传递查询时，该查询将被集群中的 Impala 之一接受。该 Impala 被视为该特定查询的协调器。

在接收到查询后，查询协调器使用来自 Hive 元存储的 Table Schema 验证查询是否适当。稍后，它从 HDFS 名称节点收集执行查询所需数据的所在位置的信息，并将此信息发送到其他 impalad 以执行查询。

所有其他 Impala 守护程序读取指定的数据块并处理查询。当所有守护程序完成其任务后，查询协调器将收集结果并将其传递给用户。

Impala - Shell

在前面的章节中，我们已经学习了使用 Cloudera 安装 Impala 及其架构。

Impala shell (command prompt)
Hue (User Interface)
ODBC 和 JDBC（第三方库）

本章说明了如何启动 Impala Shell 以及 Shell 的各种选项。

Impala Shell Command Reference

Impala Shell 的命令分为 general commands, query specific options 和 table and database specific options ，如下所示。

General Commands

help
version
history
shell (or) !
connect
exit | quit

Query specific options

Set/unset
Profile
Explain

Table and Database specific options

Alter
describe
drop
insert
select
show
use

Starting Impala Shell

打开 Cloudera 终端，以超级用户身份登录，然后键入 cloudera 作为密码，如下所示。

[cloudera@quickstart ~]$ su
Password: cloudera
[root@quickstart cloudera]#

键入以下命令启动 Impala Shell −

[root@quickstart cloudera] # impala-shell
Starting Impala Shell without Kerberos authentication
Connected to quickstart.cloudera:21000
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE
(build 0c891d79aa38f297d244855a32f1e17280e2129b)
*********************************************************************

Welcome to the Impala shell. Copyright (c) 2015 Cloudera, Inc. All rights reserved.
(Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9 12:18:12 PST 2015)

Want to know what version of Impala you're connected to? Run the VERSION command to
find out!
*********************************************************************
[quickstart.cloudera:21000] >

Impala – General Purpose Commands

以下详解 Impala 的通用命令 −

help command

Impala shell 的 help 命令提供 Impala 中可用命令的列表 −

[quickstart.cloudera:21000] > help;

Documented commands (type help <topic>):
========================================================
compute  describe  insert  set     unset  with  version
connect  explain   quit    show    values use
exit     history   profile select  shell  tip

Undocumented commands:
=========================================
alter create desc drop help load summary

version command

version 命令提供当前的 Impala 版本，如下所示。

[quickstart.cloudera:21000] > version;
Shell version: Impala Shell v2.3.0-cdh5.5.0 (0c891d7) built on Mon Nov 9
12:18:12 PST 2015

Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build
0c891d79aa38f297d244855a32f1e17280e2129b)

history command

Impala 的 history 命令显示在 shell 中执行的最后 10 条命令。以下是 history 命令的示例。在此例中，我们执行了 5 个命令：版本、帮助、显示、使用和历史记录。

[quickstart.cloudera:21000] > history;
[1]:version;
[2]:help;
[3]:show databases;
[4]:use my_db;
[5]:history;

quit/exit command

你可以使用 quit 或 exit 命令退出 Impala shell，如下所示。

[quickstart.cloudera:21000] > exit;
Goodbye cloudera

connect command

connect 命令用于连接到 Impala 的特定实例。如果你未指定任何实例，则会连接到默认端口 21000 ，如下所示。

[quickstart.cloudera:21000] > connect;
Connected to quickstart.cloudera:21000
Server version: impalad version 2.3.0-cdh5.5.0 RELEASE (build
0c891d79aa38f297d244855a32f1e17280e2129b)

Impala Query Specific Options

Impala 的查询特定命令接受查询。它们如下所示 −

Explain

explain 命令返回给定查询的执行计划。

[quickstart.cloudera:21000] > explain select * from sample;
Query: explain select * from sample
+------------------------------------------------------------------------------------+
| Explain String                                                                     |
+------------------------------------------------------------------------------------+
| Estimated Per-Host Requirements: Memory = 48.00MB VCores = 1                       |
| WARNING: The following tables are missing relevant table and/or column statistics. |
| my_db.customers                                                                    |
| 01:EXCHANGE [UNPARTITIONED]                                                        |
| 00:SCAN HDFS [my_db.customers]                                                     |
| partitions = 1/1 files = 6 size = 148B                                             |
+------------------------------------------------------------------------------------+
Fetched 7 row(s) in 0.17s

Profile

profile 命令显示有关最近查询的底层信息。此命令用于诊断和执行查询性能调优。以下是 profile 命令的示例。在此场景中， profile 命令返回 explain 查询的底层信息。

[quickstart.cloudera:21000] > profile;

Query Runtime Profile:
Query (id=164b1294a1049189:a67598a6699e3ab6):

   Summary:
      Session ID: e74927207cd752b5:65ca61e630ad3ad
      Session Type: BEESWAX
      Start Time: 2016-04-17 23:49:26.08148000 End Time: 2016-04-17 23:49:26.2404000
      Query Type: EXPLAIN
      Query State: FINISHED
      Query Status: OK
      Impala Version: impalad version 2.3.0-cdh5.5.0 RELEASE (build 0c891d77280e2129b)
      User: cloudera
      Connected User: cloudera
      Delegated User:
      Network Address:10.0.2.15:43870
      Default Db: my_db
      Sql Statement: explain select * from sample
      Coordinator: quickstart.cloudera:22000
      : 0ns
      Query Timeline: 167.304ms
         - Start execution: 41.292us (41.292us) - Planning finished: 56.42ms (56.386ms)
         - Rows available: 58.247ms (1.819ms)
         - First row fetched: 160.72ms (101.824ms)
         - Unregister query: 166.325ms (6.253ms)

   ImpalaServer:
      - ClientFetchWaitTimer: 107.969ms
      - RowMaterializationTimer: 0ns

Table and Database Specific Options

下表列出了 Impala 中的表和数据特定选项。

Sr.No	Command & Explanation
1	Alter The alter 命令用于更改 Impala 中表的结构和名称。
2	Impala 的 Describe 命令提供表的元数据。它包含列及其数据类型等信息。 describe 命令的简写为 desc 。
3	Drop 命令用于从 Impala 中删除构造，其中构造可以是表、视图或数据库函数。
4	Impala 的 insert 命令用于将数据（列）追加到表中。覆盖现有表的数据。覆盖现有表的数据。
5	select 语句用于对特定数据集执行所需的操作。它指定要完成某个操作的数据集。你可以打印或存储（在文件中）select 语句的结果。
6	Impala 的 show 语句用于显示各种构造（例如表、数据库和表）的元存储。
7	Impala 的 use 语句用于将当前上下文更改为所需数据库。

Impala - Query Language Basics

Impala Data types

下表描述了 Impala 数据类型。

Sr.No	Data Type & Description
1	BIGINT 此数据类型存储数值，且此数据类型的范围为 -9223372036854775808 到 9223372036854775807。此数据类型用于 create table 和 alter table 语句。
2	BOOLEAN 此数据类型仅存储 true 或 false 值，用于 create table 语句的列定义中。
3	CHAR 此数据类型是一个固定长度存储，用空格填充，最多可以存储 255 个字符。
4	DECIMAL 此数据类型用于存储小数，可在 create table 和 alter table 语句中使用。
5	DOUBLE 此数据类型用于存储正值或负值在 4.94065645841246544e-324d -1.79769313486231570e+308 之间的浮点数。
6	FLOAT 此数据类型用于存储正值或负值在 1.40129846432481707e-45 .. 3.40282346638528860e+38 之间的单精度浮点数数据类型。
7	INT 此数据类型用于存储最大范围 -2147483648 到 2147483647 的 4 字节整数。
8	SMALLINT 此数据类型用于存储最大范围 -32768 到 32767 的 2 字节整数。
9	STRING 用于存储字符串值。
10	TIMESTAMP 此数据类型用于表示时间中的点。
11	TINYINT 此数据类型用于存储最大范围 -128 到 127 的 1 字节整数。
12	VARCHAR 此数据类型用于存储字符，其最大长度为 65,535。
13	ARRAY 此为复杂数据类型，用于存储可变数量的排序元素。
14	Map 此为复杂数据类型，用于存储可变数量的关键值对。
15	Struct 此为复杂数据类型，用于表示单个项目的多个字段。

Comments in Impala

Impala 中的注释类似于 SQL 中的注释。通常我们在编程语言中有两种类型的注释，即单行注释和多行注释。

Single-line comments − Impala 中紧随“——”之后的每行都被视为注释。以下为 Impala 中单行注释的示例。

-- Hello welcome to tutorials point.

Multiline comments − Impala 中 / 和 / 之间的所有行都被视为多行注释。以下为 Impala 中多行注释的示例。

/*
Hi this is an example
Of multiline comments in Impala
*/

Impala 中的操作符类似于 SQL 中的操作符。请通过单击以下链接查看我们的 SQL 教程 [role="bare"]../sql/sql-operators.htmlsql-operators.

Impala - Create a Database

在 Impala 中，数据库是一种结构，用于在其命名空间内保存相关的表、视图和函数。它表示为 HDFS 中的目录树；它包含表分区和数据文件。本章介绍如何在 Impala 中创建数据库。

CREATE DATABASE Statement

CREATE DATABASE Statement 用于在 Impala 中创建新数据库。

Syntax

以下是 CREATE DATABASE 语句的语法。

CREATE DATABASE IF NOT EXISTS database_name;

此处 IF NOT EXISTS 是一个可选子句。如果我们使用此子句，则仅当不存在具有相同名称的现有数据库时，才会创建一个指定名称的数据库。

Example

以下是 create database statement 的示例。在此示例中，我们使用 my_database. 该名称创建了一个数据库。

[quickstart.cloudera:21000] > CREATE DATABASE IF NOT EXISTS my_database;

在 cloudera impala-shell 中执行上述查询后，你将获得以下输出。

Query: create DATABASE my_database

Fetched 0 row(s) in 0.21s

Verification

SHOW DATABASES 查询提供了 Impala 中的数据库列表，因此你可以使用 SHOW DATABASES 语句来验证是否创建了数据库。在此处，你可以观察列表中新创建的数据库 my_db 。

[quickstart.cloudera:21000] > show databases;

Query: show databases
+-----------------------------------------------+
| name                                          |
+-----------------------------------------------+
| _impala_builtins                              |
| default                                       |
|  my_db                                        |
+-----------------------------------------------+
Fetched 3 row(s) in 0.20s
[quickstart.cloudera:21000] >

Hdfs Path

为了在 HDFS 文件系统中创建数据库，你需要指定要创建数据库的位置。

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Creating a Database using Hue Browser

打开 Impala Query 编辑器，并在其中键入 CREATE DATABASE 的语句。然后，像以下屏幕截图中所示的那样，单击“执行”按钮。

执行查询后，将光标轻轻移动到下拉菜单的顶部，将看到一个刷新符号。如果你单击刷新符号，数据库列表将会刷新，最近的更改将应用到其中。

Verification

单击编辑器左侧标题 DATABASE 下的 drop-down box 。在那里，你可以看到系统中的数据库列表。在此处，你可以观察如下所示的新创建的数据库 my_db 。

如果你仔细观察，可以看到列表中只有一个数据库，即 my_db 连同默认数据库。

Impala - Drop a Database

Impala 的 DROP DATABASE Statement 用于从 Impala 中删除数据库。在删除数据库之前，建议先从数据库中移除所有表。

Syntax

以下是 DROP DATABASE 语句的语法。

DROP (DATABASE|SCHEMA) [IF EXISTS] database_name [RESTRICT |
CASCADE] [LOCATION hdfs_path];

此处， IF EXISTS 是一个可选子句。如果我们在具有给定名称的数据库存在时使用此子句，则将删除该数据库。如果没有具有给定名称的现有数据库，则不会执行任何操作。

Example

以下是 DROP DATABASE 语句的一个示例。假设您在 Impala 中有一个名为 sample_database 的数据库。

此外，如果您使用 SHOW DATABASES 语句验证数据库列表，您将在其中观察到名称。

[quickstart.cloudera:21000] > SHOW DATABASES;

Query: show DATABASES
+-----------------------+
| name                  |
+-----------------------+
| _impala_builtins      |
| default               |
| my_db                 |
| sample_database       |
+-----------------------+
Fetched 4 row(s) in 0.11s

现在，您可以使用 DROP DATABASE Statement 删除此数据库，如下所示。

 < DROP DATABASE IF EXISTS sample_database;

这将删除指定的数据库并给您以下输出。

Query: drop DATABASE IF EXISTS sample_database;

Verification

您可以使用 SHOW DATABASES 语句验证给定的数据库是否已删除。在这里，您可以观察到名为 sample_database 的数据库已从数据库列表中删除。

[quickstart.cloudera:21000] > SHOW DATABASES;

Query: show DATABASES
+----------------------+
| name                 |
+----------------------+
| _impala_builtins     |
| default              |
| my_db                |
+----------------------+
Fetched 3 row(s) in 0.10s
[quickstart.cloudera:21000] >

Cascade

通常，要删除数据库，您需要手动删除其中的所有表。如果您使用级联，Impala 会在删除指定数据库之前删除数据库中的表。

Example

假设 Impala 中有一个名为 sample 的数据库，它包含两个表，即 student 和 test 。如果您尝试直接删除此数据库，您将收到如下所示的错误。

[quickstart.cloudera:21000] > DROP database sample;
Query: drop database sample
ERROR:
ImpalaRuntimeException: Error making 'dropDatabase' RPC to Hive Metastore:
CAUSED BY: InvalidOperationException: Database sample is not empty. One or more
tables exist.

使用 cascade ，您可以直接删除此数据库（而不手动删除其内容），如下所示。

[quickstart.cloudera:21000] > DROP database sample cascade;
Query: drop database sample cascade

Note − 您不能在 Impala 中删除 “ current database ”。因此，在删除数据库之前，您需要确保当前上下文已设置为要删除的数据库以外的数据库。

Deleting a Database using Hue Browser

打开 Impala 查询编辑器，并在其中键入 DELETE DATABASE 语句，然后单击执行按钮，如下所示。假设有三个数据库，即 my_db, my_database 和 sample_database 以及默认数据库。此处我们正在删除名为 my_database 的数据库。

执行查询后，轻轻将光标移动到下拉菜单的顶部。然后，您将找到一个刷新符号，如下面的截图所示。如果您单击刷新符号，数据库列表将被刷新，并且所做的最新更改将应用于该列表。

Verification

单击编辑器左侧标题 DATABASE 下的 drop down 。在那里，您可以看到系统中数据库的列表。此处您可以观察到新创建的数据库 my_db ，如下所示。

如果你仔细观察，可以看到列表中只有一个数据库，即 my_db 连同默认数据库。

Impala - Select a Database

一旦连接到 Impala，则需要从可用数据库中选择一个。Impala 的 USE DATABASE Statement 用于将当前会话切换到另一个数据库。

Syntax

以下是 USE 语句的语法。

USE db_name;

Example

以下是 USE statement 的示例。首先，让我们创建一个名为 sample_database 的数据库，如下所示。

> CREATE DATABASE IF NOT EXISTS sample_database;

这将创建一个新数据库并给您以下输出。

Query: create DATABASE IF NOT EXISTS my_db2

Fetched 0 row(s) in 2.73s

如果您使用 SHOW DATABASES 语句验证数据库列表，您可以在其中观察到新创建数据库的名称。

> SHOW DATABASES;

Query: show DATABASES
+-----------------------+
| name                  |
+-----------------------+
| _impala_builtins      |
| default               |
| my_db                 |
| sample_database       |
+-----------------------+
Fetched 4 row(s) in 0.11s

现在，让我们使用 USE 语句将会话切换到新创建的数据库 (sample_database)，如下所示。

> USE sample_database;

这会将当前上下文更改为 sample_database 并显示如下所示的消息。

Query: use sample_database

Selecting a Database using Hue Browser

在 Impala Query Editor 的左侧，您会发现一个下拉菜单，如下面的截图所示。

点击下拉菜单，您可以找到下面所示的 Impala 中所有数据库的列表。

直接选择您需要更改当前上下文的目标数据库。

Impala - Create Table Statement

CREATE TABLE 语句用于在 Impala 中的所需数据库中创建新表。创建基本表包括命名表及其列和每列的数据类型。

Syntax

以下是 CREATE TABLE 语句的语法。此处， IF NOT EXISTS 是一个可选子句。如果我们使用此子句，则仅当指定数据库中没有同名已有表时，才会创建同名表。

create table IF NOT EXISTS database_name.table_name (
   column1 data_type,
   column2 data_type,
   column3 data_type,
   ………
   columnN data_type
);

CREATE TABLE 是指示数据库系统创建新表的关键字。CREATE TABLE 语句后是表的唯一名称或标识符。你还可以选择指定 database_name 和 table_name 。

Example

以下是在 create 表语句中的示例。在此示例中，我们在数据库 my_db 中创建了一个名为 student 的表。

[quickstart.cloudera:21000] > CREATE TABLE IF NOT EXISTS my_db.student
   (name STRING, age INT, contact INT );

执行上述语句后，将创建一个指定名称的表，并显示以下输出。

Query: create table student (name STRING, age INT, phone INT)

Fetched 0 row(s) in 0.48s

Verification

show Tables 查询列出 Impala 中当前数据库的表。因此，您可以使用 Show Tables 语句验证是否创建了表。

首先，您需要将上下文切换到存在所需表的数据库，如下所示。

[quickstart.cloudera:21000] > use my_db;
Query: use my_db

然后，如果您使用 show tables 查询获取表列表，则可以观察到其中名为 student 的表，如下所示。

[quickstart.cloudera:21000] > show tables;

Query: show tables
+-----------+
| name      |
+-----------+
| student   |
+-----------+
Fetched 1 row(s) in 0.10s

HDFS path

要创建 HDFS 文件系统中的数据库，您需要指定要创建数据库的位置，如下所示。

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

Creating a Database using Hue Browser

打开 Impala 查询编辑器，并输入 CREATE Table 语句。然后单击执行按钮，如下面屏幕截图所示。

执行查询后，轻轻将光标移到下拉菜单顶部，您将找到一个刷新符号。如果您单击刷新符号，将刷新数据库列表，并将对它的最新更改应用到其中。

Verification

单击编辑器左侧标题 DATABASE 下的 drop down 。在那里，您可以看到数据库列表。选择数据库 my_db ，如下所示。

选择数据库 my_db 后，您可以看到其中的表列表，如下所示。您可以在此处找到新创建的表 student ，如下所示。

Impala - Insert Statement

Impala 的 INSERT 语句有两个子句： into 和 overwrite 。带有 into 子句的插入语句用于向数据库中现有的表中添加新记录。

Syntax

INSERT 语句有两个基本语法，如下所示：

insert into table_name (column1, column2, column3,...columnN)

values (value1, value2, value3,...valueN);

这里，column1、column2、…columnN 是想要在其中插入数据表的列的名称。

您还可以添加值而不指定列名，但为此，您需要确保值的顺序与表中的列顺序相同，如下所示。

Insert into table_name values (value1, value2, value2);

CREATE TABLE 是告诉数据库系统创建新表的关键字。表中的唯一名称或标识符遵循 CREATE TABLE 语句。您还可以选择指定 database_name 以及 table_name 。

Example

假设我们在 Impala 中创建了一个名为 student 的表，如下所示。

create table employee (Id INT, name STRING, age INT,address STRING, salary BIGINT);

下面是一个在名为 employee 的表中创建记录的示例。

[quickstart.cloudera:21000] > insert into employee
(ID,NAME,AGE,ADDRESS,SALARY)VALUES (1, 'Ramesh', 32, 'Ahmedabad', 20000 );

执行上述语句后，一条记录被插入到名为 employee 的表中，并显示以下消息。

Query: insert into employee (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Ramesh',
   32, 'Ahmedabad', 20000 )
Inserted 1 row(s) in 1.32s

您可以插入另一条记录而不指定列名，如下所示。

[quickstart.cloudera:21000] > insert into employee values (2, 'Khilan', 25,
   'Delhi', 15000 );

执行上述语句后，一条记录被插入到名为 employee 的表中，并显示以下消息。

Query: insert into employee values (2, 'Khilan', 25, 'Delhi', 15000 )
Inserted 1 row(s) in 0.31s

您可以在 employee 表中插入更多记录，如下所示。

Insert into employee values (3, 'kaushik', 23, 'Kota', 30000 );

Insert into employee values (4, 'Chaitali', 25, 'Mumbai', 35000 );

Insert into employee values (5, 'Hardik', 27, 'Bhopal', 40000 );

Insert into employee values (6, 'Komal', 22, 'MP', 32000 );

插入值后，Impala 中的 employee 表将如下所示。

+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+

Overwriting the Data in a Table

我们可以使用覆盖子句覆盖表的记录。覆盖的记录将从表中永久删除。以下是使用覆盖子句的语法。

Insert overwrite table_name values (value1, value2, value2);

Example

以下是使用子句 overwrite 的一个示例。

[quickstart.cloudera:21000] > Insert overwrite employee values (1, 'Ram', 26,
   'Vishakhapatnam', 37000 );

执行上述查询后，它会用指定的记录覆盖表数据，并显示以下消息。

Query: insert overwrite employee values (1, 'Ram', 26, 'Vishakhapatnam', 37000 )
Inserted 1 row(s) in 0.31s

验证表格后，你可以观察到，表格 employee 的所有记录都被新记录覆盖，如下所示。

+----+------+-----+---------------+--------+
| id | name | age | address       | salary |
+----+------+-----+---------------+--------+
| 1  | Ram  | 26  | Vishakhapatnam| 37000  |
+----+------+-----+---------------+--------+

Inserting Data using Hue Browser

打开 Impala 查询编辑器并在其输入 insert 语句。然后点击执行按钮，如下所示。

在执行查询/语句后，该记录会添加到表格中。

Impala - Select Statement

Impala SELECT 语句用于获取数据库中一个或多个表中的数据。该查询以表格形式返回数据。

Syntax

下面是 Impala select 语句的语法。

SELECT column1, column2, columnN from table_name;

此处，column1、column2… 是您想要获取值的表的字段。如果您想要获取字段中可用的所有字段，那么您可以使用以下语法：

SELECT * FROM table_name;

Example

假设我们有一个名为 customers 的 Impala 表，其中包含以下数据：

ID    NAME       AGE    ADDRESS      SALARY
---   -------    ---    ----------   -------
1     Ramesh     32     Ahmedabad    20000
2     Khilan     25     Delhi        15000
3     Hardik     27     Bhopal       40000
4     Chaitali   25     Mumbai       35000
5     kaushik    23     Kota         30000
6     Komal      22     Mp           32000

您可以使用以下 select 语句获取 customers 表中所有记录的 id, name 和 age ，如下所示：

[quickstart.cloudera:21000] > select id, name, age from customers;

在执行以上查询后，Impala 会获取指定表中所有记录的 id、name 和 age，并显示如下内容。

Query: select id,name,age from customers

+----+----------+-----+
| id | name     | age |
| 1  | Ramesh   | 32  |
| 2  | Khilan   | 25  |
| 3  | Hardik   | 27  |
| 4  | Chaitali | 25  |
| 5  | kaushik  | 23  |
| 6  | Komal    | 22  |
+----+----------+-----+

Fetched 6 row(s) in 0.66s

您还可以在使用 select 查询后获取 customers 表中的 all 记录，如下所示：

[quickstart.cloudera:21000] > select name, age from customers;
Query: select * from customers

在执行以上查询后，Impala 会获取并显示指定表中的所有记录，如下所示。

+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | Hardik   | 27  | Bhopal    | 40000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+

Fetched 6 row(s) in 0.66s

Fetching the Records using Hue

打开 Impala Query editor，并在其中键入 select 语句。然后点击执行按钮，如下面截图所示。

在执行查询后，如果您向下滚动并选择 Results 选项卡，您可以看到指定表中记录的列表，如下所示。

Impala - Describe Statement

Impala 中的 describe 语句用于提供表的描述。此语句的结果包含有关表的信息，例如列名及其数据类型。

Syntax

以下是 Impala describe 语句的语法。

Describe table_name;

Example

例如，假设我们在 Impala 中有一个名为 customer 的表，并包含以下数据 −

ID    NAME     AGE    ADDRESS     SALARY
--- --------- ----- ----------- -----------
1   Ramesh     32    Ahmedabad    20000
2   Khilan     25    Delhi        15000
3   Hardik     27    Bhopal       40000
4   Chaitali   25    Mumbai       35000
5   kaushik    23    Kota         30000
6   Komal      22    Mp           32000

你可以使用 describe 语句获取 customer 表的描述，如下所示 −

[quickstart.cloudera:21000] > describe customer;

执行上述查询时，Impala 会获取指定表的 metadata 并如下所示显示它。

Query: describe customer

+---------+--------+---------+
| name    | type   | comment |
+---------+--------+---------+
| id      | int    |         |
| name    | string |         |
| age     | int    |         |
| address | string |         |
| salary  | bigint |         |
+---------+--------+---------+

Fetched 5 row(s) in 0.51s

Describing the Records using Hue

打开 Impala Query 编辑器，并在其中输入 describe 语句，然后单击 execute 按钮，如下面的截图所示。

执行查询后，如果你向下滚动并选择 Results 选项卡，你可以看到表的元数据，如下所示。

Impala - Alter Table

Impala 中的 Alter table 语句用于对给定表执行更改。使用该语句，可以在现有表中添加、删除或修改列，还可以对其进行重命名。

本章讲解了各种 alter 语句，包括语法和示例。首先，假设我们在 Impala 的 my_db 数据库中有一个名为 customers 的表，其中包含以下数据

ID   NAME     AGE   ADDRESS    SALARY
--- --------- ----- ----------- --------
1   Ramesh    32    Ahmedabad   20000
2   Khilan    25    Delhi       15000
3   Hardik    27    Bhopal      40000
4   Chaitali  25    Mumbai      35000
5   kaushik   23    Kota        30000
6   Komal     22    Mp          32000

而如果你获取了数据库 my_db 中的表列表，则可以像下面所示的找到 customers 表。

[quickstart.cloudera:21000] > show tables;

Query: show tables
+-----------+
| name      |
+-----------+
| customers |
| employee  |
| student   |
| student1  |
+-----------+

Altering the name of a table

Syntax

ALTER TABLE 用于重命名现有表的语法如下所示：

ALTER TABLE [old_db_name.]old_table_name RENAME TO [new_db_name.]new_table_name

Example

以下是使用 alter 语句更改表名的示例。我们将表 customers 的名称更改为 users。

[quickstart.cloudera:21000] > ALTER TABLE my_db.customers RENAME TO my_db.users;

执行上述查询后，Impala 会根据需要更改表名，并显示以下消息。

Query: alter TABLE my_db.customers RENAME TO my_db.users

你可以使用 show tables 语句验证当前数据库中的表列表。你可以找到名为 users 的表，而不是 customers 。

Query: show tables
+----------+
| name     |
+----------+
| employee |
| student  |
| student1 |
| users    |
+----------+
Fetched 4 row(s) in 0.10s

Adding columns to a table

Syntax

ALTER TABLE 用于向现有表添加列的语法如下所示：

ALTER TABLE name ADD COLUMNS (col_spec[, col_spec ...])

Example

以下查询演示了如何向现有表添加列。将两列 account_no 和 phone_number（两者都是 bigint 数据类型）添加到 users 表。

[quickstart.cloudera:21000] > ALTER TABLE users ADD COLUMNS (account_no BIGINT,
phone_no BIGINT);

执行上述查询后，将指定列添加到名为 student 的表，并显示以下消息。

Query: alter TABLE users ADD COLUMNS (account_no BIGINT, phone_no BIGINT)

如果你验证表 users 的架构，则可以在其中找到新添加的列，如下所示。

quickstart.cloudera:21000] > describe users;

Query: describe users
+------------+--------+---------+
| name       | type   | comment |
+------------+--------+---------+
| id         | int    |         |
| name       | string |         |
| age        | int    |         |
| address    | string |         |
| salary     | bigint |         |
| account_no | bigint |         |
| phone_no   | bigint |         |
+------------+--------+---------+
Fetched 7 row(s) in 0.20s

Dropping columns from a table

Syntax

ALTER TABLE 用于 DROP COLUMN 现有表中的语法如下所示：

ALTER TABLE name DROP [COLUMN] column_name

Example

以下查询是删除现有表中列的示例。删除名为 account_no 的列。

[quickstart.cloudera:21000] > ALTER TABLE users DROP account_no;

执行上述查询后，Impala 会删除名为 account_no 的列，并显示以下消息。

Query: alter TABLE users DROP account_no

如果验证表 users 的架构，由于该列已删除，因此找不到名为 account_no 的列。

[quickstart.cloudera:21000] > describe users;

Query: describe users
+----------+--------+---------+
| name     | type   | comment |
+----------+--------+---------+
| id       | int    |         |
| name     | string |         |
| age      | int    |         |
| address  | string |         |
| salary   | bigint |         |
| phone_no | bigint |         |
+----------+--------+---------+
Fetched 6 row(s) in 0.11s

Changing the name and type of a column

Syntax

在现有表中将列 change the name and datatype 变为 ALTER TABLE 的基本语法如下 −

ALTER TABLE name CHANGE column_name new_name new_type

Example

以下是使用 alter 语句更改列名称和数据类型的一个示例。此处我们更改列 phone_no to email 的名称及其数据类型为 string 。

[quickstart.cloudera:21000] > ALTER TABLE users CHANGE phone_no e_mail string;

在执行上述查询时，Impala 执行指定的更改，显示以下消息。

Query: alter TABLE users CHANGE phone_no e_mail string

你可以使用 describe 语句验证表用户的元数据。你可以观察到 Impala 已对指定列执行了所需的更改。

[quickstart.cloudera:21000] > describe users;
Query: describe users
+----------+--------+---------+
| name     | type   | comment |
+----------+--------+---------+
| id       | int    |         |
| name     | string |         |
| age      | int    |         |
| address  | string |         |
| salary   | bigint |         |
| phone_no | bigint |         |
+----------+--------+---------+
Fetched 6 row(s) in 0.11s

Altering a Table using Hue

打开 Impala 查询编辑器并在其中输入 alter 语句，然后单击执行按钮，如下面的屏幕截图所示。

在执行上述查询时，它会将表 customers 的名称更改为 users 。同样，我们可以执行所有 alter 查询。

Impala - Drop a Table

Impala drop table 语句用于删除 Impala 中的现有表。此语句还删除内部表的底层 HDFS 文件。

NOTE − 使用此命令时必须小心，因为一旦删除了表，表中可用的所有信息也将永远丢失。

Syntax

以下是 DROP TABLE 语句的语法。在此处， IF EXISTS 是一个可选子句。如果我们使用此子句，则仅当存在表时，才会删除具有给定名称的表。否则，将不执行任何操作。

DROP table database_name.table_name;

如果您尝试在没有 IF EXISTS 子句的情况下删除不存在的表，将生成一个错误。您可以选择性地指定 database_name 与 t*able_name* 一起。

Example

让我们首先验证数据库 my_db 中的表列表，如下所示。

[quickstart.cloudera:21000] > show tables;

Query: show tables
+------------+
| name       |
+------------+
| customers  |
| employee   |
| student    |
+------------+
Fetched 3 row(s) in 0.11s

从以上结果中，您可以观察到数据库 my_db 包含 3 个表。

以下是 drop table statement 的示例。在此示例中，我们从数据库 my_db 中删除了名为 student 的表。

[quickstart.cloudera:21000] > drop table if exists my_db.student;

执行上述查询后，将删除指定名称的表，并显示以下输出。

Query: drop table if exists student

Verification

show Tables 查询列出 Impala 中当前数据库中的表。因此，您可以使用 Show Tables 语句验证是否删除了表。

首先，您需要将上下文切换到存在所需表的数据库，如下所示。

[quickstart.cloudera:21000] > use my_db;
Query: use my_db

然后，如果你使用 show tables 查询获取表格列表，你可以观察到不存在名叫 student 的表格。

[quickstart.cloudera:21000] > show tables;

Query: show tables
+-----------+
| name      |
+-----------+
| customers |
| employee  |
| student   |
+-----------+
Fetched 3 row(s) in 0.11s

Creating a Database using Hue Browser

打开 Impala 查询编辑器，并在其中输入 drop Table 语句。然后，单击执行按钮，如下面的屏幕截图所示。

执行查询后，轻轻将光标移到下拉菜单顶部，您将找到一个刷新符号。如果您单击刷新符号，将刷新数据库列表，并将对它的最新更改应用到其中。

Verification

单击编辑器左侧标题 DATABASE 下方的 drop down 。在那里，你可以看到一个数据库列表；如下所示，选择数据库 my_db 。

在选择数据库 my_db 时，你可以看到其中的表格列表，如下所示。在这里，你无法找到已删除的表格 student ，如下所示。

Impala - Truncate a Table

Impala 的 Truncate Table 语句用于删除现有表格中的所有记录。

你也可以使用 DROP TABLE 命令删除一个完整的表格，但它会从数据库中删除完整的表格结构，如果你希望存储一些数据，你需要再次重新创建此表格。

Syntax

以下是截断表格语句的语法。

truncate table_name;

Example

假设，我们在 Impala 中有一个名为 customers 的表格，如果你验证其内容，你将获得以下结果。这意味着客户表格包含 6 条记录。

[quickstart.cloudera:21000] > select * from customers;

Query: select * from customers
+----+----------+-----+-----------+--------+--------+
| id | name     | age | address   | salary | e_mail |
+----+----------+-----+-----------+--------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  | NULL   |
| 2  | Khilan   | 25  | Delhi     | 15000  | NULL   |
| 3  | kaushik  | 23  | Kota      | 30000  | NULL   |
| 4  | Chaitali | 25  | Mumbai    | 35000  | NULL   |
| 5  | Hardik   | 27  | Bhopal    | 40000  | NULL   |
| 6  | Komal    | 22  | MP        | 32000  | NULL   |
+----+----------+-----+-----------+--------+--------+

以下是使用 truncate statement 在 Impala 中截断表格的示例。在这里，我们删除名为 customers 的表格的所有记录。

[quickstart.cloudera:21000] > truncate customers;

在执行上述语句时，Impala 删除指定表格中的所有记录，显示以下消息。

Query: truncate customers

Fetched 0 row(s) in 0.37s

Verification

如果使用 select 语句验证了删除操作后客户表格的内容，你将获得一个空行，如下所示。

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers

Fetched 0 row(s) in 0.12s

Truncating a Table using Hue Browser

打开 Impala 查询编辑器，并在其中输入 truncate 语句。然后，单击执行按钮，如下面的屏幕截图所示。

在执行查询/语句后，表格中的所有记录将被删除。

Impala - Show Tables

Impala 中的 show tables 语句用于获取当前数据库中所有现有表列表。

Example

以下是 show tables 语句的一个示例。如果你想获取特定数据库中的表列表，首先将上下文更改为所需的数据库，然后使用 show tables 语句获取其中的表列表，如下所示。

[quickstart.cloudera:21000] > use my_db;
Query: use my_db
[quickstart.cloudera:21000] > show tables;

在执行上述查询时，Impala 会获取指定数据库中的所有表的列表并显示如下所示。

Query: show tables
+-----------+
| name      |
+-----------+
| customers |
| employee  |
+-----------+
Fetched 2 row(s) in 0.10s

Listing the Tables using Hue

打开 Impala 查询编辑器，将上下文选择为 my_db ，并在其中键入 show tables 语句，然后单击执行按钮，如下面的屏幕截图所示。

在执行查询后，如果你向下滚动并选择 Results 选项卡，可以看到表的列表，如下所示。

Impala - Create View

视图不过是 Impala 查询语言的语句，它与相关名称一起存储在数据库中。它是以预定义 SQL 查询的形式对表格的构成。

视图可以包含表格的所有行或选定的行。一个视图可以从一个或多个表格创建。视图允许用户 -

以用户或用户类别觉得自然或直观的方式构建结构化数据。
限制对数据的访问，以便用户可以看到（有时可以修改）他们需要的恰好内容。
总结可以用来生成报告的不同表中的数据。

你可以使用 Impala 的 Create View 语句创建视图。

Syntax

以下是创建视图语句的语法。 IF NOT EXISTS 是一个可选子句。如果我们使用这个子句，只有当指定数据库中没有名为相同的现有表格时，才创建名为表格。

Create View IF NOT EXISTS view_name as Select statement

Example

例如，假设我们在 Impala 的 my_db 数据库中有一个名为 customers 的表格，其包含以下数据。

ID  NAME      AGE   ADDRESS     SALARY
--- --------- ----- ----------- --------
1   Ramesh    32    Ahmedabad   20000
2   Khilan    25    Delhi       15000
3   Hardik    27    Bhopal      40000
4   Chaitali  25    Mumbai      35000
5   kaushik   23    Kota        30000
6   Komal     22    MP          32000

以下是 Create View Statement 的示例。在此示例中，我们正在创建一个视图作为 customers 表，该表包含 name 和 age 列。

[quickstart.cloudera:21000] > CREATE VIEW IF NOT EXISTS customers_view AS
select name, age from customers;

执行上述查询后，将创建一个具有所需列的视图，并显示以下消息。

Query: create VIEW IF NOT EXISTS sample AS select * from customers
Fetched 0 row(s) in 0.33s

Verification

你可以使用 select 语句验证刚创建的视图内容，如下所示。

[quickstart.cloudera:21000] > select * from customers_view;

这将产生以下结果。

Query: select * from customers_view
+----------+-----+
| name     | age |
+----------+-----+
| Komal    | 22  |
| Khilan   | 25  |
| Ramesh   | 32  |
| Hardik   | 27  |
| Chaitali | 25  |
| kaushik  | 23  |
+----------+-----+
Fetched 6 row(s) in 4.80s

Creating a View using Hue

打开 Impala Query 编辑器，选择 my_db 作为上下文，并在其中输入 Create View 语句，然后单击 execute 按钮，如下面的截图所示。

执行查询后，如果你向下滚动，你可以在表的列表中看到名为 sample 的 view ，如下所示。

Impala - Alter View

Impala 的 Alter View 语句用于更改视图。使用此语句，你可以更改视图的名称、更改数据库以及与其关联的查询。

由于 view 是一个逻辑结构，因此物理数据将不受 alter view 查询的影响。

Syntax

以下是 Alter View 语句的语法

ALTER VIEW database_name.view_name as Select statement

Example

例如，请假设我们有一个视图名为 customers_view ，它位于 Impala 中的 my_db 数据库中，如下所示。

+----------+-----+
| name     | age |
+----------+-----+
| Komal    | 22  |
| Khilan   | 25  |
| Ramesh   | 32  |
| Hardik   | 27  |
| Chaitali | 25  |
| kaushik  | 23  |
+----------+-----+

以下是 Alter View Statement 的示例。在此示例中，我们为 customers_view 包含列 id、name 和 salary，而不是 name 和 age。

[quickstart.cloudera:21000] > Alter view customers_view as select id, name,
salary from customers;

执行上述查询后，Impala 将对 customers_view 执行指定更改，并显示以下消息。

Query: alter view customers_view as select id, name, salary from customers

Verification

你可以使用 select 语句验证名为 customers_view 的 view 的内容，如下所示。

[quickstart.cloudera:21000] > select * from customers_view;
Query: select * from customers_view

这将产生以下结果。

+----+----------+--------+
| id | name     | salary |
+----+----------+--------+
| 3  | kaushik  | 30000  |
| 2  | Khilan   | 15000  |
| 5  | Hardik   | 40000  |
| 6  | Komal    | 32000  |
| 1  | Ramesh   | 20000  |
| 4  | Chaitali | 35000  |
+----+----------+--------+
Fetched 6 row(s) in 0.69s

Altering a View using Hue

打开 Impala 查询编辑器，选择 my_db 为上下文，并键入 Alter View 语句，然后单击执行按钮，如下面的屏幕截图所示。

执行查询后，名为 sample 的 view 将得到相应地更改。

Impala - Drop a View

Impala 的 Drop View 查询用于删除现有视图。由于 view 是逻辑结构，因此 drop view 查询不会影响任何物理数据。

Syntax

以下是 drop view 语句的语法。

DROP VIEW database_name.view_name;

Example

例如，请假设我们有一个视图名为 customers_view ，它位于 Impala 中的 my_db 数据库中，如下所示。

+----------+-----+
| name     | age |
+----------+-----+
| Komal    | 22  |
| Khilan   | 25  |
| Ramesh   | 32  |
| Hardik   | 27  |
| Chaitali | 25  |
| kaushik  | 23  |
+----------+-----+

以下是 Drop View Statement 的示例。在此示例中，我们尝试使用 drop view 查询删除名为 customers_view 的 view 。

[quickstart.cloudera:21000] > Drop view customers_view;

执行上述查询后，Impala 会删除指定的视图，并显示以下消息。

Query: drop view customers_view

Verification

如果你使用 show tables 语句验证表列表，你就可以看到名为 customers_view 的 view 已被删除。

[quickstart.cloudera:21000] > show tables;

这将产生以下结果。

Query: show tables
+-----------+
| name      |
+-----------+
| customers |
| employee  |
| sample    |
+-----------+
Fetched 3 row(s) in 0.10s

Dropping a View using Hue

打开 Impala Query 编辑器，选择 my_db 作为上下文，并在其中输入 Drop view 语句，然后单击 execute 按钮，如下面的截图所示。

执行查询后，如果向下滚动，可以看到一个名为 TABLES 的列表。此列表包含当前数据库中的所有 tables 和 views 。从该列表中，您可以发现指定的 view 已被删除。

Impala - Order By Clause

Impala ORDER BY 从句用于根据一个或多个列以升序或降序对数据进行排序。默认情况下，一些数据库会按升序对查询结果进行排序。

Syntax

以下是 ORDER BY 从句的语法。

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]

你可以分别使用关键字 ASC 或 DESC 以升序或降序的方式排列表中的数据。

同样，如果我们使用 NULLS FIRST，表中的所有 null 值都会排列在顶部行；如果我们使用 NULLS LAST，包含 null 值的行将被排列在最后。

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 3  | kaushik  | 23  | Kota      | 30000  |
| 1  | Ramesh   |  32 | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
+----+----------+-----+-----------+--------+
Fetched 6 row(s) in 0.51s

以下是使用 order by 从句按 id’s 的升序来排列 customers 表中数据的一个示例。

[quickstart.cloudera:21000] > Select * from customers ORDER BY id asc;

执行后，上述查询将产生以下输出。

Query: select * from customers ORDER BY id asc
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+
Fetched 6 row(s) in 0.56s

同样，你可以使用 order by 从句按降序排列 customers 表中的数据，如下所示。

[quickstart.cloudera:21000] > Select * from customers ORDER BY id desc;

执行后，上述查询将产生以下输出。

Query: select * from customers ORDER BY id desc
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 6  | Komal    | 22  | MP        | 32000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
+----+----------+-----+-----------+--------+
Fetched 6 row(s) in 0.54s

Impala - Group By Clause

Impala GROUP BY 子句与 SELECT 语句结合使用，用于将相同数据组织成组。

Syntax

下面是 GROUP BY 子句的语法。

select data from table_name Group BY col_name;

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 6  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+
Fetched 6 row(s) in 0.51s

您可以使用 GROUP BY 查询获取每个客户的总工资，如下所示。

[quickstart.cloudera:21000] > Select name, sum(salary) from customers Group BY name;

在执行后，上述查询给出以下输出。

Query: select name, sum(salary) from customers Group BY name
+----------+-------------+
| name     | sum(salary) |
+----------+-------------+
| Ramesh   | 20000       |
| Komal    | 32000       |
| Hardik   | 40000       |
| Khilan   | 15000       |
| Chaitali | 35000       |
| kaushik  | 30000       |
+----------+-------------+
Fetched 6 row(s) in 1.75s

假设此表包含多个记录，如下所示。

+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Ramesh   | 32  | Ahmedabad | 1000|  |
| 3  | Khilan   | 25  | Delhi     | 15000  |
| 4  | kaushik  | 23  | Kota      | 30000  |
| 5  | Chaitali | 25  | Mumbai    | 35000  |
| 6  | Chaitali | 25  | Mumbai    | 2000   |
| 7  | Hardik   | 27  | Bhopal    | 40000  |
| 8  | Komal    | 22  | MP        | 32000  |
+----+----------+-----+-----------+--------+

现在，您可以再次使用 Group By 子句获取所有员工的总工资，同时考虑记录的重复条目，如下所示。

Select name, sum(salary) from customers Group BY name;

在执行后，上述查询给出以下输出。

Query: select name, sum(salary) from customers Group BY name
+----------+-------------+
| name     | sum(salary) |
+----------+-------------+
| Ramesh   | 21000       |
| Komal    | 32000       |
| Hardik   | 40000       |
| Khilan   | 15000       |
| Chaitali | 37000       |
| kaushik  | 30000       |
+----------+-------------+
Fetched 6 row(s) in 1.75s

Impala - Having Clause

Impala 中的 Having 子句能够让您指定筛选哪些组结果出现在最终结果中的条件。

通常情况下， Having 子句与 group by 子句一起使用；它规定了 GROUP BY 子句创建的组的条件。

Syntax

以下是 Having 子句的语法。

select * from table_name ORDER BY col_name [ASC|DESC] [NULLS FIRST|NULLS LAST]

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-------------+--------+
| id | name     | age | address     | salary |
+----+----------+-----+-------------+--------+
| 1  | Ramesh   | 32  | Ahmedabad   | 20000  |
| 2  | Khilan   | 25  | Delhi       | 15000  |
| 3  | kaushik  | 23  | Kota        | 30000  |
| 4  | Chaitali | 25  | Mumbai      | 35000  |
| 5  | Hardik   | 27  | Bhopal      | 40000  |
| 6  | Komal    | 22  | MP          | 32000  |
| 7  | ram      | 25  | chennai     | 23000  |
| 8  | rahim    | 22  | vizag       | 31000  |
| 9  | robert   | 23  | banglore    | 28000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.51s

以下是 Having 子句在 Impala 中的使用示例——

[quickstart.cloudera:21000] > select max(salary) from customers group by age having max(salary) > 20000;

该查询最初按年龄对表进行分组，并选择每个组的最高薪资并显示那些高于 20000 的薪资，如下所示。

20000
+-------------+
| max(salary) |
+-------------+
| 30000       |
| 35000       |
| 40000       |
| 32000       |
+-------------+
Fetched 4 row(s) in 1.30s

Impala - Limit Clause

Impala 中的 limit 子句用于将结果集的行数限制为所需数量，即，查询结果集不再持有超出行数限制的记录。

Syntax

以下是 Impala 中 Limit 子句的语法。

select * from table_name order by id limit numerical_expression;

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 3  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 8  | ram      | 22  | vizag     | 31000  |
| 9  | robert   | 23  | banglore  | 28000  |
| 7  | ram      | 25  | chennai   | 23000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.51s

你可以使用 order by 子句按其 id 的升序排列表格中的记录，如下所示。

[quickstart.cloudera:21000] > select * from customers order by id;
Query: select * from customers order by id
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 7  | ram      | 25  | chennai   | 23000  |
| 8  | ram      | 22  | vizag     | 31000  |
| 9  | robert   | 23  | banglore  | 28000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.54s

现在，你可以使用 limit 子句限制输出记录的数量为 4，使用 limit 子句，如下所示。

[quickstart.cloudera:21000] > select * from customers order by id limit 4;

在执行后，上述查询给出以下输出。

Query: select * from customers order by id limit 4
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
+----+----------+-----+-----------+--------+
Fetched 4 row(s) in 0.64s

Impala - Offset Clause

通常情况下， select 查询结果集中的行从 0 开始。使用 offset 子句，我们可以决定从何处开始考虑输出。例如，如果我们选择偏移量为 0，则结果将如常一样，如果我们选择偏移量为 5，则结果将从第五行开始。

Syntax

以下是 Impala 中 offset 子句的语法。

select data from table_name Group BY col_name;

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 3  | kaushik  | 23  | Kota      | 30000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 8  | ram      | 22  | vizag     | 31000  |
| 9  | robert   | 23  | banglore  | 28000  |
| 7  | ram      | 25  | chennai   | 23000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.51s

您可以按照 ID 的升序排列表中的记录，并使用 limit 和 order by 子句将记录数限制为 4，如下所示。

Query: select * from customers order by id limit 4
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
+----+----------+-----+-----------+--------+
Fetched 4 row(s) in 0.64s

以下是 offset 子句的一个示例。在此，我们按 ID 顺序获取 customers 表中的记录，并从第 0 行开始打印前四行。

[quickstart.cloudera:21000] > select * from customers order by id limit 4 offset 0;

执行后，上述查询将给出以下结果。

Query: select * from customers order by id limit 4 offset 0
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
+----+----------+-----+-----------+--------+
Fetched 4 row(s) in 0.62s

以同样的方式，您可以从偏移量为 5 的行开始获取 customers 表中的四条记录，如下所示。

[quickstart.cloudera:21000] > select * from customers order by id limit 4 offset 5;
Query: select * from customers order by id limit 4 offset 5
+----+--------+-----+----------+--------+
| id | name   | age | address  | salary |
+----+--------+-----+----------+--------+
| 6  | Komal  | 22  | MP       | 32000  |
| 7  | ram    | 25  | chennai  | 23000  |
| 8  | ram    | 22  | vizag    | 31000  |
| 9  | robert | 23  | banglore | 28000  |
+----+--------+-----+----------+--------+
Fetched 4 row(s) in 0.52s

Impala - Union Clause

您可以使用 Impala 的 Union 子句组合两个查询的结果。

Syntax

以下是 Union 子句在 Impala 中的语法。

query1 union query2;

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 9  | robert   | 23  | banglore  | 28000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 7  | ram      | 25  | chennai   | 23000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 8  | ram      | 22  | vizag     | 31000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.59s

同样，假设我们有另一个名为 employee 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from employee;
Query: select * from employee
+----+---------+-----+---------+--------+
| id | name    | age | address | salary |
+----+---------+-----+---------+--------+
| 3  | mahesh  | 54  | Chennai | 55000  |
| 2  | ramesh  | 44  | Chennai | 50000  |
| 4  | Rupesh  | 64  | Delhi   | 60000  |
| 1  | subhash | 34  | Delhi   | 40000  |
+----+---------+-----+---------+--------+
Fetched 4 row(s) in 0.59s

以下是 union 子句在 Impala 中的示例。在此示例中，我们按两个表的 id 将记录排列，并使用两个单独的查询将其数量限制为 3，然后使用 UNION 子句连接这些查询。

[quickstart.cloudera:21000] > select * from customers order by id limit 3
 union select * from employee order by id limit 3;

在执行后，上述查询给出以下输出。

Query: select * from customers order by id limit 3 union select
   * from employee order by id limit 3
+----+---------+-----+-----------+--------+
| id | name    | age | address   | salary |
+----+---------+-----+-----------+--------+
| 2  | Khilan  | 25  | Delhi     | 15000  |
| 3  | mahesh  | 54  | Chennai   | 55000  |
| 1  | subhash | 34  | Delhi     | 40000  |
| 2  | ramesh  | 44  | Chennai   | 50000  |
| 3  | kaushik | 23  | Kota      | 30000  |
| 1  | Ramesh  | 32  | Ahmedabad | 20000  |
+----+---------+-----+-----------+--------+
Fetched 6 row(s) in 3.11s

Impala - With Clause

如果查询过于复杂，我们可以将 aliases 定义为复杂部分，并使用 Impala 的 with 子句将其包含在查询中。

Syntax

以下是在 Impala 中 with 子句的语法。

with x as (select 1), y as (select 2) (select * from x union y);

Example

假设数据库 my_db 中有一个名为 customers 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from customers;
Query: select * from customers
+----+----------+-----+-----------+--------+
| id | name     | age | address   | salary |
+----+----------+-----+-----------+--------+
| 1  | Ramesh   | 32  | Ahmedabad | 20000  |
| 9  | robert   | 23  | banglore  | 28000  |
| 2  | Khilan   | 25  | Delhi     | 15000  |
| 4  | Chaitali | 25  | Mumbai    | 35000  |
| 7  | ram      | 25  | chennai   | 23000  |
| 6  | Komal    | 22  | MP        | 32000  |
| 8  | ram      | 22  | vizag     | 31000  |
| 5  | Hardik   | 27  | Bhopal    | 40000  |
| 3  | kaushik  | 23  | Kota      | 30000  |
+----+----------+-----+-----------+--------+
Fetched 9 row(s) in 0.59s

同样，假设我们有另一个名为 employee 的表，其内容如下 −

[quickstart.cloudera:21000] > select * from employee;
Query: select * from employee
+----+---------+-----+---------+--------+
| id | name    | age | address | salary |
+----+---------+-----+---------+--------+
| 3  | mahesh  | 54  | Chennai | 55000  |
| 2  | ramesh  | 44  | Chennai | 50000  |
| 4  | Rupesh  | 64  | Delhi   | 60000  |
| 1  | subhash | 34  | Delhi   | 40000  |
+----+---------+-----+---------+--------+
Fetched 4 row(s) in 0.59s

以下是 Impala 中 with 子句的示例。在这个示例中，我们使用 with 子句显示 employee 和 customers 中年龄大于 25 的记录。

[quickstart.cloudera:21000] >
   with t1 as (select * from customers where age>25),
   t2 as (select * from employee where age>25)
   (select * from t1 union select * from t2);

在执行后，上述查询给出以下输出。

Query: with t1 as (select * from customers where age>25), t2 as (select * from employee where age>25)
   (select * from t1 union select * from t2)
+----+---------+-----+-----------+--------+
| id | name    | age | address   | salary |
+----+---------+-----+-----------+--------+
| 3  | mahesh  | 54  | Chennai   | 55000  |
| 1  | subhash | 34  | Delhi     | 40000  |
| 2  | ramesh  | 44  | Chennai   | 50000  |
| 5  | Hardik  | 27  | Bhopal    | 40000  |
| 4  | Rupesh  | 64  | Delhi     | 60000  |
| 1  | Ramesh  | 32  | Ahmedabad | 20000  |
+----+---------+-----+-----------+--------+
Fetched 6 row(s) in 1.73s

Impala - Distinct Operator

Impala 中的 distinct 运算符用于通过删除重复值来获取唯一值。

Syntax

以下是 *distinct *运算符的语法。

select distinct columns… from table_name;

Example

假设我们在 Impala 中有一个名为 customers 的表格，其内容如下 −

[quickstart.cloudera:21000] > select distinct id, name, age, salary from customers;
Query: select distinct id, name, age, salary from customers

在此，你可以看到客户 Ramesh 和 Chaitali 的薪水输入了两次，使用 distinct 运算符，我们可以选择唯一值，如下所示。

[quickstart.cloudera:21000] > select distinct name, age, address from customers;

在执行后，上述查询给出以下输出。

Query: select distinct id, name from customers
+----------+-----+-----------+
| name     | age | address   |
+----------+-----+-----------+
| Ramesh   | 32  | Ahmedabad |
| Khilan   | 25  | Delhi     |
| kaushik  | 23  | Kota      |
| Chaitali | 25  | Mumbai    |
| Hardik   | 27  | Bhopal    |
| Komal    | 22  | MP        |
+----------+-----+-----------+
Fetched 9 row(s) in 1.46s