1
00:00:00,000 --> 00:00:06,000
[音乐]

2
00:00:17,000 --> 00:00:21,000
>>大家好，欢迎学习本课程，Microsoft 总部

3
00:00:21,000 --> 00:00:26,000
位于 Bellevue/Redmond/Seattle 地区。
我们今天将要讲授

4
00:00:26,000 --> 00:00:30,000
查询 Microsoft SQL Server2012 课程。

5
00:00:30,000 --> 00:00:33,000
非常感谢各位莅临。我们希望

6
00:00:34,000 --> 00:00:37,000
与您互动，从而能够向我们提供一些反馈，

7
00:00:37,000 --> 00:00:41,000
因此，在您查看下几个小时的演示文稿时，

8
00:00:41,000 --> 00:00:45,000
屏幕右侧有一个聊天界面，

9
00:00:45,000 --> 00:00:48,000
您可以很方便地在这里回复或发送一些意见，

10
00:00:48,000 --> 00:00:52,000
也可以在这里聊天、我们有众多的 SME（即

11
00:00:52,000 --> 00:00:55,000
行业专家）在幕后与我们一起工作。我是

12
00:00:55,000 --> 00:00:59,000
Brian Alderman，我将进行说明，

13
00:00:59,000 --> 00:01:04,000
我们还将从演播室监视聊天情况。

14
00:01:04,000 --> 00:01:06,000
很酷的是，如果您键入了一个真正好的问题，

15
00:01:06,000 --> 00:01:10,000
这个问题将会发送给我们，我们将现场指出该问题

16
00:01:10,000 --> 00:01:12,000
并且回答该问题。好像消息是您

17
00:01:12,000 --> 00:01:15,000
不必全天都听我一个人说。我还在参加

18
00:01:15,000 --> 00:01:18,000
演播室 Tobias。您最近怎么样？

19
00:01:18,000 --> 00:01:21,000
>> 不太糟，Brian。来到这里感到很开心。

20
00:01:22,000 --> 00:01:24,000
>>很高兴看到您。感谢今天参加我们的课程。并且

21
00:01:24,000 --> 00:01:26,000
我想要确保每个人都理解

22
00:01:26,000 --> 00:01:30,000
今天讲述的内容。这更偏向于级别 300 课程。

23
00:01:30,000 --> 00:01:33,000
并且我们将尽力满足想要学习

24
00:01:33,000 --> 00:01:37,000
在 SQL Server 内进行某些高级 
Transact-SQL

25
00:01:37,000 --> 00:01:41,000
查询所需技能的群体。因此，您应该至少了解

26
00:01:41,000 --> 00:01:44,000
关系数据库、了解

27
00:01:44,000 --> 00:01:47,000
SSMS（即 SQL Server Management 
Studio），因为我们将要在

28
00:01:47,000 --> 00:01:50,000
这方面用很多时间，并且掌握某些

29
00:01:50,000 --> 00:01:53,000
Microsoft Windows 操作系统及其核心

30
00:01:53,000 --> 00:01:56,000
功能的基本知识。我们来看看

31
00:01:56,000 --> 00:01:59,000
今天全天将要讨论什么。或者是晚上，这取决于

32
00:01:59,000 --> 00:02:02,000
您从其拨号的位置。我们开始时将要介绍

33
00:02:02,000 --> 00:02:05,000
SQL Server 2012。我们会介绍一些模块，

34
00:02:05,000 --> 00:02:08,000
并且保持水平相当，确保每个人都理解

35
00:02:08,000 --> 00:02:10,000
全天中我们要处理的问题，

36
00:02:10,000 --> 00:02:13,000
以及全天我们要处理或使用一些

37
00:02:13,000 --> 00:02:16,000
术语和概念。然后，我们将进入下一模块，

38
00:02:16,000 --> 00:02:20,000
看看一些高级的选择语句，例如

39
00:02:20,000 --> 00:02:23,000
不同的子句、案例以及对数据进行联接、合并、

40
00:02:23,000 --> 00:02:28,000
筛选和排序，以及如何处理这些 null 值。

41
00:02:28,000 --> 00:02:31,000
我们将介绍数据类型。因为在

42
00:02:31,000 --> 00:02:34,000
SQL Server 中生成新对象时，理解

43
00:02:34,000 --> 00:02:38,000
适当的数据类型并且应用数据类型十分重要。

44
00:02:38,000 --> 00:02:42,000
因此，我们将讨论数据类型的转换，

45
00:02:42,000 --> 00:02:44,000
并且实际介绍一些 SQL Server 功能。

46
00:02:45,000 --> 00:02:48,000
然后，我们将对数据进行分组和聚合。并且在该

47
00:02:48,000 --> 00:02:51,000
方面中，我们将介绍通过使用子句进行分组。我们将

48
00:02:51,000 --> 00:02:56,000
讨论子查询。我们将讨论不同视图、内联表、

49
00:02:56,000 --> 00:03:00,000
有效的函数和派生表。我们还将讨论一些有关
分组和聚合数据的

50
00:03:00,000 --> 00:03:04,000
更高级的..主题。

51
00:03:04,000 --> 00:03:07,000
然后，我们将吃午餐。就餐时间大约是 60 分钟。

52
00:03:07,000 --> 00:03:11,000
可能是 45 分钟、60 分钟或两小时。不，将不会

53
00:03:11,000 --> 00:03:14,000
是两小时，我保证。但是，大致是 60 分钟的

54
00:03:14,000 --> 00:03:18,000
午餐时间，具体时间视情况

