Impala 快速指南

什么是 Impala？

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

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

为什么选择 Impala？

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

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

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

与 Apache Hive 不同，**Impala 不是基于 MapReduce 算法的**。它实现了一个基于**守护进程**的分布式架构，这些守护进程负责在同一台机器上运行的查询执行的所有方面。

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

Impala 的优势

以下是 Cloudera Impala 的一些显著优势。

使用 Impala，您可以使用传统的 SQL 知识以闪电般的速度处理存储在 HDFS 中的数据。
由于数据处理是在数据驻留的位置（Hadoop 集群）进行的，因此在使用 Impala 时，无需对存储在 Hadoop 上的数据进行数据转换和数据移动。
使用 Impala，您可以访问存储在 HDFS、HBase 和 Amazon S3 中的数据，而无需了解 Java（MapReduce 作业）。您可以通过对 SQL 查询的基本了解来访问它们。
要在业务工具中编写查询，数据必须经过复杂的提取-转换-加载 (ETL) 循环。但是，使用 Impala，此过程得到了简化。使用**探索性数据分析和数据发现**等新技术克服了耗时的加载和重组阶段，从而加快了流程。
Impala 是 Parquet 文件格式的先驱，这是一种列式存储布局，针对数据仓库场景中常见的大规模查询进行了优化。

Impala 的特性

以下是 Cloudera Impala 的特性：

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

关系数据库和 Impala

Impala 使用类似于 SQL 和 HiveQL 的查询语言。下表描述了 SQL 和 Impala 查询语言之间的一些关键区别。

Impala	关系数据库
Impala 使用类似于 HiveQL 的 SQL 查询语言。	关系数据库使用 SQL 语言。
在 Impala 中，您无法更新或删除单个记录。	在关系数据库中，可以更新或删除单个记录。
Impala 不支持事务。	关系数据库支持事务。
Impala 不支持索引。	关系数据库支持索引。
Impala 存储和管理大量数据（PB 级）。	与 Impala 相比，关系数据库处理的数据量较小（TB 级）。

Hive、HBase 和 Impala

尽管 Cloudera Impala 使用与 Hive 相同的查询语言、元数据存储和用户界面，但在某些方面它与 Hive 和 HBase 不同。下表对 HBase、Hive 和 Impala 进行了比较分析。

HBase	Hive	Impala
HBase 是基于 Apache Hadoop 的宽列存储数据库。它使用 BigTable 的概念。	Hive 是一种数据仓库软件。使用它，我们可以访问和管理构建在 Hadoop 之上的大型分布式数据集。	Impala 是一种用于管理和分析存储在 Hadoop 上的数据的工具。
HBase 的数据模型是宽列存储。	Hive 遵循关系模型。	Impala 遵循关系模型。
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 不支持触发器。

所有这三个数据库：

都是 NoSQL 数据库。
作为开源软件提供。
支持服务器端脚本。
遵循 ACID 属性，如持久性和并发性。
使用**分片**进行**分区**。

Impala 的缺点

使用 Impala 的一些缺点如下：

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

Impala - 环境

本章介绍安装 Impala 的先决条件，如何在系统中下载、安装和设置**Impala**。

与 Hadoop 及其生态系统软件类似，我们需要在 Linux 操作系统上安装 Impala。由于 Cloudera 发布了 Impala，因此它与**Cloudera Quick Start VM**一起提供。

本章介绍如何下载**Cloudera Quick Start VM**并启动 Impala。

下载 Cloudera Quick Start VM

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

步骤 1

打开 Cloudera 网站的主页 http://www.cloudera.com/。您将看到如下所示的页面。

步骤 2

单击 Cloudera 主页上的**登录**链接，这将跳转到如下所示的登录页面。

如果您尚未注册，请单击**立即注册**链接，这将显示**帐户注册**表单。在那里注册并登录 Cloudera 帐户。

步骤 3

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

步骤 4 - 下载 QuickStartVM

通过单击以下快照中突出显示的**立即下载**按钮，下载 Cloudera **QuickStartVM**

这将跳转到**QuickStart VM**的下载页面。

单击**立即获取一个**按钮，接受许可协议，然后单击提交按钮，如下所示。

Cloudera 提供与其 VM 兼容的 VMware、KVM 和 VIRTUALBOX。选择所需版本。在本教程中，我们演示了使用 VirtualBox 设置**Cloudera QuickStartVM**，因此请单击**VIRTUALBOX 下载**按钮，如下所示。

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

导入 Cloudera QuickStartVM

