Impala – 快速指南
Impala – 快速指南
Impala – 介绍
什么是黑斑羚？
Impala 是一个 MPP（大规模并行处理）SQL 查询引擎，用于处理存储在 Hadoop 集群中的大量数据。它是一个用 C++ 和 Java 编写的开源软件。与 Hadoop 的其他 SQL 引擎相比，它提供了高性能和低延迟。
换句话说，Impala 是性能最高的 SQL 引擎（提供类似 RDBMS 的体验），它提供了访问存储在 Hadoop 分布式文件系统中的数据的最快方式。
为什么是黑斑羚？
Impala 通过利用 HDFS、HBase、Metastore、YARN 和 Sentry 等标准组件，将传统分析数据库的 SQL 支持和多用户性能与 Apache Hadoop 的可扩展性和灵活性相结合。
-
使用 Impala，与 Hive 等其他 SQL 引擎相比，用户可以使用 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 文件格式，这是一种列式存储布局，针对数据仓库场景中典型的大规模查询进行了优化。
黑斑羚的特点
以下是 cloudera Impala 的功能 –
-
Impala 在 Apache 许可下作为开源免费提供。
-
Impala 支持内存中数据处理，即它访问/分析存储在 Hadoop 数据节点上的数据，而无需移动数据。
-
您可以使用 Impala 使用类似 SQL 的查询访问数据。
-
与其他 SQL 引擎相比，Impala 可以更快地访问 HDFS 中的数据。
-
使用 Impala，您可以将数据存储在 HDFS、Apache HBase 和 Amazon s3 等存储系统中。
-
您可以将 Impala 与 Tableau、Pentaho、Micro 策略和 Zoom 数据等商业智能工具集成。
-
Impala 支持各种文件格式，例如 LZO、Sequence File、Avro、RCFile 和 Parquet。
-
Impala 使用来自 Apache Hive 的元数据、ODBC 驱动程序和 SQL 语法。
关系数据库和 Impala
Impala 使用类似于 SQL 和 HiveQL 的查询语言。下表描述了 SQL 和 Impala 查询语言之间的一些关键差异。
| Impala | 关系数据库 |
|---|---|
| Impala uses an SQL like query language that is similar to HiveQL. | 关系型数据库使用 SQL 语言。 |
| In Impala, you cannot update or delete individual records. | 在关系数据库中，可以更新或删除单个记录。 |
| Impala does not support transactions. | 关系数据库支持事务。 |
| Impala does not support indexing. | 关系数据库支持索引。 |
| Impala stores and manages large amounts of data (petabytes). | 与 Impala 相比，关系数据库处理的数据量更小（TB）。 |
Hive、Hbase 和 Impala
尽管 Cloudera Impala 使用与 Hive 相同的查询语言、元存储和用户界面，但它在某些方面与 Hive 和 HBase 不同。下表展示了 HBase、Hive 和 Impala 之间的对比分析。
| HBase | 蜂巢 | 黑斑羚 |
|---|---|---|
| HBase is wide-column store database based on Apache Hadoop. It uses the concepts of BigTable. | Hive 是一个数据仓库软件。使用它，我们可以访问和管理基于 Hadoop 的大型分布式数据集。 | Impala 是一种用于管理、分析存储在 Hadoop 上的数据的工具。 |
| The data model of HBase is wide column store. | Hive 遵循关系模型。 | Impala 遵循关系模型。 |
| HBase is developed using Java language. | Hive 是使用 Java 语言开发的。 | Impala 是使用 C++ 开发的。 |
| The data model of HBase is schema-free. | Hive 的数据模型是基于 Schema 的。 | Impala 的数据模型是基于 Schema 的。 |
| HBase provides Java, RESTful and, Thrift API’s. | Hive 提供 JDBC、ODBC、Thrift API。 | Impala 提供 JDBC 和 ODBC API。 |
| Supports programming languages like C, C#, C++, Groovy, Java PHP, Python, and Scala. | 支持 C++、Java、PHP 和 Python 等编程语言。 | Impala 支持所有支持 JDBC/ODBC 的语言。 |
| HBase provides support for triggers. | 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的下载页面。
单击Get ONE NOW按钮，接受许可协议，然后单击提交按钮，如下所示。
Cloudera 提供其与 VM 兼容的 VMware、KVM 和 VIRTUALBOX。选择所需的版本。在我们的教程中，我们将使用虚拟框演示Cloudera QuickStartVM设置，因此单击VIRTUALBOX 下载按钮，如下面的快照所示。
这将开始下载一个名为cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf 的文件，它是一个虚拟盒映像文件。
导入 Cloudera QuickStartVM
下载cloudera-quickstart-vm-5.5.0-0-virtualbox.ovf文件后，我们需要使用virtual box导入。为此，首先，您需要在系统中安装虚拟盒。按照下面给出的步骤导入下载的图像文件。
步骤1
从以下链接下载虚拟盒子并安装https://www.virtualbox.org/
第2步
打开虚拟盒子软件。单击File并选择Import Appliance，如下所示。
第 3 步
单击Import Appliance 后，您将看到 Import Virtual Appliance 窗口。选择下载的图像文件的位置，如下所示。
导入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 进行登录。
一登录Hue浏览器，就可以看到如下图所示的Hue浏览器快速启动向导。
单击查询编辑器下拉菜单后，您将获得 Impala 支持的编辑器列表，如下面的屏幕截图所示。
在点击帕拉在下拉菜单中，您将获得Impala的查询编辑器如下图所示。
Impala – 架构
Impala 是一个 MPP（大规模并行处理）查询执行引擎，运行在 Hadoop 集群中的多个系统上。与传统存储系统不同，impala 与其存储引擎分离。它具有三个主要组件，即 Impala 守护进程（Impalad）、Impala Statestore 和 Impala 元数据或元存储。
Impala 守护进程( Impalad )
Impala 守护进程（也称为impalad）在安装了 Impala 的每个节点上运行。它接受来自impala shell、hue 浏览器等各种接口的查询……并处理它们。
每当向特定节点上的 impalad 提交查询时，该节点将充当该查询的“协调器节点”。多个查询也由运行在其他节点上的Impalad提供服务。接受查询后，Impalad读取和写入数据文件，并通过将工作分配到 Impala 集群中的其他 Impala 节点来并行化查询。当在各种Impalad 实例上处理查询时，它们都会将结果返回给中央协调节点。
根据需求，可以将查询提交到专用的Impalad或以负载平衡的方式提交到集群中的另一个Impalad。
Impala 州立商店
Impala 还有一个重要的组件叫做 Impala State store，它负责检查每个Impalad的健康状况，然后频繁地将每个 Impala 守护进程的健康状况转发给其他守护进程。这可以在运行 Impala 服务器或集群中其他节点的同一节点上运行。
Impala State 存储守护进程的名称是State stored。Impalad将其健康状态报告给 Impala State store 守护进程，即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 interface – 您可以使用 Hue 浏览器处理 Impala 查询。在 Hue 浏览器中，您有 Impala 查询编辑器，您可以在其中键入和执行 impala 查询。要访问此编辑器，首先需要登录 Hue 浏览器。
-
ODBC/JDBC 驱动程序– 就像其他数据库一样，Impala 提供 ODBC/JDBC 驱动程序。使用这些驱动程序，您可以通过支持这些驱动程序的编程语言连接到impala，并使用这些编程语言构建在impala 中处理查询的应用程序。
查询执行程序
每当用户使用提供的任何接口传递查询时，集群中的一个 Impalad 都会接受该查询。此 Impalad 被视为该特定查询的协调器。
收到查询后，查询协调器使用Hive 元存储中的表模式验证查询是否合适。之后，它从 HDFS 名称节点收集有关执行查询所需的数据位置的信息，并将此信息发送到其他 impalad 以执行查询。
所有其他 Impala 守护进程读取指定的数据块并处理查询。一旦所有守护进程完成它们的任务，查询协调器就会将结果收集回来并将其传递给用户。
黑斑羚 – 壳牌
在前面的章节中，我们已经看到了使用 cloudera 安装 Impala 及其架构。
- Impala shell（命令提示符）
- 色调（用户界面）
- ODBC 和 JDBC（第三方库）
本章解释了如何启动 Impala Shell 以及 shell 的各种选项。
Impala Shell 命令参考
Impala shell 的命令分为通用命令、查询特定选项以及表和数据库特定选项，如下所述。
一般命令
- 帮助
- 版本
- 历史
- 壳（或）！
- 连接
- 退出 | 放弃
查询特定选项
- 设置/取消设置
- 轮廓
- 解释
表和数据库特定选项
- 改变
- 描述
- 降低
- 插
- 选择
- 表演
- 用
启动 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 的通用命令解释如下 –
帮助命令
Impala shell的帮助命令为您提供了 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
版本命令
该版本命令给你黑斑羚的当前版本，如下图所示。
[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)
历史命令
Impala的历史命令显示在 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命令退出Impala shell ，如下所示。
[quickstart.cloudera:21000] > exit; Goodbye cloudera
连接命令
的连接命令是用来连接到帕拉的给定实例。如果您不指定任何实例，则它连接到默认端口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 的查询特定命令接受查询。它们解释如下 –
解释
该解释命令返回给定的查询执行计划。
[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命令返回了解释查询的低级信息。
[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 中的表和数据特定选项。
| Sr.No | 命令和解释 |
|---|---|
| 1 |
Alter 的ALTER命令用于更改一个表的结构和名称帕拉。 |
| 2 |
Describe Impala的describe命令给出了表的元数据。它包含列及其数据类型等信息。该描述命令有递减的捷径。 |
| 3 |
Drop 的下降命令被用于去除从帕拉，一个构建体，其中的构建体可以是一个表，视图或数据库功能。 |
| 4 |
insert Impala的插入命令用于，
|
| 5 |
select 的选择语句用于对特定数据组执行所期望的操作。它指定要在其上完成某些操作的数据集。您可以打印或存储（在文件中）select 语句的结果。 |
| 6 |
show Impala的show语句用于显示表、数据库和表等各种构造的元存储。 |
| 7 |
use Impala的use语句用于将当前上下文更改为所需的数据库。 |
Impala – 查询语言基础
Impala 数据类型
下表描述了 Impala 数据类型。
| Sr.No | 数据类型和描述 |
|---|---|
| 1 |
BIGINT 此数据类型存储数值，此数据类型的范围为 -9223372036854775808 至 9223372036854775807。此数据类型用于 create table 和 alter table 语句。 |
| 2 |
BOOLEAN 此数据类型仅存储真值或假值，用于创建表语句的列定义。 |
| 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 这是一种复杂的数据类型，用于表示单个项目的多个字段。 |
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 运算符。
Impala – 创建数据库
在 Impala 中，数据库是一种在其命名空间中保存相关表、视图和函数的结构。它在 HDFS 中表示为目录树；它包含表分区和数据文件。本章介绍如何在 Impala 中创建数据库。
创建数据库语句
该CREATE DATABASE语句来创建帕拉一个新的数据库。
句法
以下是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查询给出因帕拉数据库列表，因此您可以验证是否在创建数据库，使用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 文件系统中创建数据库，您需要指定要创建数据库的位置。
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.
使用级联，您可以直接删除此数据库（无需手动删除其内容），如下所示。
[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语句用于在因帕拉所需的数据库中创建一个新表。创建基本表涉及命名表并定义其列和每列的数据类型。
句法
以下是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语句验证表是否已创建。
首先需要将上下文切换到所需表所在的数据库，如下图。
[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 Statement。然后单击执行按钮，如下面的屏幕截图所示。
执行查询后，将光标轻轻移动到下拉菜单的顶部，您会发现一个刷新符号。如果单击刷新符号，将刷新数据库列表并将最近所做的更改应用于它。
确认
单击编辑器左侧标题DATABASE下的下拉菜单。在那里你可以看到一个数据库列表。选择数据库my_db如下所示。
在选择数据库my_db 时，您可以看到其中的表列表，如下所示。在这里您可以找到新创建的学生表，如下所示。
Impala – 插入语句
Impala的INSERT语句有两个子句 – into和overwrite。带有into子句的Insert 语句用于将新记录添加到数据库中的现有表中。
句法
INSERT语句有两种基本语法，如下所示 –
插入 table_name (column1, column2, column3,...columnN) 值（值1，值2，值3，...值N）；
此处，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] > 插入员工值 (2, 'Khilan', 25, '德里', 15000 );
在执行上述语句时，一条记录被插入到名为employee的表中，显示以下消息。
Query: insert into employee values (2, 'Khilan', 25, 'Delhi', 15000 ) Inserted 1 row(s) in 0.31s
您可以在员工表中插入更多记录，如下所示。
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 中的员工表将如下所示。
+----+----------+-----+-----------+--------+ | 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
在验证表时，您可以观察到表员工的所有记录都被新记录覆盖，如下所示。
+----+------+-----+---------------+--------+ | id | name | age | address | salary | +----+------+-----+---------------+--------+ | 1 | Ram | 26 | Vishakhapatnam| 37000 | +----+------+-----+---------------+--------+
使用 Hue 浏览器插入数据
打开 Impala 查询编辑器并在其中键入插入语句。然后单击执行按钮，如下面的屏幕截图所示。
执行查询/语句后，这条记录被添加到表中。
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语句获取客户表的所有记录的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
您还可以使用如下所示的选择查询从客户表中获取所有记录。
[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语句获取客户表的描述，如下所示 –
[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中的表列表，您可以在其中找到customer表，如下所示。
[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
从表中删除列
句法
ALTER TABLE to DROP COLUMN在现有表中的基本语法如下 –
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] > 描述用户； 查询：描述用户 +-----------+--------+---------+ | 姓名 | 类型 | 评论 | +-----------+--------+---------+ | 身份证 | 国际| | | 姓名 | 字符串 | | | 年龄 | 国际| | | 地址 | 字符串 | | | 工资| bigint | | | 电话号码| bigint | | +-----------+--------+---------+ 在 0.11 秒内获取 6 行
更改列的名称和类型
句法
更改现有表中列的名称和数据类型的 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语句验证表用户的元数据。您可以观察到 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 子句时不存在的表，则会产生错误。您可以选择指定database_name和table_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语句验证表是否被删除。
首先需要将上下文切换到所需表所在的数据库，如下图。
[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 Statement。然后单击执行按钮，如下面的屏幕截图所示。
执行查询后，将光标轻轻移动到下拉菜单的顶部，您会发现一个刷新符号。如果单击刷新符号，将刷新数据库列表并将最近所做的更改应用于它。
确认
单击编辑器左侧标题DATABASE下的下拉菜单。在那里你可以看到一个数据库列表；选择数据库my_db如下所示。
在选择数据库my_db 时，您可以看到其中的表列表，如下所示。在这里您无法在列表中找到已删除的表学生，如下所示。
Impala – 截断表
Impala的Truncate Table语句用于从现有表中删除所有记录。
您也可以使用 DROP TABLE 命令删除一个完整的表，但它会从数据库中删除完整的表结构，如果您希望存储一些数据，则需要再次重新创建该表。
句法
以下是 truncate table 语句的语法。
truncate table_name;
例子
假设，我们在 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 语句在 Impala 中截断表的示例。在这里，我们将删除名为customers的表的所有记录。
[quickstart.cloudera:21000] > truncate customers;
在执行上述语句时，Impala 删除指定表的所有记录，显示以下消息。
Query: truncate customers Fetched 0 row(s) in 0.37s
确认
如果验证customers表的内容，在删除操作后，使用select语句，会得到如下所示的空行。
[quickstart.cloudera:21000] > select * from customers; Query: select * from customers Fetched 0 row(s) in 0.12s
使用 Hue 浏览器截断表格
打开 Impala 查询编辑器并在其中键入truncate Statement。然后单击执行按钮，如下面的屏幕截图所示。
执行查询/语句后，表中的所有记录都被删除。
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
以下是创建视图语句的示例。在此示例中，我们将创建一个包含列、名称和年龄的客户表视图。
[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语句的语法
ALTER VIEW database_name.view_name as Select 语句
例子
例如，假设我们在 Impala的my_db数据库中有一个名为customers_view的视图，其内容如下。
+----------+-----+ | name | age | +----------+-----+ | Komal | 22 | | Khilan | 25 | | Ramesh | 32 | | Hardik | 27 | | Chaitali | 25 | | kaushik | 23 | +----------+-----+
以下是Alter View Statement的示例。在这个例子中，我们将列 id、name 和salary 而不是name 和age 添加到customers_view 中。
[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
使用色调改变视图
打开 Impala 查询编辑器，选择上下文作为my_db，并在其中键入Alter View语句并单击执行按钮，如下面的屏幕截图所示。
执行查询后，名为sample的视图将相应更改。
Impala – 删除视图
Impala的Drop View查询用于删除现有视图。由于视图是一个逻辑结构，因此放置视图查询不会影响任何物理数据。
句法
以下是 drop view 语句的语法。
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，并在其中键入Drop view语句并单击执行按钮，如下面的屏幕截图所示。
执行查询后，如果向下滚动，您可以看到一个名为TABLES的列表。此列表包含当前数据库中的所有表和视图。从该列表中，您可以发现指定的视图已被删除。
Impala – 按条款排序
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 的升序排列客户表中的数据的示例。
[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子句按降序排列客户表的数据，如下所示。
[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 – 按条款分组
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子句与group by子句一起使用；它将条件放在由 GROUP BY 子句创建的组上。
句法
以下是Have子句的语法。
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中使用Have子句的示例–
[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 – 限制条款
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
现在，使用限制条款，你可以限制输出的记录数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 – 抵消条款
通常，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
您可以按 id 的升序排列表中的记录，并将记录数限制为 4，使用limit和order by子句，如下所示。
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 的顺序获取客户表中的记录，并打印从 0 开始的前四行th 排。
[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
以同样的方式，您可以从customer表中从偏移量为 5 的行开始获取四条记录，如下所示。
[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 – 联合条款
您可以使用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 – 带子句
如果查询太复杂，我们可以为复杂部分定义别名，并使用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 岁的员工和客户的记录。
[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 – 独特的运营商
Impala 中的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 的工资，并使用不同的运算符，我们可以选择如下所示的唯一值。
[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