55
00:03:18,000 --> 00:03:22,000
而定。在午餐后，

56
00:03:22,000 --> 00:03:24,000
我们将讨论

57
00:03:24,000 --> 00:03:25,000
集运算符。

58
00:03:26,000 --> 00:03:30,000
集运算符包括 Windows 函数，以及使用数据透视表、

59
00:03:30,000 --> 00:03:34,000
多维数据集和汇总对集进行分组。我们将介绍这些

60
00:03:34,000 --> 00:03:37,000
主题并且讨论它们。我们将讨论修改

61
00:03:37,000 --> 00:03:39,000
数据，因为并不全都是与检索数据有关，我们需要

62
00:03:39,000 --> 00:03:43,000
知道如何正确插入、更新和删除内容。

63
00:03:43,000 --> 00:03:46,000
并且我们将看看如何使用约束、默认约束、

64
00:03:46,000 --> 00:03:50,000
触发器，以便确保在我们添加数据时，

65
00:03:50,000 --> 00:03:53,000
通过设置不同的默认值、约束和触发器，

66
00:03:53,000 --> 00:03:58,000
强制实现数据完整性。我们将看看如何使用 
T-SQL、Transact-SQL 进行编程。

67
00:03:58,000 --> 00:04:02,000
我们将看看一些编程元素、一些错误处理，

68
00:04:02,000 --> 00:04:05,000
并且在您的编程环境内理解和实现事务。

69
00:04:06,000 --> 00:04:09,000
然后，我们将通过检索 SQL Server

70
00:04:09,000 --> 00:04:13,000
元数据和改进 SQL Server 查询性能，圆满
完成今天的课程。因此，我们将看看

71
00:04:13,000 --> 00:04:17,000
系统目录、动态管理视图

72
00:04:17,000 --> 00:04:21,000
或 DMV 等方面。我们将讨论创建和执行存储过程，

73
00:04:21,000 --> 00:04:24,000
然后全面了解

74
00:04:24,000 --> 00:04:28,000
在进行查询时用来专门改进 SQL Server 性能的方法。

75
00:04:28,000 --> 00:04:29,000
因此，下面我们就来看一看。正如我们所说的，我们

76
00:04:30,000 --> 00:04:33,000
将开始介绍 Microsoft SQL Server。

77
00:04:33,000 --> 00:04:36,000
此外，还可以方便地使用右侧的这个聊天界面。如果

78
00:04:36,000 --> 00:04:38,000
您有任何疑问，请通过聊天界面告诉我们，

79
00:04:38,000 --> 00:04:42,000
我们将会回答您的问题。..我们具有很多的

80
00:04:42,000 --> 00:04:45,000
SME 可回答..您的问题。..这些 SME

81
00:04:45,000 --> 00:04:48,000
在幕后与我们一起工作。并且 Tobias 和我

82
00:04:48,000 --> 00:04:52,000
还将会在这些问题出现时提出一些现场问题。
我们现在

83
00:04:52,000 --> 00:04:55,000
就开始介绍 Microsoft SQL Server。

84
00:04:56,000 --> 00:04:59,000
并且这将是模块 1。并且还只是为了

85
00:04:59,000 --> 00:05:03,000
打下基础并且保持

86
00:05:03,000 --> 00:05:06,000
水平大致相当。我们将要谈论一些

87
00:05:06,000 --> 00:05:09,000
不同类型的命令和语句

88
00:05:09,000 --> 00:05:12,000
元素，并且看看一些基本的

89
00:05:12,000 --> 00:05:15,000
选择语句。..

90
00:05:15,000 --> 00:05:18,000
一些您可以执行的基本的选择语句。

91
00:05:19,000 --> 00:05:23,000
因此，您可以在这里找到三种命令。我们具有

92
00:05:23,000 --> 00:05:26,000
DML，即数据操作语言。本课程是查询

93
00:05:26,000 --> 00:05:30,000
SQL Server，主要针对的是 DML，

94
00:05:30,000 --> 00:05:33,000
特别是选择语句。..我们将要

95
00:05:33,000 --> 00:05:35,000
讨论的是插入、更新和删除

96
00:05:35,000 --> 00:05:39,000
命令，它们都属于语句的数据操作语言

97
00:05:39,000 --> 00:05:42,000
类别。我们还将讨论 DDL、

98
00:05:42,000 --> 00:05:45,000
如何创建对象、对象是数据库、表

99
00:05:45,000 --> 00:05:49,000
还是存储过程。并且在创建后，我们可能需要
进行修改。

100
00:05:49,000 --> 00:05:52,000
我们将介绍用于更改它的方法。并且最后，
我们可能会有

101
00:05:52,000 --> 00:05:56,000
某个原因要删除它。现在，我的目标是将该 
drop 命令更改为

102
00:05:56,000 --> 00:05:59,000
toast 命令。因此，我试图让 Microsoft 将命令

103
00:05:59,000 --> 00:06:01,000
从 drop 更改为 toast。我要与 Tobias

104
00:06:01,000 --> 00:06:05,000
合作，尝试让 toast 命令代替 drop 命令。

105
00:06:05,000 --> 00:06:08,000
是否有任何方法可让我们在本课程结束前完成该任务？

106
00:06:08,000 --> 00:06:12,000
>> 是的，没有。我以后将会想想办法。我不想

107
00:06:12,000 --> 00:06:15,000
束手无策。因此，如果你们都赞成用 toast