下载**cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf**文件后，我们需要使用 VirtualBox 导入它。为此，首先需要在系统中安装 VirtualBox。按照以下步骤导入下载的映像文件。

步骤 1

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

步骤 2

打开 VirtualBox 软件。单击**文件**并选择**导入设备**，如下所示。

步骤 3

单击**导入设备**后，您将看到“导入虚拟设备”窗口。选择下载的映像文件的位置，如下所示。

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

启动 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] >

**注意** - 我们将在后面的章节中讨论所有 impala-shell 命令。

Impala 查询编辑器

除了**Impala shell**之外，您还可以使用 Hue 浏览器与 Impala 通信。安装 CDH5 并启动 Impala 后，如果您打开浏览器，您将看到如下所示的 Cloudera 主页。

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

单击**查询编辑器**下拉菜单，您将看到 Impala 支持的编辑器列表，如下面的屏幕截图所示。

在下拉菜单中单击**Impala**，您将看到如下所示的 Impala 查询编辑器。

Impala - 架构

Impala 是一个 MPP（大规模并行处理）查询执行引擎，它运行在 Hadoop 集群中的许多系统上。与传统的存储系统不同，Impala 与其存储引擎分离。它具有三个主要组件，即 Impala 守护程序（Impalad）、Impala 状态存储和 Impala 元数据或元数据存储。

Impala 守护程序（Impalad）

Impala守护进程（也称为impalad）运行在安装了Impala的每个节点上。它接收来自各种接口（例如Impala shell、Hue浏览器等）的查询并处理它们。

每当向特定节点上的impalad提交查询时，该节点将作为该查询的“协调器节点”。多个查询也由运行在其他节点上的Impalad处理。Impalad接受查询后，会读取和写入数据文件，并通过将工作分配给Impala集群中的其他Impala节点来并行化查询。当查询在各个Impalad实例上处理时，所有实例都会将结果返回到中央协调节点。

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

Impala状态存储

Impala还有一个重要的组件称为Impala状态存储，它负责检查每个Impalad的运行状况，然后定期将每个Impala守护进程的运行状况转发给其他守护进程。它可以在运行Impala服务器的同一节点或集群中的其他节点上运行。

Impala状态存储守护进程的名称为State stored。Impalad将其运行状况状态报告给Impala状态存储守护进程，即State stored。

如果由于任何原因发生节点故障，Statestore会将此故障更新到所有其他节点，并且一旦其他impalad收到此通知，就不会有其他Impala守护进程将任何其他查询分配给受影响的节点。

Impala元数据和元存储

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

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

当表定义或表数据更新时，其他Impala守护进程必须通过检索最新的元数据来更新其元数据缓存，然后才能针对相关表发出新的查询。

查询处理接口

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

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

查询执行过程

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

接收查询后，查询协调器会使用Hive元存储中的表模式验证查询是否合适。之后，它从HDFS名称节点收集执行查询所需的数据位置信息，并将此信息发送给其他impalad以执行查询。

所有其他Impala守护进程读取指定的数据块并处理查询。一旦所有守护进程完成其任务，查询协调器就会收集结果并将其交付给用户。

Impala - Shell

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

Impala shell（命令提示符）
Hue（用户界面）
ODBC和JDBC（第三方库）

本章介绍如何启动Impala Shell以及shell的各种选项。

Impala Shell命令参考

Impala shell的命令分为常规命令、特定于查询的选项和特定于表和数据库的选项，如下所述。

常规命令

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

特定于查询的选项

Set/unset
Profile
Explain

特定于表和数据库的选项

Alter
describe
drop
insert
select
show
use

启动 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 – 通用命令

以下是Impala的通用命令的说明：

help命令

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命令

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命令

Impala的history命令显示shell中执行的最后10个命令。以下是history命令的示例。在这里，我们执行了5个命令，分别是version、help、show、use和history。

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

quit/exit命令

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

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

connect命令

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特定于查询的选项

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

特定于表和数据库的选项

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

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

Impala - 查询语言基础

Impala数据类型

下表描述了Impala数据类型。

序号	数据类型和说明
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 此数据类型用于存储4字节整数，范围为-2147483648到2147483647。
8	SMALLINT 此数据类型用于存储2字节整数，范围为-32768到32767。
9	STRING 此数据类型用于存储字符串值。
10	TIMESTAMP 此数据类型用于表示时间点。
11	TINYINT 此数据类型用于存储1字节整数值，范围为-128到127。
12	VARCHAR 此数据类型用于存储最大长度为65,535的可变长度字符。
13	ARRAY 这是一个复杂的数据类型，用于存储可变数量的有序元素。
14	Map 这是一个复杂的数据类型，用于存储可变数量的键值对。
15	Struct 这是一个复杂的数据类型，用于表示单个项目的多个字段。

