Teradata快速向导
Teradata - 简介
什么是Teradata？
Teradata是受欢迎的关系数据库管理系统之一。 它主要适用于构建大规模数据仓库应用程序。 Teradata通过并行性的概念实现了这一点。 它是由Teradata公司开发的。
Teradata的历史
以下是Teradata历史的快速摘要，列出了主要里程碑。
1979 - 并入Teradata。
1984 - 发布第一个数据库计算机DBC / 1012。
1986 - 财富杂志将Teradata命名为“年度产品”。
1999 - 世界上使用Teradata的130千兆字节的最大数据库。
2002 - Teradata V2R5发布了分区主索引和压缩。
2006 - 推出Teradata主数据管理解决方案。
2008 - 使用Active Data Warehousing发布的Teradata 13.0。
2011 - 收购Teradata Aster并进入高级分析空间。
2012 - 推出Teradata 14.0。
2014 - 推出Teradata 15.0。
Teradata的特点
以下是Teradata的一些功能 -
无限并行化 - Teradata数据库系统基于大规模并行处理（MPP）架构。 MPP架构在整个系统上平均分配负载。 Teradata系统在其进程之间分割任务，并并行运行它们以确保任务快速完成。
没有共享架构 - Teradata的架构称为共享无架构。 Teradata节点，其访问模块处理器（AMP）和与AMP相关联的磁盘独立工作。 他们不会与他人分享。
线性可扩展性 - Teradata系统具有高度可扩展性。 它们可以扩展到2048个节点。 例如，通过将AMP的数量加倍，可以使系统的容量增加一倍。
连接 - Teradata可连接到通道连接的系统，如主机或网络连接的系统。
成熟优化程序 - Teradata优化程序是市场上成熟的优化程序之一。 它自从开始就被设计为平行的。 它已经针对每个版本进行了优化。
SQL - Teradata支持行业标准SQL与存储在表中的数据进行交互。 除此之外，它提供自己的扩展。
强大的实用工具 - Teradata提供强大的实用程序，用于从/向Teradata系统导入/导出数据，例如FastLoad，MultiLoad，FastExport和TPT。
自动分发 - Teradata自动将数据均匀分发到磁盘，而无需任何手动干预。
Teradata - 简介...
Teradata为VMWARE提供Teradata express，这是一个完全可操作的Teradata虚拟机。 它提供高达1 TB的存储。 Teradata提供40GB和1TB版本的VMware。
先决条件
由于VM是64位，因此您的CPU必须支持64位。
Windows的安装步骤
步骤2 - 解压缩文件并指定目标文件夹。
步骤3 - 从链接 > https://my.vmware.com/web/vmware/downloads 。 它可用于Windows和Linux。 下载适用于Windows的VMWARE工作站播放器。
步骤4 - 下载完成后，安装软件。
步骤5 - 安装完成后，运行VMWARE客户端。
步骤6 - 选择“打开虚拟机”。 浏览提取的Teradata VMWare文件夹，然后选择扩展名为.vmdk的文件。
步骤7 - Teradata VMWare已添加到VMWare客户端。 选择添加的Teradata VMware，然后单击“播放虚拟机”。
步骤7 - Teradata VMWare已添加到VMWare客户端。 选择添加的Teradata VMware，然后单击“播放虚拟机”。...
步骤9 - 以root身份输入用户名，按tab并以root身份输入password，然后再次按Enter。
步骤10 - 一旦桌面上出现以下屏幕，双击“root\'s home”。 然后双击“Genome\'s Terminal”。 这将打开Shell。
步骤11 - 从以下shell中，输入命令/etc/init.d/tpa start。 这将启动Teradata服务器。
启动BTEQ
BTEQ实用程序用于交互式提交SQL查询。 以下是启动BTEQ实用程序的步骤。
步骤1 - 输入命令/ sbin / ifconfig，记下VMWare的IP地址。
步骤2 - 运行命令bteq。 在登录提示符处，输入命令。
登录＆lt; ip address＆gt; / dbc，dbc; 并在密码提示符下输入password as dbc;
您可以使用BTEQ登录Teradata系统并运行任何SQL查询。
Teradata - 架构
Teradata架构基于大规模并行处理（MPP）架构。 Teradata的主要组件是解析引擎，BYNET和访问模块处理器（AMP）。 下图显示了Teradata节点的高级架构。
Teradata的组件
Teradata的关键组件如下 -
节点 - 它是Teradata系统中的基本单元。 Teradata系统中的每个单独的服务器都称为节点。 节点由自己的操作系统，CPU，内存，自己的Teradata RDBMS软件副本和磁盘空间组成。 机柜由一个或多个节点组成。
-
解析引擎 - 解析引擎负责从客户端接收查询并准备有效的执行计划。 解析引擎的职责是 -
从客户端接收SQL查询
解析SQL查询检查语法错误
检查用户是否具有针对SQL查询中使用的对象的所需特权
检查在SQL中使用的对象是否确实存在
准备执行计划以执行SQL查询并将其传递给BYNET
从AMP接收结果并发送到客户端
消息传递层 - 消息传递层称为BYNET，是Teradata系统中的网络层。 它允许PE和AMP之间以及节点之间的通信。 它从解析引擎接收执行计划并发送到AMP。 类似地，它从AMP接收结果并发送到解析引擎。
访问模块处理器（AMP） - 称为虚拟处理器（vprocs）的AMP是实际存储和检索数据的AMP。 AMP从解析引擎接收数据和执行计划，执行任何数据类型转换，聚合，过滤，排序并将数据存储在与其关联的磁盘中。 表中的记录均匀分布在系统中的AMP之间。 每个AMP与存储数据的一组磁盘相关联。 只有该AMP可以从磁盘读取/写入数据。
存储架构
当客户端运行查询以插入记录时，解析引擎将记录发送到BYNET。 BYNET检索记录并将该行发送到目标AMP。 AMP将这些记录存储在其磁盘上。 下图显示了Teradata的存储体系结构。
检索体系结构
当客户端运行查询以检索记录时，解析引擎会向BYNET发送请求。 BYNET将检索请求发送到适当的AMP。 然后AMPs并行搜索其磁盘并识别所需的记录并发送到BYNET。 BYNET然后将记录发送到解析引擎，解析引擎又将发送到客户端。 以下是Teradata的检索体系结构。
Teradata - 架构...
关系数据库管理系统（RDBMS）是一种DBMS软件，有助于与数据库进行交互。 它们使用结构化查询语言（SQL）与存储在表中的数据进行交互。
数据库
数据库是逻辑相关数据的集合。 它们被许多用户访问用于不同的目的。 例如，销售数据库包含有关存储在许多表中的销售的全部信息。
数据库...
表是存储数据的RDBMS中的基本单元。 表是行和列的集合。 以下是employee表的示例。
| 员工不 | 名字 | 姓 | 生日 |
|---|---|---|---|
| 101 | Mike | James | 1/5/1980 |
| 104 | Alex | Stuart | 11/6/1984 |
| 102 | Robert | Williams | 3/5/1983 |
| 105 | Robert | James | 12/1/1984 |
| 103 | Peter | Paul | 4/1/1983 |
列
列包含类似的数据。 例如，Employee表中的BirthDate列包含所有雇员的birth_date信息。
| 生日 |
|---|
| 1/5/1980 |
| 11/6/1984 |
| 3/5/1983 |
| 12/1/1984 |
| 4/1/1983 |
列...
行是所有列的一个实例。 例如，在员工表中，一行包含有关单个员工的信息。
| 员工不 | 名字 | 姓 | 生日 |
|---|---|---|---|
| 101 | Mike | James | 1/5/1980 |
首要的关键
主键用于唯一标识表中的行。 主键列中不允许有重复值，它们不能接受NULL值。 它是表中的必填字段。
首要的关键...
外键用于建立表之间的关系。 子表中的外键被定义为父表中的主键。 一个表可以有多个外键。 它可以接受重复值和空值。 外键在表中是可选的。
Teradata - 数据类型
表中的每个列都与数据类型相关联。 数据类型指定将在列中存储什么类型的值。 Teradata支持多种数据类型。 以下是一些常用的数据类型。
| 数据类型 | 长度（字节） | 值的范围 |
|---|---|---|
| BYTEINT | 1 | -128至＆amp; plus; 127 |
| SMALLINT | 2 | -32768到＆amp; plus; 32767 |
| INTEGER | 4 | -2,147,483,648至＆amp; plus; 2147,483,647 |
| BIGINT | 8 | -9,233,372,036,854,775,80 8至＆amp; plus; 9,233,372,036,854,775,8 07 |
| DECIMAL | 1-16 | |
| NUMERIC | 1-16 | |
| FLOAT | 8 | IEEE格式 |
| CHAR | 固定格式 | 1-64,000 |
| VARCHAR | Variable | 1-64,000 |
| DATE | 4 | YYYYYMMDD |
| TIME | 6或8 | HHMMSS.nnnnnn 或 HHMMSS.nnnnnn＆amp; plus; HHMM |
| TIMESTAMP | 10或12 | YYMMDDHHMMSS.nnnnnn 或 YYMMDDHHMMSS.nnnnnn＆amp; plus; HHMM |
Teradata - 表
关系模型中的表定义为数据集合。 它们表示为行和列。
表类型
类型Teradata支持不同类型的表。
永久表 - 这是默认表，它包含用户插入的数据，并永久存储数据。
易失性表 - 插入到易失性表中的数据仅在用户会话期间保留。 在会话结束时删除表和数据。 这些表主要用于在数据变换期间保存中间数据。
全局临时表 - 全局临时表的定义是持久的，但是在用户会话结束时删除表中的数据。
派生表 - 派生表保存查询中的中间结果。 它们的生命周期在创建，使用和丢弃它们的查询中。
设置Vs Multiset
Teradata基于如何处理重复记录将表分类为SET或MULTISET表。 定义为SET表的表不存储重复记录，而MULTISET表可存储重复记录。
| 值的范围... | 表命令＆amp; 描述 |
|---|---|
| 1 |
Create Table
CREATE TABLE命令用于在Teradata中创建表。 |
| 2 |
Alter Table
ALTER TABLE命令用于从现有表中添加或删除列。 |
| 3 |
Drop Table
DROP TABLE命令用于删除表。 |
Teradata - 表...
本章介绍用于操作存储在Teradata表中的数据的SQL命令。
表类型...
INSERT INTO语句用于将记录插入到表中。
句法
以下是INSERT INTO的通用语法。
INSERT INTO <tablename> (column1, column2, column3,…) VALUES (value1, value2, value3 …);
例子
以下示例将记录插入到员工表中。
INSERT INTO Employee ( EmployeeNo, FirstName, LastName, BirthDate, JoinedDate, DepartmentNo ) VALUES ( 101, 'Mike', 'James', '1980-01-05', '2005-03-27', 01 );
插入上述查询后，可以使用SELECT语句从表中查看记录。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
从另一个表插入
INSERT SELECT语句用于从另一个表插入记录。
例子
以下是INSERT INTO的通用语法。
INSERT INTO <tablename> (column1, column2, column3,…) SELECT column1, column2, column3… FROM <source table>;
例子
以下示例将记录插入到员工表中。 在运行以下插入查询之前，创建具有与employee表相同的列定义的名为Employee_Bkup的表。
INSERT INTO Employee_Bkup ( EmployeeNo, FirstName, LastName, BirthDate, JoinedDate, DepartmentNo ) SELECT EmployeeNo, FirstName, LastName, BirthDate, JoinedDate, DepartmentNo FROM Employee;
当执行上述查询时，它将把employee表中的所有记录插入到employee_bkup表中。
规则
在VALUES列表中指定的列数应该与INSERT INTO子句中指定的列匹配。
NOT NULL列的值是必需的。
如果未指定值，则为可空字段插入NULL。
在VALUES子句中指定的列的数据类型应与INSERT子句中的列的数据类型兼容。
从另一个表插入...
UPDATE语句用于更新表中的记录。
句法
以下是UPDATE的通用语法。
UPDATE <tablename> SET <columnnamme> = <new value> [WHERE condition];
例子
以下示例将员工部门更新为03（对于员工101）。
UPDATE Employee SET DepartmentNo = 03 WHERE EmployeeNo = 101;
在以下输出中，您可以看到对于员工101，部门从1更新为3。
SELECT Employeeno, DepartmentNo FROM Employee; *** Query completed. One row found. 2 columns returned. *** Total elapsed time was 1 second. EmployeeNo DepartmentNo ----------- ------------- 101 3
规则
您可以更新表的一个或多个值。
如果未指定WHERE条件，则表的所有行都受到影响。
您可以使用另一个表中的值更新表。
删除记录
DELETE FROM语句用于更新表中的记录。
句法
以下是DELETE FROM的通用语法。
DELETE FROM <tablename> [WHERE condition];
例子
以下示例从表employee中删除员工101。
DELETE FROM Employee WHERE EmployeeNo = 101;
在以下输出中，您可以看到从表中删除了员工101。
SELECT EmployeeNo FROM Employee; *** Query completed. No rows found. *** Total elapsed time was 1 second.
规则
您可以更新表的一个或多个记录。
如果未指定WHERE条件，则表的所有行都将被删除。
您可以使用另一个表中的值更新表。
Teradata - SELECT语句
SELECT语句用于从表中检索记录。
句法
以下是SELECT语句的基本语法。
SELECT column 1, column 2, ..... FROM tablename;
例子
考虑下面的employee表。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
以下是SELECT语句的示例。
SELECT EmployeeNo,FirstName,LastName FROM Employee;
执行此查询时，它从employee表中提取EmployeeNo，FirstName和LastName列。
EmployeeNo FirstName LastName ----------- ------------------------------ --------------------------- 101 Mike James 104 Alex Stuart 102 Robert Williams 105 Robert James 103 Peter Paul
如果要从表中提取所有列，可以使用以下命令，而不是列出所有列。
SELECT * FROM Employee;
上述查询将从employee表中获取所有记录。
WHERE子句
WHERE子句用于过滤SELECT语句返回的记录。 条件与WHERE子句相关联。 仅返回满足WHERE子句中的条件的记录。
例子
以下是具有WHERE子句的SELECT语句的语法。
SELECT * FROM tablename WHERE[condition];
例子
以下查询获取EmployeeNo为101的记录。
SELECT * FROM Employee WHERE EmployeeNo = 101;
执行此查询时，它返回以下记录。
EmployeeNo FirstName LastName ----------- ------------------------------ ----------------------------- 101 Mike James
ORDER BY
执行SELECT语句时，返回的行不按任何特定顺序。 ORDER BY子句用于按任何列升序/降序排列记录。
例子
以下是带有ORDER BY子句的SELECT语句的语法。
SELECT * FROM tablename ORDER BY column 1, column 2..;
例子
以下查询从employee表中提取记录，并按FirstName对结果排序。
SELECT * FROM Employee ORDER BY FirstName;
当执行上述查询时，它将产生以下输出。
EmployeeNo FirstName LastName
----------- ------------------------------ -----------------------------
104 Alex Stuart
101 Mike James
103 Peter Paul
102 Robert Williams
105 Robert James
通过...分组
GROUP BY子句与SELECT语句一起使用，并将类似的记录安排到组中。
例子
以下是具有GROUP BY子句的SELECT语句的语法。
SELECT column 1, column2 …. FROM tablename GROUP BY column 1, column 2..;
例子
以下示例按DepartmentNo列对记录进行分组，并标识每个部门的总计数。
SELECT DepartmentNo,Count(*) FROM Employee GROUP BY DepartmentNo;
当执行上述查询时，它将产生以下输出。
DepartmentNo Count(*)
------------ -----------
3 1
1 1
2 3
Teradata - SELECT语句...
Teradata支持以下逻辑和条件运算符。 这些运算符用于执行比较和组合多个条件。
| 生日... | 含义 |
|---|---|
| > | 比...更棒 |
| < | 少于 |
| >= | 大于或等于 |
| <= | 小于或等于 |
| = | 等于 |
| BETWEEN | 如果值在范围内 |
| IN | 如果＆lt;表达式＆gt; |
| 未输入 | 未输入... |
| IS NULL | IS NULL ... |
| IS NOT NULL | IS NOT NULL ... |
| AND | 组合多个条件。 仅当满足所有条件时，才评估为true |
| OR | 组合多个条件。 如果满足任一条件，则计算为true。 |
| NOT | 反转条件的含义 |
之间
BETWEEN命令用于检查值是否在值的范围内。
例子
考虑下面的employee表。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
以下示例获取员工编号介于101,102和103之间范围内的记录。
SELECT EmployeeNo, FirstName FROM Employee WHERE EmployeeNo BETWEEN 101 AND 103;
当执行上述查询时，它返回雇员记录，员工编号在101和102之间。
*** Query completed. 3 rows found. 2 columns returned. *** Total elapsed time was 1 second. EmployeeNo FirstName ----------- ------------------------------ 101 Mike 102 Robert 103 Peter
之间...
IN命令用于根据给定的值列表检查值。
例子
以下示例获取员工编号为101，102和103的记录。
SELECT EmployeeNo, FirstName FROM Employee WHERE EmployeeNo in (101,102,103);
上述查询返回以下记录。
*** Query completed. 3 rows found. 2 columns returned. *** Total elapsed time was 1 second. EmployeeNo FirstName ----------- ------------------------------ 101 Mike 102 Robert 103 Peter
不是
NOT IN命令反转IN命令的结果。 它获取的值与给定列表不匹配的记录。
例子
以下示例获取员工编号不在101，102和103中的记录。
SELECT * FROM Employee WHERE EmployeeNo not in (101,102,103);
上述查询返回以下记录。
*** Query completed. 2 rows found. 6 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo FirstName LastName
----------- ------------------------------ -----------------------------
104 Alex Stuart
105 Robert James
Teradata - SET运算符
SET运算符合并多个SELECT语句的结果。 这可能看起来类似于连接，但连接组合来自多个表的列，而SET运算符组合来自多个行的行。
规则
每个SELECT语句的列数应该相同。
每个SELECT的数据类型必须兼容。
ORDER BY应该只包含在最终的SELECT语句中。
不是...
UNION语句用于组合多个SELECT语句的结果。 它忽略重复。
句法
下面是UNION语句的基本语法。
SELECT col1, col2, col3… FROM <table 1> [WHERE condition] UNION SELECT col1, col2, col3… FROM <table 2> [WHERE condition];
例子
考虑下面的员工表和工资表。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
| 员工不 | 毛 | 毛... | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
以下UNION查询组合Employee和Salary表中的EmployeeNo值。
SELECT EmployeeNo FROM Employee UNION SELECT EmployeeNo FROM Salary;
执行查询时，将生成以下输出。
EmployeeNo ----------- 101 102 103 104 105
UNION ALL
UNION ALL语句与UNION类似，它合并来自多个表（包括重复行）的结果。
例子
以下是UNION ALL语句的基本语法。
SELECT col1, col2, col3… FROM <table 1> [WHERE condition] UNION ALL SELECT col1, col2, col3… FROM <table 2> [WHERE condition];
例子
以下是UNION ALL语句的示例。
SELECT EmployeeNo FROM Employee UNION ALL SELECT EmployeeNo FROM Salary;
当执行上述查询时，它将产生以下输出。 你可以看到它也返回重复。
EmployeeNo
-----------
101
104
102
105
103
101
104
102
103
UNION ALL...
当执行上述查询时，它将产生以下输出。 你可以看到它也返回重复。...
例子
以下是INTERSECT语句的基本语法。
SELECT col1, col2, col3… FROM <table 1> [WHERE condition] INTERSECT SELECT col1, col2, col3… FROM <table 2> [WHERE condition];
例子
以下是INTERSECT语句的示例。 它返回两个表中存在的EmployeeNo值。
SELECT EmployeeNo FROM Employee INTERSECT SELECT EmployeeNo FROM Salary;
当执行上述查询时，它返回以下记录。 EmployeeNo 105被排除，因为它不存在于SALARY表中。
EmployeeNo ----------- 101 104 102 103
MINUS / EXCEPT
MINUS / EXCEPT命令组合多个表中的行，并返回第一个SELECT但不包含第二个SELECT的行。 它们都返回相同的结果。
例子
以下是MINUS语句的基本语法。
SELECT col1, col2, col3… FROM <table 1> [WHERE condition] MINUS SELECT col1, col2, col3… FROM <table 2> [WHERE condition];
例子
以下是MINUS语句的示例。
SELECT EmployeeNo FROM Employee MINUS SELECT EmployeeNo FROM Salary;
执行此查询时，它返回以下记录。
EmployeeNo ----------- 105
Teradata - SET运算符...
Teradata提供了几个函数来操作字符串。 这些功能与ANSI标准兼容。
| NetPay... | 字符串函数＆amp; 描述 |
|---|---|
| 1 |
||
将字符串连接在一起 |
| 2 |
SUBSTR
提取字符串的一部分（Teradata扩展） |
| 3 |
SUBSTRING
提取字符串的一部分（ANSI标准） |
| 4 |
INDEX
查找字符在字符串中的位置（Teradata扩展） |
| 5 |
POSITION
定位字符在字符串中的位置（ANSI标准） |
| 6 |
TRIM
修剪字符串中的空格 |
| 7 |
UPPER
将字符串转换为大写 |
| 8 |
LOWER
将字符串转换为小写 |
例子
下表列出了一些带有结果的字符串函数。
| 字符串函数＆amp; 描述... | 结果 |
|---|---|
| SELECT SUBSTRING（\'warehouse\'FROM 1 FOR 4） | Ware |
| SELECT SUBSTR（\'warehouse\'，1,4） | Ware |
| SELECT\'data\'|| \'\'|| \'仓库\' | SELECT\'data\'|| \'\'|| \'仓库\'... |
| SELECT UPPER（\'data\'） | DATA |
| SELECT LOWER（\'DATA\'） | Data |
Teradata - 日期/时间函数
本章讨论Teradata中可用的日期/时间功能。
例子...
日期使用以下公式在内部存储为整数。
((YEAR - 1900) * 10000) + (MONTH * 100) + DAY
您可以使用以下查询来检查日期的存储方式。
SELECT CAST(CURRENT_DATE AS INTEGER);
由于日期存储为整数，您可以对它们执行一些算术运算。 Teradata提供执行这些操作的函数。
提取
EXTRACT函数从DATE值提取日，月和年的部分。 此功能还用于从TIME / TIMESTAMP值提取小时，分钟和秒。
例子
以下示例显示如何从日期和时间戳值提取年，月，日期，小时，分钟和秒值。
SELECT EXTRACT(YEAR FROM CURRENT_DATE);
EXTRACT(YEAR FROM Date)
-----------------------
2016
SELECT EXTRACT(MONTH FROM CURRENT_DATE);
EXTRACT(MONTH FROM Date)
------------------------
1
SELECT EXTRACT(DAY FROM CURRENT_DATE);
EXTRACT(DAY FROM Date)
------------------------
1
SELECT EXTRACT(HOUR FROM CURRENT_TIMESTAMP);
EXTRACT(HOUR FROM Current TimeStamp(6))
---------------------------------------
4
SELECT EXTRACT(MINUTE FROM CURRENT_TIMESTAMP);
EXTRACT(MINUTE FROM Current TimeStamp(6))
-----------------------------------------
54
SELECT EXTRACT(SECOND FROM CURRENT_TIMESTAMP);
EXTRACT(SECOND FROM Current TimeStamp(6))
-----------------------------------------
27.140000
提取...
Teradata提供INTERVAL函数以对DATE和TIME值执行算术运算。 有两种类型的INTERVAL函数。
年 - 月间隔
- YEAR
- YEAR TO MONTH
- MONTH
日间隔
- DAY
- DAY TO HOUR
- DAY TO MINUTE
- DAY TO SECOND
- HOUR
- HOUR TO MINUTE
- HOUR TO SECOND
- MINUTE
- MINUTE TO SECOND
- SECOND
例子
以下示例将3年添加到当前日期。
SELECT CURRENT_DATE, CURRENT_DATE + INTERVAL '03' YEAR; Date (Date+ 3) -------- --------- 16/01/01 19/01/01
以下示例将3年和01个月添加到当前日期。
SELECT CURRENT_DATE, CURRENT_DATE + INTERVAL '03-01' YEAR TO MONTH; Date (Date+ 3-01) -------- ------------ 16/01/01 19/02/01
以下示例将01天，05小时和10分钟添加到当前时间戳。
SELECT CURRENT_TIMESTAMP,CURRENT_TIMESTAMP + INTERVAL '01 05:10' DAY TO MINUTE;
Current TimeStamp(6) (Current TimeStamp(6)+ 1 05:10)
-------------------------------- --------------------------------
2016-01-01 04:57:26.360000+00:00 2016-01-02 10:07:26.360000+00:00
Teradata - 内置函数
Teradata提供了内置函数，这些函数是SQL的扩展。 以下是常见的内置函数。
| 功能 | 结果 |
|---|---|
| SELECT DATE; |
日期 -------- 16/01/01 |
| SELECT CURRENT_DATE; |
日期 -------- 16/01/01 |
| 选择时间; | Time -------- 04:50:29 |
| SELECT CURRENT_TIME; |
时间 -------- 04:50:29 |
| SELECT CURRENT_TIMESTAMP; |
当前时间戳（6） -------------------------------- 2016-01-01 04： 51：06.990000＆amp; plus; 00：00 |
|
当前时间戳（6） -------------------------------- 2016-01-01 04： 51：06.990000＆amp; plus; 00：00... |
Database ------------------------------ TDUSER |
Teradata - 聚合函数
Teradata支持公共聚合函数。 它们可以与SELECT语句一起使用。
COUNT - 计算行数
SUM - 累计指定列的值
MAX - 返回指定列的较大值
MIN - 返回所指定列的最小值
AVG - 返回指定列的平均值
例子
考虑下面的薪资表。
| 员工不 | 毛 | 扣除 | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 104 | 75,000 | 5,000 | 70,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 105 | 70,000 | 4,000 | 66,000 |
| 103 | 90,000 | 7,000 | 83,000 |
计数
以下示例计算Salary表中的记录数。
SELECT count(*) from Salary;
Count(*)
-----------
5
MAX
以下示例返回最大员工净工资值。
SELECT max(NetPay) from Salary;
Maximum(NetPay)
---------------------
83000
MAX...
以下示例从薪金表中返回最低雇员净薪值。
SELECT min(NetPay) from Salary;
Minimum(NetPay)
---------------------
36000
AVG
以下示例返回表中的员工净薪值的平均值。
SELECT avg(NetPay) from Salary;
Average(NetPay)
---------------------
65800
和
以下示例计算员工薪金表中所有记录的净工资总和。
SELECT sum(NetPay) from Salary;
Sum(NetPay)
-----------------
329000
Teradata - CASE和COALESCE
本章介绍Teradata的CASE和COALESCE函数。
CASE表达式
CASE表达式根据条件或WHEN子句计算每一行，并返回第一个匹配的结果。 如果没有匹配，则返回ELSE部分的结果。
句法
以下是CASE表达式的语法。
CASE <expression> WHEN <expression> THEN result-1 WHEN <expression> THEN result-2 ELSE Result-n END
例子
考虑以下Employee表。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
以下示例计算DepartmentNo列，如果部门号为1，则返回值1; 如果部门号码为3，则返回2; 否则返回值作为无效部门。
SELECT EmployeeNo, CASE DepartmentNo WHEN 1 THEN 'Admin' WHEN 2 THEN 'IT' ELSE 'Invalid Dept' END AS Department FROM Employee;
当执行上述查询时，它将产生以下输出。
*** Query completed. 5 rows found. 2 columns returned. *** Total elapsed time was 1 second. EmployeeNo Department ----------- ------------ 101 Admin 104 IT 102 IT 105 Invalid Dept 103 IT
上述CASE表达式也可以以下面的形式写出，这将产生与上面相同的结果。
SELECT EmployeeNo, CASE WHEN DepartmentNo = 1 THEN 'Admin' WHEN DepartmentNo = 2 THEN 'IT' ELSE 'Invalid Dept' END AS Department FROM Employee;
合并
COALESCE是返回表达式的第一个非空值的语句。 如果表达式的所有参数计算结果为NULL，则返回NULL。 以下是语法。
例子
COALESCE(expression 1, expression 2, ....)
例子
SELECT EmployeeNo, COALESCE(dept_no, 'Department not found') FROM employee;
NULLIF
如果参数相等，NULLIF语句返回NULL。
例子
以下是NULLIF语句的语法。
NULLIF(expression 1, expression 2)
例子
如果Department等于3，下面的示例返回NULL。否则，它返回Department No值。
SELECT EmployeeNo, NULLIF(DepartmentNo,3) AS department FROM Employee;
上述查询返回以下记录。 你可以看到员工105有部门号。 作为NULL。
*** Query completed. 5 rows found. 2 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo department
----------- ------------------
101 1
104 2
102 2
105 ?
103 2
Teradata - 主索引
主索引用于指定数据驻留在Teradata中的位置。 它用于指定哪个AMP获取数据行。 Teradata中的每个表都需要定义主索引。 如果未定义主索引，Teradata会自动分配主索引。 主索引提供了访问数据的最快方式。 主要最多可以有64列。
在创建表时定义主索引。 有两种类型的主索引。
- Unique Primary Index(UPI)
- Non Unique Primary Index(NUPI)
NULLIF...
如果表被定义为具有UPI，则被认为是UPI的列不应该具有任何重复值。 如果插入任何重复值，它们将被拒绝。
创建唯一主索引
以下示例使用列EmployeeNo作为唯一主索引创建了“薪金”表。
CREATE SET TABLE Salary ( EmployeeNo INTEGER, Gross INTEGER, Deduction INTEGER, NetPay INTEGER ) UNIQUE PRIMARY INDEX(EmployeeNo);
非唯一主索引（NUPI）
如果表被定义为具有NUPI，则被视为UPI的列可以接受重复值。
创建非唯一主索引
以下示例创建了将EmployeeNo列作为非唯一主索引的员工帐户表。 EmployeeNo被定义为非唯一主索引，因为员工在表中可以有多个帐户; 一个用于薪金帐户，另一个用于报销帐户。
CREATE SET TABLE Employee _Accounts ( EmployeeNo INTEGER, employee_bank_account_type BYTEINT. employee_bank_account_number INTEGER, employee_bank_name VARCHAR(30), employee_bank_city VARCHAR(30) ) PRIMARY INDEX(EmployeeNo);
Teradata - 加入
联接用于组合来自多个表的记录。 基于来自这些表的公共列/值来连接表。
有不同类型的联接可用。
- Inner Join
- Left Outer Join
- Right Outer Join
- Full Outer Join
- Self Join
- Cross Join
- Cartesian Production Join
非唯一主索引（NUPI）...
内连接组合来自多个表的记录，并返回两个表中存在的值。
句法
以下是INNER JOIN语句的语法。
SELECT col1, col2, col3…. FROM Table-1 INNER JOIN Table-2 ON (col1 = col2) <WHERE condition>;
例子
考虑下面的员工表和工资表。
| 员工不 | 名字 | 姓 | JoinedDate | 部门 | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
| 员工不 | 毛 | 毛... | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
以下查询连接公用列EmployeeS上的Employee表和Salary表。 每个表被分配一个别名A＆amp; B和列使用正确的别名引用。
SELECT A.EmployeeNo, A.DepartmentNo, B.NetPay FROM Employee A INNER JOIN Salary B ON (A.EmployeeNo = B. EmployeeNo);
当执行上述查询时，它返回以下记录。 员工105不包括在结果中，因为它在薪金表中没有匹配的记录。
*** Query completed. 4 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo DepartmentNo NetPay
----------- ------------ -----------
101 1 36000
102 2 74000
103 2 83000
104 2 70000
外部加入
LEFT OUTER JOIN和RIGHT OUTER JOIN也合并了多个表的结果。
LEFT OUTER JOIN和RIGHT OUTER JOIN也合并了多个表的结果。...
RIGHT OUTER JOIN 返回右表中的所有记录，并仅返回左表中匹配的行。
FULL OUTER JOIN 结合了LEFT OUTER和RIGHT OUTER JOINS的结果。 它从连接的表返回匹配和不匹配的行。
例子
以下是OUTER JOIN语句的语法。 您需要使用LEFT OUTER JOIN，RIGHT OUTER JOIN或FULL OUTER JOIN中的一个选项。
SELECT col1, col2, col3…. FROM Table-1 LEFT OUTER JOIN/RIGHT OUTER JOIN/FULL OUTER JOIN Table-2 ON (col1 = col2) <WHERE condition>;
例子
以下是OUTER JOIN语句的语法。 您需要使用LEFT OUTER JOIN，RIGHT OUTER JOIN或FULL OUTER JOIN中的一个选项。...
SELECT A.EmployeeNo, A.DepartmentNo, B.NetPay FROM Employee A LEFT OUTER JOIN Salary B ON (A.EmployeeNo = B. EmployeeNo) ORDER BY A.EmployeeNo;
当执行上述查询时，它将产生以下输出。 对于员工105，NetPay值为NULL，因为它在薪金表中没有匹配的记录。
*** Query completed. 5 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo DepartmentNo NetPay
----------- ------------ -----------
101 1 36000
102 2 74000
103 2 83000
104 2 70000
105 3 ?
CROSS JOIN
交叉连接将左表中的每一行连接到右表中的每一行。
例子
以下是CROSS JOIN语句的语法。
SELECT A.EmployeeNo, A.DepartmentNo, B.EmployeeNo,B.NetPay FROM Employee A CROSS JOIN Salary B WHERE A.EmployeeNo = 101 ORDER BY B.EmployeeNo;
以下是CROSS JOIN语句的语法。...
*** Query completed. 4 rows found. 4 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo DepartmentNo EmployeeNo NetPay
----------- ------------ ----------- -----------
101 1 101 36000
101 1 104 70000
101 1 102 74000
101 1 103 83000
Teradata - 子查询
子查询基于另一个表中的值从一个表返回记录。 它是另一个查询中的SELECT查询。 作为内部查询调用的SELECT查询将首先执行，结果将由外部查询使用。 它的一些突出特点是 -
子查询基于另一个表中的值从一个表返回记录。 它是另一个查询中的SELECT查询。 作为内部查询调用的SELECT查询将首先执行，结果将由外部查询使用。 它的一些突出特点是 - ...
子查询不返回重复记录。
子查询不返回重复记录。...
句法
以下是子查询的通用语法。
SELECT col1, col2, col3,… FROM Outer Table WHERE col1 OPERATOR ( Inner SELECT Query);
例子
考虑以下薪资表。
| 员工不 | 毛 | 扣除 | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
以下查询标识最高薪水的员工编号。 内部SELECT执行聚合函数以返回最大NetPay值，外部SELECT查询使用此值返回具有此值的雇员记录。
SELECT EmployeeNo, NetPay FROM Salary WHERE NetPay = (SELECT MAX(NetPay) FROM Salary);
执行此查询时，将生成以下输出。
*** Query completed. One row found. 2 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo NetPay
----------- -----------
103 83000
Teradata - 表类型
Teradata支持以下表类型来保存临时数据。
- Derived Table
- Volatile Table
- Global Temporary Table
派生表
Teradata支持以下表类型来保存临时数据。...
例子
以下示例构建具有薪金大于75000的员工的记录的派生表EmpSal。
SELECT Emp.EmployeeNo, Emp.FirstName, Empsal.NetPay FROM Employee Emp, (select EmployeeNo , NetPay from Salary where NetPay >= 75000) Empsal where Emp.EmployeeNo = Empsal.EmployeeNo;
以下示例构建具有薪金大于75000的员工的记录的派生表EmpSal。...
*** Query completed. One row found. 3 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo FirstName NetPay
----------- ------------------------------ -----------
103 Peter 83000
挥发性表
在用户会话中创建，使用和删除易失性表。 它们的定义不存储在数据字典中。 它们保存经常使用的查询的中间数据。 以下是语法。
例子
CREATE [SET|MULTISET] VOALTILE TABLE tablename <table definitions> <column definitions> <index definitions> ON COMMIT [DELETE|PRESERVE] ROWS
例子
CREATE VOLATILE TABLE dept_stat ( dept_no INTEGER, avg_salary INTEGER, max_salary INTEGER, min_salary INTEGER ) PRIMARY INDEX(dept_no) ON COMMIT PRESERVE ROWS;
在用户会话中创建，使用和删除易失性表。 它们的定义不存储在数据字典中。 它们保存经常使用的查询的中间数据。 以下是语法。...
*** Table has been created. *** Total elapsed time was 1 second.
全球临时表
全局临时表的定义存储在数据字典中，并且它们可以被许多用户/会话使用。 但是加载到全局临时表中的数据仅在会话期间保留。 每个会话最多可以实现2000个全局临时表。 以下是语法。
例子
CREATE [SET|MULTISET] GLOBAL TEMPORARY TABLE tablename <table definitions> <column definitions> <index definitions>
例子
CREATE SET GLOBAL TEMPORARY TABLE dept_stat ( dept_no INTEGER, avg_salary INTEGER, max_salary INTEGER, min_salary INTEGER ) PRIMARY INDEX(dept_no);
全局临时表的定义存储在数据字典中，并且它们可以被许多用户/会话使用。 但是加载到全局临时表中的数据仅在会话期间保留。 每个会话最多可以实现2000个全局临时表。 以下是语法。...
*** Table has been created. *** Total elapsed time was 1 second.
Teradata - 空间概念
Teradata中有三种类型的空格可用。
永久空间
Teradata中有三种类型的空格可用。...
不为数据库/用户预分配永久空间。 它们只是定义为数据库/用户可以使用的最大空间量。 永久空间的量除以AMP的数量。 每当每个AMP限制超过，将生成一条错误消息。
卷轴空间
假脱机空间是未使用的永久空间，由系统用于保留SQL查询的中间结果。 没有假脱机空间的用户无法执行任何查询。
与永久空间类似，假脱机空间定义了用户可以使用的最大空间量。 线圈空间除以AMP的数量。 每当每个AMP限制超过，用户将得到假脱机空间错误。
温度空间
临时空间是未使用的永久空间，由全局临时表使用。 温度空间也除以AMP的数量。
Teradata - 空间概念...
表只能包含一个主索引。 更多情况下，您会遇到表包含其他列的情况，使用这些列来频繁访问数据。 Teradata将对这些查询执行全表扫描。 辅助索引解决此问题。
辅助索引是访问数据的备用路径。 主索引和辅助索引之间存在一些差异。
次级索引不涉及数据分发。
辅助索引值存储在子表中。 这些表是在所有AMP中内置的。
辅助索引是可选的。
它们可以在创建表期间或在创建表之后创建。
它们占用额外的空间，因为它们构建子表，并且它们还需要维护，因为需要为每个新行更新子表。
有两种类型的辅助索引 -
- Unique Secondary Index (USI)
- Non-Unique Secondary Index (NUSI)
唯一二级指数（USI）
唯一辅助索引只允许定义为USI的列的唯一值。 通过USI访问该行是一个双放大操作。
创建唯一二级索引
以下示例在Employee表的EmployeeNo列上创建USI。
CREATE UNIQUE INDEX(EmployeeNo) on employee;
非唯一二级指数（NUSI）
非唯一二级索引允许定义为NUSI的列的重复值。 通过NUSI访问该行是全放大器操作。
创建非唯一二级索引
以下示例在employee表的FirstName列上创建NUSI。
CREATE INDEX(FirstName) on Employee;
Teradata - 统计
Teradata优化器提出了每个SQL查询的执行策略。 此执行策略基于在SQL查询中使用的表收集的统计信息。 使用COLLECT STATISTICS命令收集表上的统计信息。 优化器需要环境信息和数据人口统计数据来制定最佳执行策略。
环境信息
- Number of Nodes, AMPs and CPUs
- Amount of memory
数据人口统计
- Number of rows
- Row size
- Range of values in the table
- Number of rows per value
- Number of Nulls
有三种方法来收集表上的统计信息。
- Random AMP Sampling
- Full statistics collection
- Using SAMPLE option
收集统计
COLLECT STATISTICS命令用于收集表上的统计信息。
句法
以下是收集表上的统计信息的基本语法。
COLLECT [SUMMARY] STATISTICS INDEX (indexname) COLUMN (columnname) ON <tablename>;
例子
以下示例收集Employee表的EmployeeNo列的统计信息。
COLLECT STATISTICS COLUMN(EmployeeNo) ON Employee;
当执行上述查询时，它将产生以下输出。
*** Update completed. 2 rows changed. *** Total elapsed time was 1 second.
查看统计信息
您可以使用HELP STATISTICS命令查看收集的统计信息。
例子
以下是查看收集的统计信息的语法。
HELP STATISTICS <tablename>;
例子
以下是查看在Employee表上收集的统计信息的示例。
HELP STATISTICS employee;
当执行上述查询时，它产生以下结果。
Date Time Unique Values Column Names -------- -------- -------------------- ----------------------- 16/01/01 08:07:04 5 * 16/01/01 07:24:16 3 DepartmentNo 16/01/01 08:07:04 5 EmployeeNo
Teradata - 统计...
压缩用于减少表所使用的存储。 在Teradata中，压缩最多可以压缩255个不同的值，包括NULL。 由于存储已减少，Teradata可以在块中存储更多记录。 这导致改进的查询响应时间，因为任何I / O操作可以每块处理更多行。 可以在使用CREATE TABLE创建表或使用ALTER TABLE命令创建表之后添加压缩。
限制
- Only 255 values can be compressed per column.
- Primary Index column cannot be compressed.
- Volatile tables cannot be compressed.
多值压缩（MVC）
下表压缩值为1，2和3的字段DepatmentNo。对列应用压缩时，此列的值不与该行一起存储。 相反，值存储在每个AMP中的表头中，只有存在位被添加到该行以指示该值。
CREATE SET TABLE employee ( EmployeeNo integer, FirstName CHAR(30), LastName CHAR(30), BirthDate DATE FORMAT 'YYYY-MM-DD-', JoinedDate DATE FORMAT 'YYYY-MM-DD-', employee_gender CHAR(1), DepartmentNo CHAR(02) COMPRESS(1,2,3) ) UNIQUE PRIMARY INDEX(EmployeeNo);
当在具有有限值的大表中具有列时，可以使用多值压缩。
Teradata - 解释
EXPLAIN命令以英语返回解析引擎的执行计划。 它可以与除另一个EXPLAIN命令之外的任何SQL语句一起使用。 当查询前面有EXPLAIN命令时，解析引擎的执行计划将返回给用户，而不是AMP。
EXPLAIN的示例
考虑具有以下定义的表Employee。
CREATE SET TABLE EMPLOYEE,FALLBACK ( EmployeeNo INTEGER, FirstName VARCHAR(30), LastName VARCHAR(30), DOB DATE FORMAT 'YYYY-MM-DD', JoinedDate DATE FORMAT 'YYYY-MM-DD', DepartmentNo BYTEINT ) UNIQUE PRIMARY INDEX ( EmployeeNo );
下面给出了EXPLAIN计划的一些示例。
全表扫描（FTS）
当在SELECT语句中没有指定条件时，优化器可以选择在访问表的每一行时使用全表扫描。
例子
以下是一个示例查询，其中优化程序可以选择FTS。
EXPLAIN SELECT * FROM employee;
当执行上述查询时，它将产生以下输出。 可以看出，优化器选择访问AMP中的所有AMP和所有行。
1) First, we lock a distinct TDUSER."pseudo table" for read on a RowHash to prevent global deadlock for TDUSER.employee. 2) Next, we lock TDUSER.employee for read. 3) We do an all-AMPs RETRIEVE step from TDUSER.employee by way of an all-rows scan with no residual conditions into Spool 1 (group_amps), which is built locally on the AMPs. The size of Spool 1 is estimated with low confidence to be 2 rows (116 bytes). The estimated time for this step is 0.03 seconds. 4) Finally, we send out an END TRANSACTION step to all AMPs involved in processing the request. → The contents of Spool 1 are sent back to the user as the result of statement 1. The total estimated time is 0.03 seconds.
唯一主索引
当使用唯一主索引访问行时，则它是一个AMP操作。
EXPLAIN SELECT * FROM employee WHERE EmployeeNo = 101;
当执行上述查询时，它将产生以下输出。 可以看出，它是单AMP检索，优化器使用唯一的主索引访问该行。
1) First, we do a single-AMP RETRIEVE step from TDUSER.employee by way of the unique primary index "TDUSER.employee.EmployeeNo = 101" with no residual conditions. The estimated time for this step is 0.01 seconds. → The row is sent directly back to the user as the result of statement 1. The total estimated time is 0.01 seconds.
唯一二级索引
当使用唯一二级索引访问行时，它是一个双放大操作。
例子
考虑具有以下定义的表薪水。
CREATE SET TABLE SALARY,FALLBACK ( EmployeeNo INTEGER, Gross INTEGER, Deduction INTEGER, NetPay INTEGER ) PRIMARY INDEX ( EmployeeNo ) UNIQUE INDEX (EmployeeNo);
请考虑以下SELECT语句。
EXPLAIN SELECT * FROM Salary WHERE EmployeeNo = 101;
当执行上述查询时，它将产生以下输出。 可以看出，优化器在使用唯一二级索引的两个amp操作中检索该行。
1) First, we do a two-AMP RETRIEVE step from TDUSER.Salary by way of unique index # 4 "TDUSER.Salary.EmployeeNo = 101" with no residual conditions. The estimated time for this step is 0.01 seconds. → The row is sent directly back to the user as the result of statement 1. The total estimated time is 0.01 seconds.
附加条款
以下是EXPLAIN计划中常见的术语列表。
...（最后使用）...
不再需要假脱机文件，并且将在此步骤完成后释放。
...没有残余条件...
所有适用的条件已应用于行。
... END TRANSACTION ...
... END TRANSACTION ... ...
...消除重复行...
...消除重复行... ...
...通过遍历索引#n仅提取行id ... ...
...通过遍历索引#n仅提取行id ... ... ...
构建了一个假脱机文件，其中包含在辅助索引（索引#n）中找到的行标识...
...我们做一个短信（设置操作步骤）... ...
...由散列码重新分配给所有AMP。
...由散列码重新分配给所有AMP。...
...在所有AMP上重复。
在准备加入时，从较小的表（根据SPOOL）复制数据。
...（one_AMP）或（group_AMPs）
...（one_AMP）或（group_AMPs）...
Teradata - 解释...
基于主索引值将行分配给特定的AMP。 Teradata使用散列算法来确定哪个AMP获取行。
基于主索引值将行分配给特定的AMP。 Teradata使用散列算法来确定哪个AMP获取行。...
以下是插入数据的步骤。
以下是插入数据的步骤。...
解析器接收查询并将记录的PI值传递给散列算法。
解析器接收查询并将记录的PI值传递给散列算法。...
行散列（前16位）的高阶位用于标识散列映射条目。 哈希映射包含一个AMP＃。 哈希映射是包含特定AMP＃的桶的数组。
BYNET将数据发送到标识的AMP。
AMP使用32位行散列来定位其磁盘中的行。
AMP使用32位行散列来定位其磁盘中的行。...
行散列和唯一性ID的组合称为行ID。
行散列和唯一性ID的组合称为行ID。...
AMP中的每个表行都按其行ID进行逻辑排序。
如何存储表
AMP中的每个表行都按其行ID进行逻辑排序。...
| 行哈希 | 唯一性ID | 员工不 | 名字 | 名字... |
|---|---|---|---|---|
| 2A01 2611 | 0000 0001 | 101 | Mike | James |
| 2A01 2612 | 0000 0001 | 104 | Alex | Stuart |
| 2A01 2613 | 0000 0001 | 102 | Robert | Williams |
| 2A01 2614 | 0000 0001 | 105 | Robert | James |
| 2A01 2615 | 0000 0001 | 103 | Peter | Paul |
Teradata - JOIN索引
JOIN INDEX是一个物化视图。 其定义是永久存储的，并且只要更新连接索引中引用的基表，就会更新数据。 JOIN INDEX可以包含一个或多个表，并且还包含预聚合数据。 连接索引主要用于提高性能。
JOIN INDEX是一个物化视图。 其定义是永久存储的，并且只要更新连接索引中引用的基表，就会更新数据。 JOIN INDEX可以包含一个或多个表，并且还包含预聚合数据。 连接索引主要用于提高性能。...
- Single Table Join Index (STJI)
- Multi Table Join Index (MTJI)
- Aggregated Join Index (AJI)
单表连接索引
单表联接索引允许基于不同于基表中的主索引列的主索引列来分区大表。
例子
单表联接索引允许基于不同于基表中的主索引列的主索引列来分区大表。...
CREATE JOIN INDEX <index name> AS <SELECT Query> <Index Definition>;
例子
考虑以下员工和薪资表。
CREATE SET TABLE EMPLOYEE,FALLBACK ( EmployeeNo INTEGER, FirstName VARCHAR(30) , LastName VARCHAR(30) , DOB DATE FORMAT 'YYYY-MM-DD', JoinedDate DATE FORMAT 'YYYY-MM-DD', DepartmentNo BYTEINT ) UNIQUE PRIMARY INDEX ( EmployeeNo ); CREATE SET TABLE SALARY,FALLBACK ( EmployeeNo INTEGER, Gross INTEGER, Deduction INTEGER, NetPay INTEGER ) PRIMARY INDEX ( EmployeeNo ) UNIQUE INDEX (EmployeeNo);
考虑以下员工和薪资表。...
CREATE JOIN INDEX Employee_JI AS SELECT EmployeeNo,FirstName,LastName, BirthDate,JoinedDate,DepartmentNo FROM Employee PRIMARY INDEX(FirstName);
如果用户在EmployeeNo上提交带有WHERE子句的查询，那么系统将使用唯一的主索引查询Employee表。 如果用户使用employee_name查询employee表，则系统可以使用employee_name访问连接索引Employee_JI。 连接索引的行在employee_name列上进行散列。 如果未定义连接索引且employee_name未定义为辅助索引，则系统将执行全表扫描以访问耗时的行。
您可以运行以下EXPLAIN计划并验证优化程序计划。 在以下示例中，您可以看到，当表使用Employee_Name列查询时，优化程序正在使用Join Index而不是base Employee表。
EXPLAIN SELECT * FROM EMPLOYEE WHERE FirstName='Mike';
*** Help information returned. 8 rows.
*** Total elapsed time was 1 second.
Explanation
------------------------------------------------------------------------
1) First, we do a single-AMP RETRIEVE step from EMPLOYEE_JI by
way of the primary index "EMPLOYEE_JI.FirstName = 'Mike'"
with no residual conditions into Spool 1 (one-amp), which is built
locally on that AMP. The size of Spool 1 is estimated with low
confidence to be 2 rows (232 bytes). The estimated time for this
step is 0.02 seconds.
→ The contents of Spool 1 are sent back to the user as the result of
statement 1. The total estimated time is 0.02 seconds.
多表连接索引
您可以运行以下EXPLAIN计划并验证优化程序计划。 在以下示例中，您可以看到，当表使用Employee_Name列查询时，优化程序正在使用Join Index而不是base Employee表。...
例子
以下示例通过连接Employee和Salary表来创建一个名为Employee_Salary_JI的JOIN INDEX。
CREATE JOIN INDEX Employee_Salary_JI AS SELECT a.EmployeeNo,a.FirstName,a.LastName, a.BirthDate,a.JoinedDate,a.DepartmentNo,b.Gross,b.Deduction,b.NetPay FROM Employee a INNER JOIN Salary b ON(a.EmployeeNo = b.EmployeeNo) PRIMARY INDEX(FirstName);
以下示例通过连接Employee和Salary表来创建一个名为Employee_Salary_JI的JOIN INDEX。...
聚合联接索引
如果表在某些列上始终聚合，则可以在表上定义聚合连接索引以提高性能。 聚合连接索引的一个限制是它仅支持SUM和COUNT函数。
例子
在以下示例中，加入员工和工资以确定每个部门的总工资。
CREATE JOIN INDEX Employee_Salary_JI AS SELECT a.DepartmentNo,SUM(b.NetPay) AS TotalPay FROM Employee a INNER JOIN Salary b ON(a.EmployeeNo = b.EmployeeNo) GROUP BY a.DepartmentNo Primary Index(DepartmentNo);
Teradata - JOIN索引...
视图是由查询构建的数据库对象。 可以使用单个表或通过连接的多个表来构建视图。 它们的定义永久存储在数据字典中，但它们不存储数据的副本。 视图的数据是动态构建的。
视图可以包含表的行的子集或表的列的子集。
创建视图
视图是使用CREATE VIEW语句创建的。
例子
下面是创建视图的语法。
CREATE/REPLACE VIEW <viewname> AS <select query>;
例子
考虑以下Employee表。
| 员工不 | 名字 | 姓 | 姓... |
|---|---|---|---|
| 101 | Mike | James | 1/5/1980 |
| 104 | Alex | Stuart | 11/6/1984 |
| 102 | Robert | Williams | 3/5/1983 |
| 105 | Robert | James | 12/1/1984 |
| 103 | Peter | Paul | 4/1/1983 |
以下示例在Employee表上创建视图。
CREATE VIEW Employee_View AS SELECT EmployeeNo, FirstName, LastName, FROM Employee;
使用视图
以下示例在Employee表上创建视图。...
例子
以下示例从Employee_View中检索记录;
SELECT EmployeeNo, FirstName, LastName FROM Employee_View;
当执行上述查询时，它将产生以下输出。
*** Query completed. 5 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo FirstName LastName
----------- ------------------------------ ---------------------------
101 Mike James
104 Alex Stuart
102 Robert Williams
105 Robert James
103 Peter Paul
修改视图
当执行上述查询时，它将产生以下输出。...
以下是修改视图的语法。
REPLACE VIEW <viewname> AS <select query>;
例子
以下是修改视图的语法。...
REPLACE VIEW Employee_View AS SELECT EmployeeNo, FirstName, BirthDate, JoinedDate DepartmentNo FROM Employee;
下降视图
可以使用DROP VIEW语句删除现有视图。
例子
可以使用DROP VIEW语句删除现有视图。...
DROP VIEW <viewname>;
例子
下面是一个删除视图Employee_View的示例。
DROP VIEW Employee_View;
视图的优点
下面是一个删除视图Employee_View的示例。...
用户只能访问视图而不是基表。
用户只能访问视图而不是基表。...
Teradata - 宏
宏是一组SQL语句，通过调用宏名称来存储和执行。 宏的定义存储在数据字典中。 用户只需要EXEC特权来执行宏。 用户不需要对宏中使用的数据库对象具有单独的特权。 宏语句作为单个事务执行。 如果宏中的某个SQL语句失败，则所有语句都将回滚。 宏可以接受参数。 宏可以包含DDL语句，但应该是宏中的最后一个语句。
创建宏
宏是一组SQL语句，通过调用宏名称来存储和执行。 宏的定义存储在数据字典中。 用户只需要EXEC特权来执行宏。 用户不需要对宏中使用的数据库对象具有单独的特权。 宏语句作为单个事务执行。 如果宏中的某个SQL语句失败，则所有语句都将回滚。 宏可以接受参数。 宏可以包含DDL语句，但应该是宏中的最后一个语句。...
句法
以下是CREATE MACRO命令的通用语法。
CREATE MACRO <macroname> [(parameter1, parameter2,...)] ( <sql statements> );
例子
以下是CREATE MACRO命令的通用语法。...
| 员工不 | 名字 | 姓 | 生日 |
|---|---|---|---|
| 101 | Mike | James | 1/5/1980 |
| 104 | Alex | Stuart | 11/6/1984 |
| 102 | Robert | Williams | 3/5/1983 |
| 105 | Robert | James | 12/1/1984 |
| 103 | Peter | Paul | 4/1/1983 |
下面的示例创建一个名为Get_Emp的宏。 它包含一个select语句来从employee表中检索记录。
CREATE MACRO Get_Emp AS ( SELECT EmployeeNo, FirstName, LastName FROM employee ORDER BY EmployeeNo; );
执行宏
下面的示例创建一个名为Get_Emp的宏。 它包含一个select语句来从employee表中检索记录。...
例子
以下是EXECUTE MACRO命令的语法。
EXEC <macroname>;
例子
以下示例执行宏名称Get_Emp; 执行以下命令时，它将从employee表中检索所有记录。
EXEC Get_Emp; *** Query completed. 5 rows found. 3 columns returned. *** Total elapsed time was 1 second. EmployeeNo FirstName LastName ----------- ------------------------------ --------------------------- 101 Mike James 102 Robert Williams 103 Peter Paul 104 Alex Stuart 105 Robert James
参数化宏
Teradata宏可以接受参数。 在宏内，这些参数用引用; （分号）。
Teradata宏可以接受参数。 在宏内，这些参数用引用; （分号）。...
CREATE MACRO Get_Emp_Salary(EmployeeNo INTEGER) AS ( SELECT EmployeeNo, NetPay FROM Salary WHERE EmployeeNo = :EmployeeNo; );
执行参数化宏
宏使用EXEC命令执行。 您需要EXEC特权才能执行宏。
例子
以下是EXECUTE MACRO语句的语法。
EXEC <macroname>(value);
例子
以下是EXECUTE MACRO语句的语法。...
EXEC Get_Emp_Salary(101); *** Query completed. One row found. 2 columns returned. *** Total elapsed time was 1 second. EmployeeNo NetPay ----------- ------------ 101 36000
Teradata - 宏...
存储过程包含一组SQL语句和过程语句。 它们可能只包含程序性声明。 存储过程的定义存储在数据库中，参数存储在数据字典表中。
优点
存储过程包含一组SQL语句和过程语句。 它们可能只包含程序性声明。 存储过程的定义存储在数据库中，参数存储在数据字典表中。...
提供更好的安全性，因为通过存储过程访问数据，而不是直接访问它们。
提供更好的安全性，因为通过存储过程访问数据，而不是直接访问它们。...
执行参数化宏...
存储过程使用CREATE PROCEDURE语句创建。
句法
存储过程使用CREATE PROCEDURE语句创建。...
CREATE PROCEDURE <procedurename> ( [parameter 1 data type, parameter 2 data type..] ) BEGIN <SQL or SPL statements>; END;
例子
考虑下面的薪资表。
| 员工不 | 毛 | 扣除 | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
考虑下面的薪资表。...
CREATE PROCEDURE InsertSalary (
IN in_EmployeeNo INTEGER, IN in_Gross INTEGER,
IN in_Deduction INTEGER, IN in_NetPay INTEGER
)
BEGIN
INSERT INTO Salary (
EmployeeNo,
Gross,
Deduction,
NetPay
)
VALUES (
:in_EmployeeNo,
:in_Gross,
:in_Deduction,
:in_NetPay
);
END;
执行程序
存储过程使用CALL语句执行。
例子
以下是CALL语句的通用语法。
CALL <procedure name> [(parameter values)];
例子
以下示例调用存储过程InsertSalary，并将记录插入到“薪金表”中。
CALL InsertSalary(105,20000,2000,18000);
执行上述查询后，它将生成以下输出，您可以在Salary表中看到插入的行。
| 员工不 | 毛 | 扣除 | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
| 105 | 20,000 | 2,000 | 18,000 |
Teradata - JOIN策略
执行上述查询后，它将生成以下输出，您可以在Salary表中看到插入的行。...
执行程序...
Teradata使用不同的连接方法来执行连接操作。 一些常用的Join方法是 -
- Merge Join
- Nested Join
- Product Join
合并加入
Teradata使用不同的连接方法来执行连接操作。 一些常用的Join方法是 - ...
例子...
如果连接列是相应表的主索引，则连接行已在同一AMP上。 在这种情况下，不需要分配。
如果连接列是相应表的主索引，则连接行已在同一AMP上。 在这种情况下，不需要分配。...
CREATE SET TABLE EMPLOYEE,FALLBACK ( EmployeeNo INTEGER, FirstName VARCHAR(30) , LastName VARCHAR(30) , DOB DATE FORMAT 'YYYY-MM-DD', JoinedDate DATE FORMAT 'YYYY-MM-DD', DepartmentNo BYTEINT ) UNIQUE PRIMARY INDEX ( EmployeeNo );
CREATE SET TABLE Salary ( EmployeeNo INTEGER, Gross INTEGER, Deduction INTEGER, NetPay INTEGER ) UNIQUE PRIMARY INDEX(EmployeeNo);
当这两个表在EmployeeNo列上连接时，不会发生重新分配，因为EmployeeNo是正在连接的两个表的主索引。
策略＃2
当这两个表在EmployeeNo列上连接时，不会发生重新分配，因为EmployeeNo是正在连接的两个表的主索引。...
CREATE SET TABLE EMPLOYEE,FALLBACK ( EmployeeNo INTEGER, FirstName VARCHAR(30) , LastName VARCHAR(30) , DOB DATE FORMAT 'YYYY-MM-DD', JoinedDate DATE FORMAT 'YYYY-MM-DD', DepartmentNo BYTEINT ) UNIQUE PRIMARY INDEX ( EmployeeNo );
CREATE SET TABLE DEPARTMENT,FALLBACK ( DepartmentNo BYTEINT, DepartmentName CHAR(15) ) UNIQUE PRIMARY INDEX ( DepartmentNo );
如果这两个表在DeparmentNo列上连接，那么这些行需要重新分布，因为DepartmentNo是一个表中的主索引和另一个表中的非主索引。 在这种情况下，加入行可能不在同一个AMP上。 在这种情况下，Teradata可能会在DepartmentNo列重新分发employee表。
策略＃3
如果这两个表在DeparmentNo列上连接，那么这些行需要重新分布，因为DepartmentNo是一个表中的主索引和另一个表中的非主索引。 在这种情况下，加入行可能不在同一个AMP上。 在这种情况下，Teradata可能会在DepartmentNo列重新分发employee表。...
合并加入...
嵌套连接不使用所有AMP。 对于嵌套连接发生，其中一个条件应该是一个表的唯一主索引上的相等，然后将此列连接到另一个表上的任何索引。
嵌套连接不使用所有AMP。 对于嵌套连接发生，其中一个条件应该是一个表的唯一主索引上的相等，然后将此列连接到另一个表上的任何索引。...
产品加盟
Product Join将来自一个表的每个限定行与来自其他表的每个限定行进行比较。 产品加入可能由于以下某些因素而发生：
- Where condition is missing.
- Join condition is not based on equality condition.
- Table aliases is not correct.
- Multiple join conditions.
Teradata - 分区主索引
分区主索引（PPI）是一种索引机制，可用于提高某些查询的性能。 当将行插入到表中时，它们存储在AMP中并按其行散列顺序排列。 当使用PPI定义表时，行按其分区编号排序。 在每个分区中，它们按其行散列排列。 根据定义的分区表达式将行分配给分区。
产品加盟...
避免对某些查询进行全表扫描。
避免使用需要额外物理结构和额外I / O维护的辅助索引。
快速访问大表的子集。
快速删除旧数据并添加新数据。
例子
考虑以下OrderNo主索引的Orders表。
| StoreNo | 订单号 | 订购日期 | 合计订单 |
|---|---|---|---|
| 101 | 7501 | 2015-10-01 | 900 |
| 101 | 7502 | 2015-10-02 | 1,200 |
| 102 | 7503 | 2015-10-02 | 3,000 |
| 102 | 7504 | 2015-10-03 | 2,454 |
| 101 | 7505 | 2015-10-03 | 1201 |
| 103 | 7506 | 2015-10-04 | 2,454 |
| 101 | 7507 | 2015-10-05 | 1201 |
| 101 | 7508 | 2015-10-05 | 1201 |
假设记录分布在AMP之间，如下表所示。 记录存储在AMP中，基于它们的行哈希排序。
| RowHash | 订单号 | 订购日期 |
|---|---|---|
| 1 | 7505 | 2015-10-03 |
| 2 | 7504 | 2015-10-03 |
| 3 | 7501 | 2015-10-01 |
| 4 | 7508 | 2015-10-05 |
| RowHash | 订单号 | 订购日期 |
|---|---|---|
| 1 | 7507 | 2015-10-05 |
| 2 | 7502 | 2015-10-02 |
| 3 | 7506 | 2015-10-04 |
| 4 | 7503 | 2015-10-02 |
如果运行查询以提取特定日期的订单，则优化程序可以选择使用全表扫描，然后可以访问AMP中的所有记录。 为了避免这种情况，您可以将订单日期定义为分区主索引。 将行插入到订单表中时，它们按订单日期进行分区。 在每个分区中，它们将按其行哈希排序。
以下数据显示如果记录按订单日期分区，则记录将如何存储在AMP中。 如果运行查询以按订单日期访问记录，则只会访问包含该特定订单的记录的分区。
以下数据显示如果记录按订单日期分区，则记录将如何存储在AMP中。 如果运行查询以按订单日期访问记录，则只会访问包含该特定订单的记录的分区。...
| 划分 | RowHash | 订单号 | 订购日期 |
|---|---|---|---|
| 0 | 3 | 7501 | 2015-10-01 |
| 1 | 1 | 7505 | 2015-10-03 |
| 1 | 2 | 7504 | 2015-10-03 |
| 2 | 4 | 7508 | 2015-10-05 |
| 划分 | RowHash | RowHash... | 订购日期 |
|---|---|---|---|
| 0 | 2 | 7502 | 2015-10-02 |
| 0 | 4 | 7503 | 2015-10-02 |
| 1 | 3 | 7506 | 2015-10-04 |
| 2 | 1 | 7507 | 2015-10-05 |
以下是创建具有分区primary Index的表的示例。 PARTITION BY子句用于定义分区。
CREATE SET TABLE Orders ( StoreNo SMALLINT, OrderNo INTEGER, OrderDate DATE FORMAT 'YYYY-MM-DD', OrderTotal INTEGER ) PRIMARY INDEX(OrderNo) PARTITION BY RANGE_N ( OrderDate BETWEEN DATE '2010-01-01' AND '2016-12-31' EACH INTERVAL '1' DAY );
在上面的示例中，表由OrderDate列分区。 每天将有一个单独的分区。
Teradata - OLAP函数
OLAP函数类似于聚合函数，除了聚合函数只返回一个值，而OLAP函数将提供聚合以外的各行。
句法
以下是OLAP函数的一般语法。
<aggregate function> OVER ([PARTITION BY] [ORDER BY columnname][ROWS BETWEEN UNBOUDED PRECEDING AND UNBOUNDED FOLLWOING)
聚合函数可以是SUM，COUNT，MAX，MIN，AVG。
例子
考虑以下薪资表。
| 员工不 | 毛 | 扣除 | NetPay |
|---|---|---|---|
| 101 | 40,000 | 4,000 | 36,000 |
| 102 | 80,000 | 6,000 | 74,000 |
| 103 | 90,000 | 7,000 | 83,000 |
| 104 | 75,000 | 5,000 | 70,000 |
以下是查找工资表上NetPay的累计金额或运行总计的示例。 记录按EmployeeNo排序，累积和计算在NetPay列上。
SELECT EmployeeNo, NetPay, SUM(Netpay) OVER(ORDER BY EmployeeNo ROWS UNBOUNDED PRECEDING) as TotalSalary FROM Salary;
当执行上述查询时，它将产生以下输出。
EmployeeNo NetPay TotalSalary ----------- ----------- ----------- 101 36000 36000 102 74000 110000 103 83000 193000 104 70000 263000 105 18000 281000
例子...
当执行上述查询时，它将产生以下输出。...
例子
以下是使用RANK函数的通用语法。
RANK() OVER ([PARTITION BY columnnlist] [ORDER BY columnlist][DESC|ASC])
例子
考虑以下Employee表。
| 员工不 | 名字 | 姓 | JoinedDate | DepartmentID | 生日 |
|---|---|---|---|---|---|
| 101 | Mike | James | 3/27/2005 | 1 | 1/5/1980 |
| 102 | Robert | Williams | 4/25/2007 | 2 | 3/5/1983 |
| 103 | Peter | Paul | 3/21/2007 | 2 | 4/1/1983 |
| 104 | Alex | Stuart | 2/1/2008 | 2 | 11/6/1984 |
| 105 | Robert | James | 1/4/2008 | 3 | 12/1/1984 |
以下查询通过加入日期对雇员表的记录进行排序，并在“加入日期”中分配排名。
SELECT EmployeeNo, JoinedDate,RANK() OVER(ORDER BY JoinedDate) as Seniority FROM Employee;
当执行上述查询时，它将产生以下输出。
EmployeeNo JoinedDate Seniority ----------- ---------- ----------- 101 2005-03-27 1 103 2007-03-21 2 102 2007-04-25 3 105 2008-01-04 4 104 2008-02-01 5
PARTITION BY子句按照在PARTITION BY子句中定义的列对数据进行分组，并在每个组中执行OLAP功能。 以下是使用PARTITION BY子句的查询的示例。
SELECT EmployeeNo, JoinedDate,RANK() OVER(PARTITION BY DeparmentNo ORDER BY JoinedDate) as Seniority FROM Employee;
当执行上述查询时，它将产生以下输出。 您可以看到每个部门都重置了排名。
EmployeeNo DepartmentNo JoinedDate Seniority
----------- ------------ ---------- -----------
101 1 2005-03-27 1
103 2 2007-03-21 1
102 2 2007-04-25 2
104 2 2008-02-01 3
105 3 2008-01-04 1
Teradata - 数据保护
本章讨论Teradata中数据保护的可用功能。
瞬态杂志
Teradata使用瞬态日志来保护数据免受事务故障的影响。 无论何时运行任何事务，Transient journal都会保留受影响行的before映像的副本，直到事务成功或回滚成功。 然后，丢弃之前的图像。 瞬时日志保存在每个AMP中。 这是一个自动过程，不能禁用。
倒退
回退通过将表的行的第二副本存储在称为回退AMP的另一AMP上来保护表数据。 如果一个AMP出现故障，则会访问回退行。 这样，即使一个AMP出现故障，通过备用AMP仍然可以获得数据。 Fallback选项可用于表创建或表创建后。 回退确保表的行的第二副本总是存储在另一个AMP中以保护数据免于AMP故障。 但是，回退占用的存储空间和I / O的两倍，用于插入/删除/更新。
下图显示了如何将行的后备副本存储在另一个AMP中。
下降AMP恢复
当AMP故障并且表受回退保护时，将激活Down AMP恢复日志。 此日志记录对失败的AMP的数据的所有更改。 在集群中剩余的AMP上激活日志。 这是一个自动过程，不能禁用。 一旦失败的AMP生效，则来自下行AMP恢复日志的数据与AMP同步。 一旦完成，日志将被丢弃。
Cliques
Clique是Teradata用来保护数据免受节点故障的机制。 clique只是一组共享一组公共磁盘阵列的Teradata节点。 当节点出现故障时，来自故障节点的vprocs将迁移到clique中的其他节点，并继续访问其磁盘阵列。
Cliques...
热备节点是不参与生产环境的节点。 如果节点出现故障，则故障节点的vprocs将迁移到热备份节点。 一旦故障节点恢复，它将成为热备份节点。 热备节点用于在节点故障的情况下维持性能。
袭击
热备节点是不参与生产环境的节点。 如果节点出现故障，则故障节点的vprocs将迁移到热备份节点。 一旦故障节点恢复，它将成为热备份节点。 热备节点用于在节点故障的情况下维持性能。...
RAID 1通常用于Teradata。 在RAID 1中，每个磁盘与镜像磁盘相关联。 对主磁盘中的数据的任何更改也反映在镜像副本中。 如果主磁盘发生故障，则可以访问来自镜像磁盘的数据。
Teradata - 用户管理
本章讨论了Teradata中用户管理的各种策略。
袭击...
本章讨论了Teradata中用户管理的各种策略。...
例子
以下是CREATE USER的语法。
CREATE USER username AS [PERMANENT|PERM] = n BYTES PASSWORD = password TEMPORARY = n BYTES SPOOL = n BYTES;
创建用户时，用户名，永久空间和密码的值是必需的。 其他字段是可选的。
例子
以下是创建用户TD01的示例。
CREATE USER TD01 AS PERMANENT = 1000000 BYTES PASSWORD = ABC$124 TEMPORARY = 1000000 BYTES SPOOL = 1000000 BYTES;
帐户
在创建新用户时，可以将用户分配到帐户。 CREATE USER中的ACCOUNT选项用于分配帐户。 用户可以分配到多个帐户。
例子
以下是具有帐户选项的CREATE USER的语法。
CREATE USER username PERM = n BYTES PASSWORD = password ACCOUNT = accountid
例子
以下是具有帐户选项的CREATE USER的语法。...
CREATE USER TD02 AS PERMANENT = 1000000 BYTES PASSWORD = abc$123 TEMPORARY = 1000000 BYTES SPOOL = 1000000 BYTES ACCOUNT = (‘IT’,’Admin’);
用户可以在登录Teradata系统或使用SET SESSION命令登录系统后指定帐户ID。
.LOGON username, passowrd,accountid OR SET SESSION ACCOUNT = accountid
帐户...
GRANT命令用于将数据库对象的一个或多个特权分配给用户或数据库。
例子
以下是GRANT命令的语法。
GRANT privileges ON objectname TO username;
特权可以是INSERT，SELECT，UPDATE，REFERENCES。
例子
以下是GRANT语句的示例。
GRANT SELECT,INSERT,UPDATE ON Employee TO TD01;
撤销特权
REVOKE命令从用户或数据库中删除特权。 REVOKE命令只能删除显式权限。
例子
以下是REVOKE命令的基本语法。
REVOKE [ALL|privileges] ON objectname FROM username;
例子
以下是REVOKE命令的示例。
REVOKE INSERT,SELECT ON Employee FROM TD01;
Teradata - 用户管理...
本章讨论Teradata中性能调整的过程。
撤销特权...
性能调整的第一步是在查询中使用EXPLAIN。 EXPLAIN计划提供了优化程序如何执行查询的详细信息。 在解释计划中，检查关键字，如置信度级别，使用的连接策略，假脱机文件大小，重新分配等。
收集统计数据
优化程序使用数据受众特征来制定有效的执行策略。 COLLECT STATISTICS命令用于收集表的数据人口统计。 确保在列上收集的统计数据是最新的。
收集在WHERE子句中使用的列以及在连接条件中使用的列上的统计信息。
收集唯一主索引列的统计信息。
收集非唯一二级索引列的统计信息。 优化器将决定是否可以使用NUSI或全表扫描。
通过基表上的统计信息收集联接索引的统计信息。
收集分区列上的统计信息。
数据类型
确保使用正确的数据类型。 这将避免使用超过所需的过量存储。
数据类型...
请确保连接条件中使用的列的数据类型兼容，以避免显式数据转换。
分类
删除不必要的ORDER BY子句，除非必需。
分类...
如果查询超过该用户的每个AMP卷轴空间限制，则会生成假脱机空间错误。 验证解释计划并识别占用更多假脱机空间的步骤。 这些中间查询可以拆分并单独放置以构建临时表。
主索引
确保为表正确定义了主索引。 主索引列应均匀分布数据，应经常用于访问数据。
主索引...
如果定义了SET表，那么优化器将检查记录是否与插入的每个记录重复。 要删除重复检查条件，可以为表定义唯一辅助索引。
更新大表
更新大表将是耗时的。 您可以删除记录，并插入带有修改行的记录，而不是更新表。
更新大表...
删除临时表（临时表）和挥发性（如果不再需要它们）。 这将释放永久空间和假脱机空间。
MULTISET表
如果确定输入记录不具有重复记录，则可以将目标表定义为MULTISET表，以避免SET表使用重复行检查。
Teradata - FastLoad
FastLoad实用程序用于将数据加载到空表。 由于它不使用临时日志，因此可以快速加载数据。 即使目标表是MULTISET表，它也不会加载重复行。
局限性
目标表不应该有二级索引，连接索引和外键引用。
MULTISET表...
FastLoad在两个阶段执行。
阶段1
解析引擎从输入文件中读取记录，并向每个AMP发送一个块。
每个AMP存储记录块。
然后AMP散列每个记录，并将它们重新分配到正确的AMP。
然后AMP散列每个记录，并将它们重新分配到正确的AMP。...
阶段2
阶段2在FastLoad接收到END LOADING语句时启动。
每个AMP对行散列上的记录进行排序，并将它们写入磁盘。
释放目标表上的锁，并删除错误表。
例子
释放目标表上的锁，并删除错误表。...
101,Mike,James,1980-01-05,2010-03-01,1 102,Robert,Williams,1983-03-05,2010-09-01,1 103,Peter,Paul,1983-04-01,2009-02-12,2 104,Alex,Stuart,1984-11-06,2014-01-01,2 105,Robert,James,1984-12-01,2015-03-09,3
下面是一个示例FastLoad脚本将上述文件加载到Employee_Stg表中。
LOGON 192.168.1.102/dbc,dbc;
DATABASE tduser;
BEGIN LOADING tduser.Employee_Stg
ERRORFILES Employee_ET, Employee_UV
CHECKPOINT 10;
SET RECORD VARTEXT ",";
DEFINE in_EmployeeNo (VARCHAR(10)),
in_FirstName (VARCHAR(30)),
in_LastName (VARCHAR(30)),
in_BirthDate (VARCHAR(10)),
in_JoinedDate (VARCHAR(10)),
in_DepartmentNo (VARCHAR(02)),
FILE = employee.txt;
INSERT INTO Employee_Stg (
EmployeeNo,
FirstName,
LastName,
BirthDate,
JoinedDate,
DepartmentNo
)
VALUES (
:in_EmployeeNo,
:in_FirstName,
:in_LastName,
:in_BirthDate (FORMAT 'YYYY-MM-DD'),
:in_JoinedDate (FORMAT 'YYYY-MM-DD'),
:in_DepartmentNo
);
END LOADING;
LOGOFF;
执行FastLoad脚本
创建输入文件employee.txt并将FastLoad脚本命名为EmployeeLoad.fl后，可以在UNIX和Windows中使用以下命令运行FastLoad脚本。
FastLoad < EmployeeLoad.fl;
一旦执行上述命令，FastLoad脚本将运行并产生日志。 在日志中，您可以看到FastLoad处理的记录数和状态代码。
**** 03:19:14 END LOADING COMPLETE
Total Records Read = 5
Total Error Table 1 = 0 ---- Table has been dropped
Total Error Table 2 = 0 ---- Table has been dropped
Total Inserts Applied = 5
Total Duplicate Rows = 0
Start: Fri Jan 8 03:19:13 2016
End : Fri Jan 8 03:19:14 2016
**** 03:19:14 Application Phase statistics:
Elapsed time: 00:00:01 (in hh:mm:ss)
0008 LOGOFF;
**** 03:19:15 Logging off all sessions
执行FastLoad脚本...
以下是FastLoad脚本中使用的常用术语列表。
LOGON - 登录到Teradata并启动一个或多个会话。
DATABASE - 设置默认数据库。
BEGIN LOADING - 标识要加载的表。
ERRORFILES - 标识需要创建/更新的2个错误表。
CHECKPOINT - 定义何时采取检查点。
SET RECORD - 指定输入文件格式是格式化，二进制，文本还是未格式化。
DEFINE - 定义输入文件布局。
FILE - 指定输入文件名和路径。
INSERT - 将输入文件中的记录插入目标表中。
INSERT - 将输入文件中的记录插入目标表中。...
LOGOFF - 结束所有会话并终止FastLoad。
Teradata - MultiLoad
MultiLoad可以一次加载多个表，它还可以执行不同类型的任务，如INSERT，DELETE，UPDATE和UPSERT。 它一次最多可以加载5个表，并在脚本中执行多达20个DML操作。 MultiLoad不需要目标表。
MultiLoad支持两种模式 -
- IMPORT
- DELETE
除了目标表之外，MultiLoad还需要一个工作表，一个日志表和两个错误表。
日志表 - 用于维护在加载期间采用的检查点，用于重新启动。
错误表 - 在发生错误时，在加载期间插入这些表。 第一个错误表存储转换错误，而第二个错误表存储重复记录。
日志表 - 维护MultiLoad每个阶段的结果，以便重新启动。
工作表 - MultiLoad脚本为每个目标表创建一个工作表。 工作表用于保留DML任务和输入数据。
局限性
MultiLoad有一些限制。
- Unique Secondary Index not supported on target table.
- Referential integrity not supported.
- Triggers not supported.
MultiLoad如何工作
MultiLoad导入有五个阶段 -
MultiLoad导入有五个阶段 - ...
阶段2 - DML事务阶段 - 验证DML语句的语法并将其带到Teradata系统。
阶段3 - 获取阶段 - 将输入数据置于工作表中并锁定表。
阶段4 - 应用程序阶段 - 应用所有DML操作。
阶段4 - 应用程序阶段 - 应用所有DML操作。...
MultiLoad脚本中涉及的步骤是 -
步骤1 - 设置日志表。
步骤2 - 登录到Teradata。
步骤3 - 指定目标，工作和错误表。
步骤3 - 指定目标，工作和错误表。...
步骤5 - 定义DML查询。
步骤6 - 命名IMPORT文件。
步骤7 - 指定要使用的布局。
步骤8 - 启动加载。
步骤9 - 完成加载并终止会话。
例子
创建具有以下记录的文本文件，并将该文件命名为employee.txt。
101,Mike,James,1980-01-05,2010-03-01,1 102,Robert,Williams,1983-03-05,2010-09-01,1 103,Peter,Paul,1983-04-01,2009-02-12,2 104,Alex,Stuart,1984-11-06,2014-01-01,2 105,Robert,James,1984-12-01,2015-03-09,3
以下示例是一个MultiLoad脚本，它从employee表中读取记录并加载到Employee_Stg表中。
.LOGTABLE tduser.Employee_log;
.LOGON 192.168.1.102/dbc,dbc;
.BEGIN MLOAD TABLES Employee_Stg;
.LAYOUT Employee;
.FIELD in_EmployeeNo * VARCHAR(10);
.FIELD in_FirstName * VARCHAR(30);
.FIELD in_LastName * VARCHAR(30);
.FIELD in_BirthDate * VARCHAR(10);
.FIELD in_JoinedDate * VARCHAR(10);
.FIELD in_DepartmentNo * VARCHAR(02);
.DML LABEL EmpLabel;
INSERT INTO Employee_Stg (
EmployeeNo,
FirstName,
LastName,
BirthDate,
JoinedDate,
DepartmentNo
)
VALUES (
:in_EmployeeNo,
:in_FirstName,
:in_Lastname,
:in_BirthDate,
:in_JoinedDate,
:in_DepartmentNo
);
.IMPORT INFILE employee.txt
FORMAT VARTEXT ','
LAYOUT Employee
APPLY EmpLabel;
.END MLOAD;
LOGOFF;
执行MultiLoad脚本
以下示例是一个MultiLoad脚本，它从employee表中读取记录并加载到Employee_Stg表中。...
Multiload < EmployeeLoad.ml;
Teradata - FastExport
FastExport实用程序用于将Teradata表中的数据导出为平面文件。 它还可以生成报告格式的数据。 可以使用Join从一个或多个表中提取数据。 由于FastExport导出64K块中的数据，因此它可用于提取大量数据。
例子
考虑以下Employee表。
| 员工不 | 名字 | 姓 | 生日 |
|---|---|---|---|
| 101 | Mike | James | 1/5/1980 |
| 104 | Alex | Stuart | 11/6/1984 |
| 102 | Robert | Williams | 3/5/1983 |
| 105 | Robert | James | 12/1/1984 |
| 103 | Peter | Paul | 4/1/1983 |
以下是FastExport脚本的示例。 它从employee表导出数据，并写入文件employeedata.txt。
.LOGTABLE tduser.employee_log;
.LOGON 192.168.1.102/dbc,dbc;
DATABASE tduser;
.BEGIN EXPORT SESSIONS 2;
.EXPORT OUTFILE employeedata.txt
MODE RECORD FORMAT TEXT;
SELECT CAST(EmployeeNo AS CHAR(10)),
CAST(FirstName AS CHAR(15)),
CAST(LastName AS CHAR(15)),
CAST(BirthDate AS CHAR(10))
FROM
Employee;
.END EXPORT;
.LOGOFF;
执行MultiLoad脚本...
一旦脚本被编写并命名为employee.fx，您可以使用以下命令来执行脚本。
fexp < employee.fx
执行上述命令后，您将在employeedata.txt文件中收到以下输出。
103 Peter Paul 1983-04-01 101 Mike James 1980-01-05 102 Robert Williams 1983-03-05 105 Robert James 1984-12-01 104 Alex Stuart 1984-11-06
FastExport条款
以下是FastExport脚本中常用的术语列表。
LOGTABLE - 指定用于重新启动目的的日志表。
LOGON - 登录到Teradata并启动一个或多个会话。
DATABASE - 设置默认数据库。
DATABASE - 设置默认数据库。...
EXPORT - 指定目标文件和导出格式。
SELECT - 指定要导出数据的选择查询。
END EXPORT - 指定FastExport的结束。
LOGOFF - 结束所有会话并终止FastExport。
Teradata - FastExport...
LOGOFF - 结束所有会话并终止FastExport。...
FastExport条款...
以下是BTEQ脚本中常用的术语列表。
LOGON - 用于登录Teradata系统。
ACTIVITYCOUNT - 返回受上一个查询影响的行数。
ERRORCODE - 返回上一个查询的状态代码。
DATABASE - 设置默认数据库。
DATABASE - 设置默认数据库。...
RUN FILE - 执行文件中包含的查询。
GOTO - 将控制权转移到标签。
LOGOFF - 从数据库注销并终止所有会话。
IMPORT - 指定输入文件路径。
EXPORT - 指定输出文件路径并启动导出。
例子
以下是BTEQ示例脚本。
.LOGON 192.168.1.102/dbc,dbc;
DATABASE tduser;
CREATE TABLE employee_bkup (
EmployeeNo INTEGER,
FirstName CHAR(30),
LastName CHAR(30),
DepartmentNo SMALLINT,
NetPay INTEGER
)
Unique Primary Index(EmployeeNo);
.IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;
SELECT * FROM
Employee
Sample 1;
.IF ACTIVITYCOUNT <> 0 THEN .GOTO InsertEmployee;
DROP TABLE employee_bkup;
.IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;
.LABEL InsertEmployee
INSERT INTO employee_bkup
SELECT a.EmployeeNo,
a.FirstName,
a.LastName,
a.DepartmentNo,
b.NetPay
FROM
Employee a INNER JOIN Salary b
ON (a.EmployeeNo = b.EmployeeNo);
.IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;
.LOGOFF;
上述脚本执行以下任务。
登录到Teradata系统。
设置缺省数据库。
创建名为employee_bkup的表。
从Employee表中选择一个记录，以检查表是否有任何记录。
如果表为空，则删除employee_bkup表。
如果表为空，则删除employee_bkup表。...
在每个SQL语句之后，检查ERRORCODE以确保语句成功。
ACTIVITYCOUNT返回先前SQL查询选择/影响的记录数。
更多建议：