108
00:06:15,000 --> 00:06:18,000
命令代替 drop 命令，请让我们知道您的想法，

109
00:06:18,000 --> 00:06:23,000
并且我想如果我们都对

110
00:06:23,000 --> 00:06:26,000
SQL 开发团队施加足够影响，我们可能会在
下一版本中看到添加了 toast 命令。

111
00:06:26,000 --> 00:06:30,000
>>我一直在努力告诉 Brian 有关此 NC 标准的情况，

112
00:06:30,000 --> 00:06:34,000
我们已尽力接近标准，

113
00:06:34,000 --> 00:06:38,000
但显然，它们尚未达到 toast 命令的水准。

114
00:06:38,000 --> 00:06:40,000
>>好了，我想我们可以设置了。..您可以进行新

115
00:06:40,000 --> 00:06:44,000
设置了。可能每个人都要从 drop 命令

116
00:06:44,000 --> 00:06:47,000
更改到 toast 命令。这是个很酷的命令。

117
00:06:47,000 --> 00:06:49,000
我们今天将会多次使用 toast。遗憾的是，

118
00:06:49,000 --> 00:06:52,000
我要键入 drop，但在我键入 drop 时，我想的却是

119
00:06:53,000 --> 00:06:54,000
toast 命令。

120
00:06:54,000 --> 00:06:57,000
>>但没有 drop 命令。..没有 toast 命令。

121
00:06:57,000 --> 00:07:00,000
好了。我们还要谈谈数据控制语句。

122
00:07:00,000 --> 00:07:04,000
这些数据控制语句控制对 SQL Server 数据库内

123
00:07:04,000 --> 00:07:08,000
不同对象的访问。因此，它们是 DCL 命令。
我们也将要

124
00:07:08,000 --> 00:07:11,000
了解它们。因此，我们将使用三种不同类别的

125
00:07:11,000 --> 00:07:12,000
命令。

126
00:07:13,000 --> 00:07:18,000
DML、DDL 和 DCL。现在，我们有一些将要
使用的 T-SQL 语言元素，

127
00:07:18,000 --> 00:07:20,000
我们将要更深入地了解一下

128
00:07:20,000 --> 00:07:23,000
这些元素。我先会介绍一下它们，然后让 Tobias

129
00:07:23,000 --> 00:07:25,000
再多讲讲有关它们的情况。

130
00:07:25,000 --> 00:07:28,000
我们将会介绍在编写 T-SQL 命令时我们会使用的

131
00:07:28,000 --> 00:07:31,000
谓词和运算符，以及我们可能会调用的

132
00:07:31,000 --> 00:07:34,000
不同函数。我们可能要重复使用存储过程之类的功能，

133
00:07:34,000 --> 00:07:37,000
因此我们可能要传递变量。我们具有将能够使用的不同

134
00:07:37,000 --> 00:07:41,000
表达式、用于具有批处理作业的方法并且

135
00:07:41,000 --> 00:07:45,000
我们可以为此提供分隔符。我们想要控制该流程，

136
00:07:45,000 --> 00:07:49,000
因此，我们可以使用 if/else 之类的语句。然后，

137
00:07:49,000 --> 00:07:51,000
我们想要添加注释，因为我们始终认为给内容

138
00:07:51,000 --> 00:07:53,000
加注释很不错，因此我们想要确保可以添加注释。并且我们

139
00:07:53,000 --> 00:07:58,000
将要向您展示如何对此内容添加注释。因此，我将

140
00:07:58,000 --> 00:08:02,000
请 Tobias 演练其中一些元素，

141
00:08:02,000 --> 00:08:05,000
在我们使用 T-SQL 时可使用这些元素。

142
00:08:07,000 --> 00:08:08,000
>>谢谢您，Brian。好。

143
00:08:08,000 --> 00:08:13,000
因此，您看到的是您在任何编程语言

144
00:08:13,000 --> 00:08:15,000
中都设想存在的标准事务，对吧？

145
00:08:17,000 --> 00:08:23,000
我们具有谓词。这包括常见的运算符、常见的包括

146
00:08:23,000 --> 00:08:26,000
like 在内的比较运算符，

147
00:08:26,000 --> 00:08:30,000
like 是一种特殊的字符串类型的运算符。
我们有三种逻辑运算符：not、and

148
00:08:30,000 --> 00:08:31,000
和 or。

149
00:08:32,000 --> 00:08:36,000
并且我们在授课期间将深入探讨如何使用所有
这些运算符。

150
00:08:36,000 --> 00:08:39,000
并且我考虑的我们关注的一件事就是

151
00:08:39,000 --> 00:08:45,000
最佳实践、如何使用语言、

152
00:08:45,000 --> 00:08:50,000
您应该考虑什么以及出于不同原因您要

153
00:08:50,000 --> 00:08:52,000
避免什么。它们全都是上下文相关的，对吧？

154
00:08:52,000 --> 00:08:57,000
因此，在正确时间使用正确内容显然会

155
00:08:59,000 --> 00:09:01,000
>>好，这些就是谓词。现在，我们也具有函数。

156
00:09:01,000 --> 00:09:04,000
您看到我们有三个类别的函数。我们有字符串

157
00:09:04,000 --> 00:09:07,000
函数，如果您想要提取字符串的某一

158
00:09:07,000 --> 00:09:11,000
部分或者想要看看字符串的长度，则可以使用
字符串函数。我们有

159
00:09:11,000 --> 00:09:13,000
日期和时间函数。如果我们想要获取系统日期，