Impala中的注释

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

单行注释 − 以“—”结尾的每一行都被视为Impala中的注释。以下是Impala中单行注释的示例。

-- Hello welcome to tutorials point.

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

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

Impala中的运算符类似于SQL中的运算符。点击以下链接参考我们的SQL教程 sql-operators。

Impala - 创建数据库

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

CREATE DATABASE 语句

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

语法

以下是CREATE DATABASE语句的语法。

CREATE DATABASE IF NOT EXISTS database_name;

这里，IF NOT EXISTS是一个可选子句。如果使用此子句，只有在不存在具有相同名称的数据库时，才会创建具有给定名称的数据库。

示例

以下是create database 语句的示例。在此示例中，我们创建了一个名为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

验证

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 路径

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

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

使用 Hue 浏览器创建数据库

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

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

验证

单击编辑器左侧“DATABASE”标题下的下拉框。您可以在其中看到系统中数据库的列表。在这里，您可以看到如下所示新创建的数据库my_db。

如果您仔细观察，您会发现列表中只有一个数据库，即my_db以及默认数据库。

Impala - 删除数据库

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

语法

以下是DROP DATABASE语句的语法。

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

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

示例

以下是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 语句删除此数据库。

 < DROP DATABASE IF EXISTS sample_database;

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

Query: drop DATABASE IF EXISTS sample_database;

验证

您可以使用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] >

级联

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

示例

假设 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

注意 - 您不能删除 Impala 中的“当前数据库”。因此，在删除数据库之前，您需要确保当前上下文设置为除要删除的数据库以外的其他数据库。

使用 Hue 浏览器删除数据库

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

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

验证

单击编辑器左侧“DATABASE”标题下的下拉菜单。在那里，您可以看到系统中数据库的列表。在这里，您可以看到如下所示新创建的数据库my_db。

如果您仔细观察，您会发现列表中只有一个数据库，即my_db以及默认数据库。

Impala - 选择数据库

连接到 Impala 后，需要在可用的数据库中选择一个。Impala 的USE DATABASE 语句用于将当前会话切换到另一个数据库。

语法

以下是USE语句的语法。

USE db_name;

示例

以下是USE 语句的示例。首先，让我们创建一个名为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

使用 Hue 浏览器选择数据库

在 Impala 的查询编辑器左侧，您将找到如下面的屏幕截图所示的下拉菜单。

如果您单击下拉菜单，您将找到 Impala 中所有数据库的列表，如下所示。

只需选择您需要更改当前上下文的数据库。

Impala - 创建表语句

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

语法

以下是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。

示例

以下是 create table 语句的示例。在此示例中，我们在数据库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

验证

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 路径

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

CREATE DATABASE IF NOT EXISTS database_name LOCATION hdfs_path;

使用 Hue 浏览器创建数据库

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

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

验证

单击编辑器左侧“DATABASE”标题下的下拉菜单。您可以在其中看到数据库列表。选择数据库my_db，如下所示。

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

Impala - 插入语句

Impala 的INSERT语句有两个子句 - into和overwrite。带有into子句的 insert 语句用于将新记录添加到数据库中现有表中。

语法

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。

示例

假设我们在 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  |
+----+----------+-----+-----------+--------+

覆盖表中的数据

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

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

示例

以下是使用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  |
+----+------+-----+---------------+--------+

使用 Hue 浏览器插入数据

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

执行查询/语句后，此记录将添加到表中。

Impala - 选择语句

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

语法

以下是 Impala select语句的语法。

SELECT column1, column2, columnN from table_name;

这里，column1、column2…是您要获取其值的表的字段。如果要获取字段中所有可用的字段，则可以使用以下语法：

SELECT * FROM table_name;

示例

假设我们在 Impala 中有一个名为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

您可以使用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表中的所有记录，如下所示。