160
00:09:13,000 --> 00:09:18,000
或者如果我们想要查看一天中的某个时间段或
者添加一天中的某个时间段，

161
00:09:18,000 --> 00:09:21,000
则可以使用日期和时间函数。然后，我们具有聚合函数。
如果我们想要了解某个特定销售人员的

162
00:09:21,000 --> 00:09:27,000
平均销售额或者特定销售人员的总销售额，
可以使用聚合函数。

163
00:09:27,000 --> 00:09:30,000
这些函数就属于聚合函数。因此我们可以使用
这三种函数。

164
00:09:30,000 --> 00:09:34,000
并且我们将再次看看它们，我们今天的演示文
稿中会说明它们。

165
00:09:34,000 --> 00:09:38,000
并且我们将看到它们的实际使用情况。现在，
非常想使用

166
00:09:38,000 --> 00:09:42,000
变量，因为这使我们有机会

167
00:09:42,000 --> 00:09:45,000
重复使用我们已创建的存储过程之类的项，

168
00:09:45,000 --> 00:09:49,000
并且能够传递不同变量或具有这些变量的不同值。

169
00:09:49,000 --> 00:09:52,000
因此，我们将看看如何声明变量。非常简单。

170
00:09:52,000 --> 00:09:56,000
实际上，从 SQL Server 2008 开始，
我们现在不仅可以声明它，

171
00:09:56,000 --> 00:09:59,000
还可以同时初始化它。

172
00:09:59,000 --> 00:10:02,000
因此，我们将谈谈如何使用变量以及它们多么强大，
从而可以

173
00:10:02,000 --> 00:10:05,000
使其更灵活和动态一些，

174
00:10:05,000 --> 00:10:08,000
例如存储过程，如果我们重新尝试使用存储过程。
我们在这里有一些

175
00:10:08,000 --> 00:10:12,000
表达式。我们重新执行选择，一年，

176
00:10:12,000 --> 00:10:15,000
订单日期加 1，我们选择订单数量乘以单价。

177
00:10:15,000 --> 00:10:17,000
因此，我们可以使用我们的选择语句得到了创
造性的结果。我们不必

178
00:10:17,000 --> 00:10:21,000
从表名称中选择星号。

179
00:10:21,000 --> 00:10:24,000
我们实际上可以创建和自定义

180
00:10:24,000 --> 00:10:26,000
该结果集。并且我们将看看是否有一些机会，

181
00:10:26,000 --> 00:10:30,000
可以通过使用可供我们使用的这些表达式

182
00:10:30,000 --> 00:10:33,000
对结果集进行自定义。并且使用

183
00:10:33,000 --> 00:10:37,000
批处理作业却是很强大，因为这允许我们

184
00:10:37,000 --> 00:10:40,000
能够编写内容脚本，然后我们可以

185
00:10:40,000 --> 00:10:45,000
计划在特定时间运行该内容。并且如果我们具有多个语句，

186
00:10:45,000 --> 00:10:48,000
我们通常可能要分隔它们。我们最常做的就是

187
00:10:49,000 --> 00:10:52,000
使用 go 语句。现在，go 并不是特定于 SQL

188
00:10:53,000 --> 00:10:57,000
Server T-SQL 命令的。它允许我们

189
00:10:57,000 --> 00:11:01,000
分隔不同的批处理作业或者一个批处理作业内的命令。

190
00:11:01,000 --> 00:11:04,000
>>并且知道如何使用

191
00:11:04,000 --> 00:11:08,000
SQL Server Management Studio 之类
的工具很重要。看起来它在

192
00:11:08,000 --> 00:11:11,000
执行，

193
00:11:11,000 --> 00:11:14,000
等待来自服务器的响应，然后我将发送其余内容，

194
00:11:14,000 --> 00:11:17,000
并且在运行过程中执行此操作。因此，就像 
Brian 提到的，SQL Server 本身

195
00:11:17,000 --> 00:11:21,000
并不真的知道做什么。它是不同的

196
00:11:21,000 --> 00:11:24,000
工具，可以使用不同的批处理分隔符。但是，
我们的所有工具都默认使用

197
00:11:25,000 --> 00:11:28,000
批处理分隔符。

198
00:11:29,000 --> 00:11:32,000
>>我们可以使用的其他一些元素是流控制。
我将要简短

199
00:11:32,000 --> 00:11:36,000
谈谈它。If/else、while、begin end。
错误处理。

200
00:11:36,000 --> 00:11:40,000
我们将要看看捕获错误的一些方法，

201
00:11:40,000 --> 00:11:42,000
以及我们如何对这些错误作出响应。在今天的
后面我们将会

202
00:11:42,000 --> 00:11:46,000
讲讲它们。并且，我们还将花一些时间来说说

203
00:11:46,000 --> 00:11:50,000
事务，例如如何定义

204
00:11:50,000 --> 00:11:53,000
在批处理内使用的事务、提交该事务

205
00:11:53,000 --> 00:11:55,000
并且可能需要回滚该事务。

206
00:11:56,000 --> 00:11:58,000
您会想要进行记录，特别是在开始

207
00:11:58,000 --> 00:12:00,000
批处理作业时，您想要记录所发生的

208
00:12:00,000 --> 00:12:03,000
情况。这使您有机会使用

209
00:12:03,000 --> 00:12:06,000
注释代码块。这允许您设置注释。

210
00:12:06,000 --> 00:12:09,000
您可以看到我们具有正斜杠加上星号。它们的

211
00:12:09,000 --> 00:12:13,000
后面就是注释，注释后又是

212
00:12:13,000 --> 00:12:17,000
正斜杠加上星号。这将结束该注释块。如果您只是

213
00:12:17,000 --> 00:12:21,000
想要一行注释，我们可以使用两个短划线。然后将

214
00:12:21,000 --> 00:12:24,000
不会..执行该行。因此，如果您是在

215
00:12:24,000 --> 00:12:27,000
进行针对特定脚本的故障排除并且暂时不想运行

216
00:12:27,000 --> 00:12:30,000
某些代码，则可以使用注释代码块或

217
00:12:30,000 --> 00:12:34,000
或两个短划线注释掉不想运行的代码，

218
00:12:34,000 --> 00:12:37,000
并且运行时将会暂时忽略这些代码。或者，如果您只是

219
00:12:37,000 --> 00:12:40,000
想要在那里记录所做的事情，在批处理作业

220
00:12:40,000 --> 00:12:44,000
正在运行时， 您实际上可以向该文档添加一些注释。

221
00:12:44,000 --> 00:12:47,000
或者作为针对该脚本或该批处理作业的文档。

222
00:12:48,000 --> 00:12:51,000
现在，该实际上执行查询了。..如果您

223
00:12:51,000 --> 00:12:54,000
理解了选择语句，则可以使用 from、..

224
00:12:54,000 --> 00:12:58,000
where、group by 或 order by。

225
00:12:58,000 --> 00:13:02,000
通常我们会看看编写方式，并且考虑

226
00:13:02,000 --> 00:13:05,000
实际执行它的方式。我们想要在这里向您展示的是

227
00:13:05,000 --> 00:13:08,000
要处理的查询的逻辑顺序。因此，要进行的第一件事

228
00:13:08,000 --> 00:13:10,000
就是跳出到 from。

229
00:13:11,000 --> 00:13:12,000
我们要了解它们。..

230
00:13:12,000 --> 00:13:16,000
>>因此，Brian，为什么我会关心？为什么

231
00:13:16,000 --> 00:13:17,000
逻辑查询处理很重要？

232
00:13:17,000 --> 00:13:19,000
>>因为您想要确保在您编写

233
00:13:19,000 --> 00:13:21,000
此信息时理解了，并且如果您在进行故障排除和尝试

234
00:13:21,000 --> 00:13:26,000
优化它，如果您理解了这些选项的顺序

235
00:13:26,000 --> 00:13:29,000
或者这些要执行的语句，

236
00:13:29,000 --> 00:13:33,000
您将有机会优化它并且使其运行更快一点。

237
00:13:33,000 --> 00:13:35,000
>>是的，这很好。并且..知道逻辑

238
00:13:35,000 --> 00:13:39,000
查询顺序也很重要，并且

239
00:13:39,000 --> 00:13:44,000
这有助于您清楚地了解在背后需要什么。

240
00:13:44,000 --> 00:13:49,000
因此，如果您不确切明白如何建立查询语言的结构，

241
00:13:49,000 --> 00:13:53,000
则可能最终不会得到您想要的结果。

242
00:13:53,000 --> 00:13:57,000
因此，..这并不意味着您键入的内容

243
00:13:57,000 --> 00:14:02,000
恰恰是我们想要做的，

244
00:14:02,000 --> 00:14:06,000
因为我们有了这个很棒的查询优化器，它会确定正确方式，
也就是用于向您提供结果的最佳方法。

245
00:14:06,000 --> 00:14:10,000
但它意味着我们受到了约束，以便我们将始终

246
00:14:10,000 --> 00:14:13,000
按此顺序在逻辑上执行。因此，理解

247
00:14:13,000 --> 00:14:15,000
逻辑查询处理极其重要。

248
00:14:16,000 --> 00:14:19,000
>>因此，实际上以 from 语句开始，

249
00:14:19,000 --> 00:14:20,000
然后转到 where 子句。我只是提出它们让您看到，

250
00:14:21,000 --> 00:14:25,000
它们在这里编号。Group by、having，

251
00:14:25,000 --> 00:14:28,000
然后是 select。足够奇怪的是，我编写的第一个内容是

252
00:14:28,000 --> 00:14:31,000
select，但实际上.在步骤 5 之前..

253
00:14:32,000 --> 00:14:35,000
并未解决。并且如果有 order by，

254
00:14:35,000 --> 00:14:39,000
这是最后执行的。因此，在您重新编写查询或
者在您尝试

255
00:14:39,000 --> 00:14:42,000
优化查询时

256
00:14:42,000 --> 00:14:44,000
理解处理顺序是很重要的，您可以看到

257
00:14:44,000 --> 00:14:45,000
这些信息来自于哪里。

258
00:14:46,000 --> 00:14:50,000
>>并且我们在后面将更详细地介绍逻辑

259
00:14:50,000 --> 00:14:53,000
查询处理，因为除了我们在本幻灯片上

260
00:14:53,000 --> 00:14:57,000
展示的元素之外，还有其他一些针对该语言的元素。

261
00:14:58,000 --> 00:15:01,000
>>因此，这适用于这里的运算的逻辑顺序。

262
00:15:01,000 --> 00:15:03,000
我们在这里已得到了这个语句，因此让我们从
顶部开始，使用

263
00:15:04,000 --> 00:15:07,000
Adventure Works。我们还..标识了要使用的

264
00:15:07,000 --> 00:15:11,000
数据库，并且因此我始终从一个语句开始，