[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

使用 Hue 获取记录

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

执行查询后，如果向下滚动并选择**结果**选项卡，您将看到指定表的记录列表，如下所示。

Impala - 描述语句

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

语法

以下是 Impala **describe** 语句的语法。

Describe table_name;

示例

例如，假设我们在 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 将获取指定表的**元数据**并显示它，如下所示。

Query: describe customer
 
+---------+--------+---------+ 
| name    | type   | comment | 
+---------+--------+---------+ 
| id      | int    |         |                    
| name    | string |         | 
| age     | int    |         | 
| address | string |         | 
| salary  | bigint |         |
+---------+--------+---------+ 

Fetched 5 row(s) in 0.51s

使用 Hue 描述记录

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

执行查询后，如果向下滚动并选择**结果**选项卡，您将看到表的元数据，如下所示。

Impala - 修改表

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  | 
+-----------+

更改表名

语法

重命名现有表的**ALTER TABLE**的基本语法如下：

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

示例

以下是使用**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

向表中添加列

语法

向现有表添加列的**ALTER TABLE**基本语法如下：

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

示例

以下查询是一个演示如何向现有表添加列的示例。这里我们将两列 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

从表中删除列

语法

在现有表中**DROP COLUMN**的 ALTER TABLE 基本语法如下：

ALTER TABLE name DROP [COLUMN] column_name

示例

以下查询是从现有表中删除列的示例。这里我们删除名为**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

更改列的名称和类型

语法

在现有表中**更改列的名称和数据类型**的 ALTER TABLE 基本语法如下：

ALTER TABLE name CHANGE column_name new_name new_type

示例

以下是使用 alter 语句更改列的名称和数据类型的示例。这里我们将列**phone_no**的名称更改为**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**语句验证 users 表的元数据。您可以观察到 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

使用 Hue 更改表

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

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

Impala - 删除表

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

**注意** - 使用此命令时必须小心，因为一旦表被删除，表中所有可用信息也将永远丢失。

语法

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

DROP table database_name.table_name;

如果您尝试删除不存在的表而不使用 IF EXISTS 子句，则会生成错误。您可以选择性地与**table_name**一起指定**database_name**。

示例

让我们首先验证**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 语句**的示例。在此示例中，我们正在从**my_db**数据库中删除名为**student**的表。

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

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

Query: drop table if exists student

验证

**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

使用 Hue 浏览器创建数据库

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

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

验证

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

选择数据库**my_db**后，您可以看到其中的表列表，如下所示。在这里，您找不到已删除的表**student**，如下所示。

Impala - 清空表

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

您还可以使用 DROP TABLE 命令删除整个表，但这将从数据库中删除整个表结构，如果您希望存储一些数据，则需要重新创建此表。

语法

以下是 truncate table 语句的语法。

truncate table_name;

示例

假设我们在 Impala 中有一个名为**customers**的表，如果您验证其内容，您将得到以下结果。这意味着 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 语句**截断 Impala 中表的示例。这里我们删除名为**customers**的表的所有记录。

[quickstart.cloudera:21000] > truncate customers;

执行上述语句后，Impala 将删除指定表的所有记录，并显示以下消息。

Query: truncate customers 

Fetched 0 row(s) in 0.37s

验证

如果您使用**select**语句验证删除操作后 customers 表的内容，您将得到一个空行，如下所示。

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

Fetched 0 row(s) in 0.12s

使用 Hue 浏览器截断表

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

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

Impala - 显示表

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

示例

以下是**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

使用 Hue 列出表

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

执行查询后，如果向下滚动并选择**结果**选项卡，您将看到表列表，如下所示。

Impala - 创建视图

视图只不过是存储在数据库中并具有关联名称的 Impala 查询语言语句。它是以预定义 SQL 查询的形式组合的表。

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

以用户或用户类别认为自然或直观的方式组织数据。
限制对数据的访问，以便用户只能看到（有时）修改他们需要的内容，而不会更多。
汇总来自各种表的，可用于生成报告的数据。

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

语法

以下是 create view 语句的语法。**IF NOT EXISTS**是一个可选子句。如果我们使用此子句，则只有在指定的数据库中不存在具有相同名称的现有表时，才创建具有给定名称的表。

Create View IF NOT EXISTS view_name as Select statement

示例

例如，假设我们在 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 语句**的示例。在此示例中，我们正在创建一个名为**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

验证

您可以使用如下所示的**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

使用 Hue 创建视图

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

执行查询后，如果向下滚动，您将在表列表中看到名为**sample**的**视图**，如下所示。

Impala - 修改视图

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

由于**视图**是一个逻辑结构，因此**修改视图**查询不会影响任何物理数据。

语法

以下是**修改视图**语句的语法

ALTER VIEW database_name.view_name as Select statement

示例

例如，假设我们在Impala的**my_db**数据库中有一个名为**customers_view**的视图，其内容如下。

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

以下是一个**修改视图语句**的示例。在这个例子中，我们将列id、name和salary添加到**customers_view**中，而不是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

验证

您可以使用如下所示的**select**语句验证名为**customers_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

使用Hue修改视图

打开Impala查询编辑器，选择上下文为**my_db**，在其中键入**修改视图**语句，然后单击执行按钮，如下图所示。

执行查询后，名为**sample**的**视图**将相应地被修改。

Impala - 删除视图

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

语法

以下是删除视图语句的语法。

DROP VIEW database_name.view_name;

示例

例如，假设我们在Impala的**my_db**数据库中有一个名为**customers_view**的视图，其内容如下。

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

以下是一个**删除视图语句**的示例。在这个例子中，我们尝试使用**drop view**查询删除名为**customers_view**的**视图**。

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

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

Query: drop view customers_view

验证

如果您使用**show tables**语句验证表列表，您可以看到名为**customers_view**的**视图**已被删除。

[quickstart.cloudera:21000] > show tables;

这将产生以下结果。

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

使用Hue删除视图

打开Impala查询编辑器，选择上下文为**my_db**，在其中键入**删除视图**语句，然后单击执行按钮，如下图所示。

执行查询后，如果向下滚动，您可以看到一个名为**TABLES**的列表。此列表包含当前数据库中的所有**表**和**视图**。在此列表中，您可以找到指定的**视图**已被删除。

Impala - ORDER BY 子句

Impala的**ORDER BY**子句用于根据一列或多列对数据进行升序或降序排序。某些数据库默认按升序对查询结果进行排序。

语法

以下是ORDER BY子句的语法。

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

您可以分别使用关键字**ASC**或**DESC**将表中的数据排列为升序或降序。

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

示例

假设我们在**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**的升序排列**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 子句

Impala的**GROUP BY**子句与SELECT语句一起使用，用于将相同的数据排列到组中。

语法

以下是GROUP BY子句的语法。

select data from table_name Group BY col_name;

示例

假设我们在**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 子句

Impala中的**Having**子句允许您指定条件来筛选最终结果中显示的组结果。

通常，**Having**子句与**group by**子句一起使用；它对GROUP BY子句创建的组设置条件。

语法

以下是**Having**子句的语法。

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

示例

假设我们在**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

以下是如何在Impala中使用**Having**子句的示例：

[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 子句

Impala中的**limit**子句用于将结果集的行数限制为所需数量，即查询的结果集不包含超过指定限制的记录。

语法

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

select * from table_name order by id limit numerical_expression;

示例

假设我们在**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**子句，您可以使用**limit**子句将输出的记录数限制为4，如下所示。

[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 子句

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

语法

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

select data from table_name Group BY col_name;

示例

假设我们在**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

您可以使用**limit**和**order by**子句按id的升序排列表中的记录并将记录数限制为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 子句

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

语法

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

query1 union query2;

示例

假设我们在**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中使用**union**子句的示例。在这个例子中，我们使用两个单独的查询按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 子句

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

语法

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

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

示例

假设我们在**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**子句显示年龄大于25的**employee**和**customers**中的记录。

[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 运算符

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

语法

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

select distinct columns… from table_name;

示例

假设我们在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

打印页面

Impala 快速指南

Impala - 简介

什么是 Impala？

为什么选择 Impala？

Impala 的优势

Impala 的特性

关系数据库和 Impala

Hive、HBase 和 Impala

Impala 的缺点

Impala - 环境

下载 Cloudera Quick Start VM

步骤 1

步骤 2

步骤 3

步骤 4 - 下载 QuickStartVM

导入 Cloudera QuickStartVM

步骤 1

步骤 2

步骤 3

启动 Impala Shell

Impala 查询编辑器

Impala - 架构

Impala 守护程序（Impalad）

Impala状态存储

Impala元数据和元存储

查询处理接口

查询执行过程

Impala - Shell

Impala Shell命令参考

常规命令

特定于查询的选项

特定于表和数据库的选项

启动 Impala Shell

Impala – 通用命令

help命令

version命令

history命令

quit/exit命令

connect命令

Impala特定于查询的选项

Explain

Profile

特定于表和数据库的选项

Impala - 查询语言基础

Impala数据类型

Impala中的注释

Impala - 创建数据库

CREATE DATABASE 语句

语法

示例

验证

Hdfs 路径

使用 Hue 浏览器创建数据库

验证

Impala - 删除数据库

语法

示例

验证

级联

示例

使用 Hue 浏览器删除数据库

验证

Impala - 选择数据库

语法

示例

使用 Hue 浏览器选择数据库

Impala - 创建表语句

语法

示例

验证

HDFS 路径

使用 Hue 浏览器创建数据库

验证

Impala - 插入语句

语法

示例

覆盖表中的数据

示例

使用 Hue 浏览器插入数据

Impala - 选择语句