265
00:15:11,000 --> 00:15:13,000
从而确保我处于适当的数据库中。

266
00:15:14,000 --> 00:15:15,000
然后我们将添加 from。

267
00:15:16,000 --> 00:15:17,000
这实际上是 sales.salesorderheader。

268
00:15:18,000 --> 00:15:22,000
其中，客户 ID 等于某个编号。按销售人员进行分组。

269
00:15:22,000 --> 00:15:26,000
然后，我们必须获取订单日期的年份。

270
00:15:26,000 --> 00:15:28,000
让计数大于 1。

271
00:15:28,000 --> 00:15:31,000
然后执行，我们将具有所选部分。我们将不会

272
00:15:31,000 --> 00:15:33,000
编写该语句，但这是

273
00:15:33,000 --> 00:15:37,000
我们编写的将由 SQL Server 处理的语句。

274
00:15:37,000 --> 00:15:39,000
并且最后以 order by 结尾。

275
00:15:39,000 --> 00:15:44,000
>> 对。我想要提到的一件事就是我们具有

276
00:15:44,000 --> 00:15:47,000
与 SQL 有关的两个很棒的产品，不是吗？一个是

277
00:15:47,000 --> 00:15:50,000
SQL Server 2012，这是我们的本地产品，

278
00:15:50,000 --> 00:15:53,000
另一个是 Windows Azure SQL Database，
这是我们在

279
00:15:53,000 --> 00:15:57,000
Azure 中的云产品。并且在 SQL

280
00:15:57,000 --> 00:16:02,000
数据库中并不支持使用 use 语句本身，因为
我们所销售的与

281
00:16:02,000 --> 00:16:05,000
SQL Server 不同。我们销售的是数据库，
而不是实例。

282
00:16:05,000 --> 00:16:09,000
知道这一点很重要。如果您想要创建在这两个
平台上都能很好

283
00:16:09,000 --> 00:16:13,000
运行的软件，则不应在您的程序内使用

284
00:16:13,000 --> 00:16:16,000
use 语句。是的，您将非常频繁地在

285
00:16:17,000 --> 00:16:20,000
SQL Server 中使用该语句调试或预测您的脚本，

286
00:16:20,000 --> 00:16:25,000
但在您的软件或者您编写的应用程序中，您最好

287
00:16:25,000 --> 00:16:29,000
避免使用 use 语句。这里的另一件有趣的事情是，

288
00:16:29,000 --> 00:16:33,000
如果您对在我们的 Azure 平台以及

289
00:16:33,000 --> 00:16:37,000
我们的本地平台上使用它感兴趣，则应该在这
两个平台上都

290
00:16:37,000 --> 00:16:41,000
试用它。此外，如果您在针对 
Windows Azure SQL DB 进行开发，则也将能够

291
00:16:41,000 --> 00:16:44,000
在 SQL Server 上运行。

292
00:16:44,000 --> 00:16:48,000
>>您是否在部署前建议他们对代码进行测试？

293
00:16:48,000 --> 00:16:51,000
>>真的没有。好的。因为我不知道我们是否需
要做这件事。

294
00:16:51,000 --> 00:16:54,000
因此，好的。我们来再次看看一些基本的

295
00:16:54,000 --> 00:16:58,000
选择语句。其中一些语句可能更高级并且

296
00:16:58,000 --> 00:17:00,000
您可能对它们很熟悉，但我们只是想要确保每个人都

297
00:17:00,000 --> 00:17:04,000
在看相同的页面。因此，我们具有选择语句，
我们提供选择列表，

298
00:17:04,000 --> 00:17:06,000
from、where、group by 和 order by。

299
00:17:06,000 --> 00:17:07,000
我们将要看看其中的许多内容。

300
00:17:08,000 --> 00:17:10,000
在这里我们看看从一个组中检索调用。

301
00:17:10,000 --> 00:17:15,000
我们实际上只是使用从 sales.customer 
选择 customerID、store ID。

302
00:17:15,000 --> 00:17:20,000
因此，我们在该对象的架构中标识该对象。

303
00:17:20,000 --> 00:17:22,000
这里介绍的只是一些基本知识。好的，我们可以

304
00:17:22,000 --> 00:17:25,000
更高级一些。您可以将星号放置于列中将

305
00:17:25,000 --> 00:17:27,000
列名替换掉，代替标识列。

306
00:17:27,000 --> 00:17:29,000
这是您可以编写的最基本的选择语句。

307
00:17:29,000 --> 00:17:32,000
从表名称中选择星号。我们实际上将它提示了一个

308
00:17:32,000 --> 00:17:33,000
>>我们可以使它更容易一些。

309
00:17:33,000 --> 00:17:34,000
>>使它比这里的内容更容易？

310
00:17:34,000 --> 00:17:36,000
>> 是的。选择空间 1。

311
00:17:36,000 --> 00:17:38,000
>>选择 space1。就是这个。..

312
00:17:38,000 --> 00:17:40,000
>>这可能是您可以执行的最简单方法。

313
00:17:40,000 --> 00:17:43,000
>>好的。好的，试试这个。如果您想要使用最
容易的语句，

314
00:17:44,000 --> 00:17:47,000
您可以提交并

315
00:17:47,000 --> 00:17:50,000
执行选择语句。..是什么，select space 1。

316
00:17:50,000 --> 00:17:53,000
>>实际上不是这样。..它看起来没什么价值
并且有些蠢，

317
00:17:53,000 --> 00:17:56,000
为什么您要这么做，但在您想要执行性能优化时

318
00:17:56,000 --> 00:17:59,000
它是很有趣的，

319
00:17:59,000 --> 00:18:02,000
如果您对 SQL Server 的性能感兴趣，例如

320
00:18:02,000 --> 00:18:06,000
网络等方面，而对在数据库引擎中实际发生的

321
00:18:06,000 --> 00:18:10,000
情况感兴趣，则 select1 很适合进行测试。

322
00:18:10,000 --> 00:18:13,000
>>太棒了。当然。Select 1。

323
00:18:13,000 --> 00:18:16,000
好的。使用计算，因此，正如您在这里看到的，
我们选择了

324
00:18:16,000 --> 00:18:19,000
单价和订单数量，然后我们执行

325
00:18:19,000 --> 00:18:22,000
计算，让单价乘以订单数量，

326
00:18:22,000 --> 00:18:26,000
我们将要从销售订单详细信息表中取这个。
因此，我们实际上可以

327
00:18:26,000 --> 00:18:28,000
使用这个。并且我们具有不同的计算。现在，我们在

328
00:18:29,000 --> 00:18:32,000
这里执行乘法。但是，我们也可以执行加法、

329
00:18:32,000 --> 00:18:35,000
除法和百分比计算。因此，我们具有这些不同的计算，

330
00:18:35,000 --> 00:18:38,000
我们也可以采用标量计算。我们还可以执行

331
00:18:38,000 --> 00:18:41,000
串联。我们可以将内容进行串联。我们将会看看

332
00:18:41,000 --> 00:18:43,000
串联的一些例子。我们刚刚介绍了将会在今天

333
00:18:43,000 --> 00:18:45,000
学习的一些主题。

334
00:18:47,000 --> 00:18:49,000
好了。我们来看看这里的一些基本的语句。

335
00:18:50,000 --> 00:18:53,000
因此，我将离开

336
00:18:54,000 --> 00:18:58,000
PowerPoint 幻灯片并且跳转到这里的图像，

337
00:19:00,000 --> 00:19:03,000
然后进入 SQL Management Studio。我们
再次利用 adventure

338
00:19:03,000 --> 00:19:05,000
works 并且我们已在使用 adventure works。
因此，我们可以再次

339
00:19:06,000 --> 00:19:07,000
执行选择。

340
00:19:07,000 --> 00:19:08,000
>> 1, 1, 1.

341
00:19:08,000 --> 00:19:10,000
>> 1.我将要首先执行它，以便每个人都可以看到

342
00:19:10,000 --> 00:19:12,000
这是有效的。很酷的是，如果您对它不熟悉，

343
00:19:12,000 --> 00:19:15,000
可以突出显示它并且执行它。

344
00:19:15,000 --> 00:19:18,000
并且您没有列名称，但会返回一个。因此，

345
00:19:18,000 --> 00:19:22,000
正如您所说的，Tobias，我们已经与

346
00:19:22,000 --> 00:19:25,000
SQL Server 通信并且得到了响应。因此，
我们知道事情是奏效的。

347
00:19:25,000 --> 00:19:30,000
我们能够进行通信。现在，您还可以再提升一下，

348
00:19:30,000 --> 00:19:33,000
从 sales 中选择..

349
00:19:34,000 --> 00:19:37,000
星号。..Intellisense 很酷，因为我无法

350
00:19:37,000 --> 00:19:40,000
确切记得要去哪里，我可以转到销售或

351
00:19:40,000 --> 00:19:44,000
表，订单标头，然后我们..将突出显示它并且

352
00:19:44,000 --> 00:19:47,000
执行该命令。

353
00:19:47,000 --> 00:19:50,000
并且它现在向我们提供许多信息。可能太多了，

354
00:19:50,000 --> 00:19:52,000
因为现在我们获得了每一行，当我真的不是想要

355
00:19:52,000 --> 00:19:56,000
每一行，对不起，..应该是每一列。
我只是想要与这里的行有关的

356
00:19:56,000 --> 00:19:59,000
若干项。因此，我们可以再次更改它以便执行

357
00:19:59,000 --> 00:20:02,000
选择。我们将获取销售订单 ID。

358
00:20:04,000 --> 00:20:06,000
我们来实际进行销售。..

359
00:20:06,000 --> 00:20:08,000
我们将执行它，..将它都拼写出来。

360
00:20:10,000 --> 00:20:12,000
并且我们将再取一个。

361
00:20:12,000 --> 00:20:16,000
我们将选取到期日期，因此我们留在这里。

362
00:20:20,000 --> 00:20:23,000
到期日期。然后，我们将从销售中指定这个

363
00:20:24,000 --> 00:20:29,000
sales.salesorderheader，并且我将双击

364
00:20:29,000 --> 00:20:32,000
此处，省了几个键击操作。因此，我们将再次
突出显示它并且

365
00:20:32,000 --> 00:20:33,000
执行

366
00:20:33,000 --> 00:20:34,000
>> As sales。

367
00:20:35,000 --> 00:20:36,000
>>抱歉，

368
00:20:36,000 --> 00:20:41,000
>>您必须作为 salesfor。..您可以试一下。

369
00:20:41,000 --> 00:20:43,000
>>我听不到您在说什么。很抱歉。

370
00:20:43,000 --> 00:20:45,000
>>您必须指定表别名，因为您添加了它。..

371
00:20:46,000 --> 00:20:47,000
您在使用 sales 加上点。

372
00:20:47,000 --> 00:20:49,000
>> 哦，用作 sales.明白了。

373
00:20:49,000 --> 00:20:50,000
>>因为您添加了它。

374
00:20:52,000 --> 00:20:55,000
>> From sales.sales.duedate, 
sales.orderheader.

375
00:20:56,000 --> 00:20:59,000
As sales...并不真的想这么早做这个，

376
00:20:59,000 --> 00:21:00,000
但我们还是要执行此操作。

377
00:21:01,000 --> 00:21:05,000
我们继续。执行它。好了。因此，现在我们设
置了不同的内容。..

378
00:21:05,000 --> 00:21:07,000
因此，我们获得了我们的销售订单 ID 以及
在那里设置的我们的到期日期。

379
00:21:08,000 --> 00:21:11,000
好了。然后，我们添加了它。现在，..我们..

380
00:21:11,000 --> 00:21:13,000
看到所有行。

381
00:21:13,000 --> 00:21:16,000
我们来看看是否可以控制返回的行数。

382
00:21:16,000 --> 00:21:17,000
我们如何来做？

383
00:21:18,000 --> 00:21:20,000
我们使用 request 子句来实现该任务。因此，..

384
00:21:20,000 --> 00:21:23,000
我将..重复使用它。我要在

385
00:21:23,000 --> 00:21:24,000
这里做什么？我要向上

386
00:21:24,000 --> 00:21:28,000
并且到达这里，我要让销售订单

387
00:21:31,000 --> 00:21:36,000
ID 等于或者小于

388
00:21:37,000 --> 00:21:39,000
等于 45,000。

389
00:21:40,000 --> 00:21:43,000
我们来..看看，不错，..我们使用 44。

390
00:21:45,000 --> 00:21:47,000
因此，现在我们删除了这些数目的行。我们删除了这些

391
00:21:47,000 --> 00:21:50,000
数目的列。现在我们正删除这些数目的行。

392
00:21:51,000 --> 00:21:54,000
现在您看到，如果我们真的很快向上跳到了消息，

393
00:21:54,000 --> 00:21:56,000
您将会看到我们有 342 行。

394
00:21:56,000 --> 00:22:01,000
现在，我们还是运行这个命令，但不像前面那
样使用 where 子句，

395
00:22:02,000 --> 00:22:06,000
跳转到消息后，我们具有了 31,465 行。
因此，where 子句..

396
00:22:06,000 --> 00:22:10,000
有助于减少返回给

397
00:22:10,000 --> 00:22:14,000
您的行数，并且在您管理该类型的内容时给您
提供强大功能。

398
00:22:15,000 --> 00:22:18,000
因此，我们还可以在这里变化一下。

399
00:22:18,000 --> 00:22:21,000
我们还可以使用 order by。因此，我们针对..

400
00:22:21,000 --> 00:22:23,000
销售订单 ID 使用 order by。

401
00:22:24,000 --> 00:22:26,000
>>您想要销售订单 ID。

402
00:22:26,000 --> 00:22:28,000
>>是的，就这么简单。我想要更好地使用数字。我认为

403
00:22:28,000 --> 00:22:29,000
这就是整个过程。

404
00:22:30,000 --> 00:22:33,000
因此，我们开始做这件事。我们将要执行它并且

405
00:22:33,000 --> 00:22:36,000
现在它将按订单 ID 排序。

406
00:22:36,000 --> 00:22:39,000
好了。

407
00:22:39,000 --> 00:22:44,000
只用了在

408
00:22:44,000 --> 00:22:48,000
SQL Server 内与执行选择语句有关的几个
基本的选择语句，并且会感到

409
00:22:48,000 --> 00:22:53,000
很适合使用。..我们要在 SSMS 上用一些时间，
这样我们可以

410
00:22:53,000 --> 00:22:55,000
把重点放在要执行的方面，并且在我们遇到这
些命令时在

411
00:22:55,000 --> 00:22:58,000
我们的命令的基础上构建。

412
00:22:59,000 --> 00:23:00,000
好了。回到这里的 PowerPoint。

413
00:23:02,000 --> 00:23:07,000
我已经使用这里的幻灯片做了什么？我想我已经

414
00:23:07,000 --> 00:23:09,000
打开了某个地方。找到了。

415
00:23:11,000 --> 00:23:15,000
好了。现在快速演示一下如何编写基本的选择语句。

416
00:23:15,000 --> 00:23:17,000
为了回顾一下，我们引入了三种不同的命令：

417
00:23:17,000 --> 00:23:22,000
DML、DCL、DDL。我们今天将使用它们。

418
00:23:22,000 --> 00:23:25,000
我们讨论了不同类型的元素，例如谓词、运算符、

419
00:23:25,000 --> 00:23:29,000
函数、变量、注释、控制流。此外，

420
00:23:29,000 --> 00:23:32,000
我们将要更细致地探讨它们。我们已经看到了

421
00:23:32,000 --> 00:23:35,000
不同的元素以及处理它们的方式。我们从

422
00:23:35,000 --> 00:23:39,000
from 开始，然后是 where、group
by、having、select

423
00:23:39,000 --> 00:23:42,000
以及 order by这是在您执行某一选择语句

424
00:23:42,000 --> 00:23:45,000
时实际进行处理的顺序。第一个

425
00:23:45,000 --> 00:23:49,000
部分到此就结束了，

426
00:23:49,000 --> 00:23:53,000
我们将要继续提供与使用 SQL Server 的

427
00:23:53,000 --> 00:23:58,000
基本元素有关的信息。