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

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

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

4
00:00:25,600 --> 00:00:30,210
 查询 Microsoft SQL Server2012 课程。

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

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

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

8
00:00:41,070 --> 00:00:44,640
 屏幕右侧有一个聊天界面，

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

24
00:01:32,630 --> 00:01:36,760
 在 SQL Server 内进行某些高级  Transact-SQL

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

26
00:01:40,630 --> 00:01:44,350
 关系数据库、了解 

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

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

29
00:01:50,090 --> 00:01:52,890
 Microsoft Windows 操作系统及其核心

30
00:01:52,940 --> 00:01:55,630
 功能的基本知识。我们来看看

31
00:01:55,680 --> 00:01:58,740
 今天全天将要讨论什么。或者是晚上，这取决于

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

50
00:03:00,060 --> 00:03:03,800
 更高级的..主题。

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

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

53
00:03:10,850 --> 00:03:13,820
 是两小时，我保证。但是，大致是 60 分钟的

54
00:03:13,870 --> 00:03:17,760
 午餐时间，具体时间视情况

55
00:03:17,810 --> 00:03:21,630
 而定。在午餐后，

56
00:03:21,680 --> 00:03:24,050
 我们将讨论

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

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

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

60
00:03:33,580 --> 00:03:36,990
 主题并且讨论它们。我们将讨论修改

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

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

63
00:03:42,910 --> 00:03:45,980
 并且我们将看看如何使用约束、默认约束、

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

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

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

67
00:03:57,580 --> 00:04:01,560
 我们将看看一些编程元素、一些错误处理，

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

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

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

71
00:04:13,040 --> 00:04:16,630
 系统目录、动态管理视图

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

73
00:04:20,580 --> 00:04:24,110
 然后全面了解

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

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

76
00:04:29,510 --> 00:04:33,200
 将开始介绍 Microsoft SQL Server。

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

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

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

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

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

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

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

84
00:04:55,510 --> 00:04:58,820
 并且这将是模块 1。并且还只是为了

85
00:04:58,870 --> 00:05:02,940
 打下基础并且保持

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

87
00:05:06,210 --> 00:05:08,600
 不同类型的命令和语句

88
00:05:08,650 --> 00:05:11,510
 元素，并且看看一些基本的

89
00:05:11,560 --> 00:05:14,870
 选择语句。..

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

91
00:05:18,940 --> 00:05:22,670
 因此，您可以在这里找到三种命令。我们具有 

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

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

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

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

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

97
00:05:38,910 --> 00:05:42,240
 类别。我们还将讨论 DDL、

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

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

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

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

102
00:05:55,820 --> 00:05:58,710
 toast 命令。因此，我试图让 Microsoft 将命令

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

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

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

106
00:06:07,950 --> 00:06:08,360
 没有。

107
00:06:08,410 --> 00:06:11,800
  是的，没有。我以后将会想想办法。我不想

108
00:06:11,850 --> 00:06:15,020
 束手无策。因此，如果你们都赞成用 toast

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

110
00:06:18,150 --> 00:06:22,970
 并且我想如果我们都对

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

112
00:06:25,720 --> 00:06:29,560
 我一直在努力告诉 Brian 有关此 NC 标准的情况，

113
00:06:29,610 --> 00:06:34,310
 我们已尽力接近标准，

114
00:06:34,360 --> 00:06:37,540
 但显然，它们尚未达到 toast 命令的水准。

115
00:06:37,590 --> 00:06:40,320
 好了，我想我们可以设置了。..您可以进行新

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

117
00:06:44,430 --> 00:06:46,850
 更改到 toast 命令。这是个很酷的命令。

118
00:06:46,900 --> 00:06:49,420
 我们今天将会多次使用 toast。遗憾的是，

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

120
00:06:52,530 --> 00:06:53,860
 toast 命令。

121
00:06:53,910 --> 00:06:54,440
 不。

122
00:06:54,490 --> 00:06:57,360
 但没有 drop 命令。..没有 toast 命令。

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

124
00:07:00,150 --> 00:07:03,570
 这些数据控制语句控制对 SQL Server 数据库内

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

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

127
00:07:11,240 --> 00:07:11,890
 命令。

128
00:07:12,570 --> 00:07:17,700
 DML、DDL 和 DCL。现在，我们有一些将要 使用的 T-SQL 语言元素，

129
00:07:17,750 --> 00:07:19,770
 我们将要更深入地了解一下

130
00:07:19,820 --> 00:07:22,740
 这些元素。我先会介绍一下它们，然后让 Tobias

131
00:07:22,790 --> 00:07:24,860
 再多讲讲有关它们的情况。

132
00:07:24,910 --> 00:07:27,570
 我们将会介绍在编写 T-SQL 命令时我们会使用的

133
00:07:27,620 --> 00:07:30,690
 谓词和运算符，以及我们可能会调用的

134
00:07:30,740 --> 00:07:33,730
 不同函数。我们可能要重复使用存储过程之类的功能，

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

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

137
00:07:41,320 --> 00:07:44,690
 我们可以为此提供分隔符。我们想要控制该流程，

138
00:07:44,740 --> 00:07:48,670
 因此，我们可以使用 if/else 之类的语句。然后，

139
00:07:48,720 --> 00:07:51,160
 我们想要添加注释，因为我们始终认为给内容

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

141
00:07:53,460 --> 00:07:57,750
 将要向您展示如何对此内容添加注释。因此，我将

142
00:07:57,800 --> 00:08:01,610
 请 Tobias 演练其中一些元素，

143
00:08:02,230 --> 00:08:04,700
 在我们使用 T-SQL 时可使用这些元素。

144
00:08:06,650 --> 00:08:07,890
 谢谢您，Brian。好。

145
00:08:07,940 --> 00:08:13,240
 因此，您看到的是您在任何编程语言

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

147
00:08:16,910 --> 00:08:22,770
 我们具有谓词。这包括常见的运算符、常见的包括

148
00:08:22,820 --> 00:08:25,940
 like 在内的比较运算符，

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

150
00:08:30,080 --> 00:08:30,560
 和 or。

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

152
00:08:36,050 --> 00:08:38,710
 并且我考虑的我们关注的一件事就是

153
00:08:38,760 --> 00:08:45,140
 最佳实践、如何使用语言、

154
00:08:45,190 --> 00:08:49,580
 您应该考虑什么以及出于不同原因您要

155
00:08:49,630 --> 00:08:52,380
 避免什么。它们全都是上下文相关的，对吧？

156
00:08:52,430 --> 00:08:56,510
 因此，在正确时间使用正确内容显然会

157
00:08:56,560 --> 00:08:57,230
 对您有所帮助。

158
00:08:58,650 --> 00:09:01,440
 好，这些就是谓词。现在，我们也具有函数。

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

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

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

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

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

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

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

166
00:09:26,950 --> 00:09:30,450
 这些函数就属于聚合函数。因此我们可以使用 这三种函数。

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

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

169
00:09:38,010 --> 00:09:41,560
 变量，因为这使我们有机会

170
00:09:41,610 --> 00:09:45,140
 重复使用我们已创建的存储过程之类的项，

171
00:09:45,190 --> 00:09:48,750
 并且能够传递不同变量或具有这些变量的不同值。

172
00:09:48,800 --> 00:09:52,110
 因此，我们将看看如何声明变量。非常简单。

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

174
00:09:56,010 --> 00:09:59,140
 还可以同时初始化它。

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

176
00:10:02,010 --> 00:10:04,990
 使其更灵活和动态一些，

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

178
00:10:08,170 --> 00:10:11,540
 表达式。我们重新执行选择，一年，

179
00:10:11,590 --> 00:10:15,060
 订单日期加 1，我们选择订单数量乘以单价。

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

181
00:10:17,470 --> 00:10:21,200
 从表名称中选择星号。

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

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

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

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

186
00:10:33,250 --> 00:10:36,560
 批处理作业却是很强大，因为这允许我们

187
00:10:36,610 --> 00:10:40,090
 能够编写内容脚本，然后我们可以

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

189
00:10:44,630 --> 00:10:48,490
 我们通常可能要分隔它们。我们最常做的就是

190
00:10:48,540 --> 00:10:52,490
 使用 go 语句。现在，go 并不是特定于 SQL

191
00:10:52,540 --> 00:10:56,760
 Server T-SQL 命令的。它允许我们

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

193
00:11:00,840 --> 00:11:03,980
 并且知道如何使用

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

195
00:11:08,430 --> 00:11:11,250
 执行，

196
00:11:11,300 --> 00:11:13,980
 等待来自服务器的响应，然后我将发送其余内容，

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

198
00:11:17,410 --> 00:11:20,590
 并不真的知道做什么。它是不同的

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

200
00:11:24,730 --> 00:11:27,840
 批处理分隔符。

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

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

203
00:11:36,360 --> 00:11:39,710
 我们将要看看捕获错误的一些方法，

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

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

206
00:11:46,080 --> 00:11:49,560
 事务，例如如何定义

207
00:11:49,610 --> 00:11:52,640
 在批处理内使用的事务、提交该事务

208
00:11:52,690 --> 00:11:55,130
 并且可能需要回滚该事务。

209
00:11:55,920 --> 00:11:58,150
 您会想要进行记录，特别是在开始

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

211
00:12:00,240 --> 00:12:02,640
 情况。这使您有机会使用

212
00:12:02,690 --> 00:12:06,220
 注释代码块。这允许您设置注释。

213
00:12:06,270 --> 00:12:08,970
 您可以看到我们具有正斜杠加上星号。它们的

214
00:12:09,020 --> 00:12:13,340
 后面就是注释，注释后又是

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

216
00:12:16,800 --> 00:12:20,870
 想要一行注释，我们可以使用两个短划线。然后将

217
00:12:20,920 --> 00:12:23,870
 不会..执行该行。因此，如果您是在

218
00:12:23,920 --> 00:12:27,290
 进行针对特定脚本的故障排除并且暂时不想运行

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

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

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

222
00:12:36,670 --> 00:12:40,140
 想要在那里记录所做的事情，在批处理作业

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

224
00:12:43,670 --> 00:12:46,980
 或者作为针对该脚本或该批处理作业的文档。

225
00:12:47,670 --> 00:12:51,110
 现在，该实际上执行查询了。..如果您

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

227
00:12:54,470 --> 00:12:58,420
 where、group by 或 order by。

228
00:12:58,470 --> 00:13:01,720
 通常我们会看看编写方式，并且考虑

229
00:13:01,770 --> 00:13:04,610
 实际执行它的方式。我们想要在这里向您展示的是

230
00:13:04,660 --> 00:13:08,260
 要处理的查询的逻辑顺序。因此，要进行的第一件事

231
00:13:08,310 --> 00:13:10,490
 就是跳出到 from。

232
00:13:10,540 --> 00:13:11,680
 我们要了解它们。..

233
00:13:11,730 --> 00:13:15,550
 因此，Brian，为什么我会关心？为什么

234
00:13:15,600 --> 00:13:16,870
 逻辑查询处理很重要？

235
00:13:16,920 --> 00:13:18,600
 因为您想要确保在您编写

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

237
00:13:21,180 --> 00:13:25,600
 优化它，如果您理解了这些选项的顺序

238
00:13:25,650 --> 00:13:28,940
 或者这些要执行的语句，

239
00:13:28,990 --> 00:13:32,750
 您将有机会优化它并且使其运行更快一点。

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

241
00:13:35,270 --> 00:13:39,230
 查询顺序也很重要，并且

242
00:13:39,280 --> 00:13:43,560
 这有助于您清楚地了解在背后需要什么。

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

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

245
00:13:53,290 --> 00:13:56,710
 因此，..这并不意味着您键入的内容

246
00:13:56,760 --> 00:14:01,770
 恰恰是我们想要做的，

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

248
00:14:06,160 --> 00:14:09,820
 但它意味着我们受到了约束，以便我们将始终

249
00:14:09,870 --> 00:14:12,950
 按此顺序在逻辑上执行。因此，理解

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

251
00:14:15,890 --> 00:14:18,690
 因此，实际上以 from 语句开始，

252
00:14:18,740 --> 00:14:20,490
 然后转到 where 子句。我只是提出它们让您看到，

253
00:14:20,540 --> 00:14:25,270
 它们在这里编号。Group by、having，

254
00:14:25,320 --> 00:14:27,540
 然后是 select。足够奇怪的是，我编写的第一个内容是

255
00:14:27,590 --> 00:14:31,270
 select，但实际上.在步骤 5 之前..

256
00:14:31,930 --> 00:14:35,180
 并未解决。并且如果有 order by，

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

258
00:14:39,140 --> 00:14:41,920
 优化查询时

259
00:14:41,970 --> 00:14:44,200
 理解处理顺序是很重要的，您可以看到

260
00:14:44,250 --> 00:14:45,450
 这些信息来自于哪里。

261
00:14:45,500 --> 00:14:49,930
 并且我们在后面将更详细地介绍逻辑

262
00:14:49,980 --> 00:14:53,270
 查询处理，因为除了我们在本幻灯片上

263
00:14:53,320 --> 00:14:56,950
 展示的元素之外，还有其他一些针对该语言的元素。

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

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

266
00:15:03,530 --> 00:15:06,870
 Adventure Works。我们还..标识了要使用的

267
00:15:06,920 --> 00:15:10,570
 数据库，并且因此我始终从一个语句开始，

268
00:15:10,620 --> 00:15:12,940
 从而确保我处于适当的数据库中。

269
00:15:13,510 --> 00:15:14,730
 然后我们将添加 from。

270
00:15:15,680 --> 00:15:17,390
 这实际上是 sales.salesorderheader。

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

272
00:15:22,460 --> 00:15:25,640
 然后，我们必须获取订单日期的年份。

273
00:15:25,690 --> 00:15:27,560
 让计数大于 1。

274
00:15:28,400 --> 00:15:30,760
 然后执行，我们将具有所选部分。我们将不会

275
00:15:30,810 --> 00:15:33,110
 编写该语句，但这是

276
00:15:33,160 --> 00:15:36,970
 我们编写的将由 SQL Server 处理的语句。

277
00:15:37,020 --> 00:15:39,380
 并且最后以 order by 结尾。

278
00:15:39,430 --> 00:15:43,680
  对。我想要提到的一件事就是我们具有

279
00:15:43,730 --> 00:15:46,690
 与 SQL 有关的两个很棒的产品，不是吗？一个是 

280
00:15:46,740 --> 00:15:49,910
 SQL Server 2012，这是我们的本地产品，

281
00:15:49,960 --> 00:15:53,050
 另一个是 Windows Azure SQL Database， 这是我们在

282
00:15:53,100 --> 00:15:57,200
 Azure 中的云产品。并且在 SQL

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

284
00:16:02,230 --> 00:16:04,760
 SQL Server 不同。我们销售的是数据库， 而不是实例。

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

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

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

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

289
00:16:20,400 --> 00:16:24,690
 但在您的软件或者您编写的应用程序中，您最好

290
00:16:24,740 --> 00:16:28,590
 避免使用 use 语句。这里的另一件有趣的事情是，

291
00:16:28,640 --> 00:16:33,010
 如果您对在我们的 Azure 平台以及

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

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

294
00:16:40,780 --> 00:16:43,950
 在 SQL Server 上运行。

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

296
00:16:47,630 --> 00:16:48,290
 没有，

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

298
00:16:50,860 --> 00:16:54,200
 因此，好的。我们来再次看看一些基本的

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

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

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

302
00:17:03,580 --> 00:17:05,840
 from、where、group by 和 order by。

303
00:17:05,890 --> 00:17:07,350
 我们将要看看其中的许多内容。

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

305
00:17:10,410 --> 00:17:14,790
 我们实际上只是使用从 sales.customer  选择 customerID、store ID。

306
00:17:14,970 --> 00:17:19,770
 因此，我们在该对象的架构中标识该对象。

307
00:17:19,820 --> 00:17:21,790
 这里介绍的只是一些基本知识。好的，我们可以

308
00:17:21,840 --> 00:17:24,670
 更高级一些。您可以将星号放置于列中将

309
00:17:24,720 --> 00:17:26,870
 列名替换掉，代替标识列。

310
00:17:26,920 --> 00:17:28,820
 这是您可以编写的最基本的选择语句。

311
00:17:28,870 --> 00:17:31,660
 从表名称中选择星号。我们实际上将它提示了一个

312
00:17:31,710 --> 00:17:32,030
 档次。..

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

314
00:17:33,150 --> 00:17:34,220
 使它比这里的内容更容易？

315
00:17:34,270 --> 00:17:36,120
  是的。选择空间 1。

316
00:17:36,170 --> 00:17:37,600
 选择 space1。就是这个。..

317
00:17:37,650 --> 00:17:39,780
 这可能是您可以执行的最简单方法。

318
00:17:39,830 --> 00:17:43,460
 好的。好的，试试这个。如果您想要使用最 容易的语句，

319
00:17:43,510 --> 00:17:46,820
 您可以提交并

320
00:17:46,870 --> 00:17:50,220
 执行选择语句。..是什么，select space 1。

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

322
00:17:53,220 --> 00:17:55,880
 为什么您要这么做，但在您想要执行性能优化时

323
00:17:55,930 --> 00:17:58,530
 它是很有趣的，

324
00:17:58,580 --> 00:18:02,420
 如果您对 SQL Server 的性能感兴趣，例如

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

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

327
00:18:10,360 --> 00:18:12,570
 太棒了。当然。Select 1。

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

329
00:18:15,720 --> 00:18:18,980
 单价和订单数量，然后我们执行

330
00:18:19,030 --> 00:18:21,920
 计算，让单价乘以订单数量，

331
00:18:21,970 --> 00:18:25,770
 我们将要从销售订单详细信息表中取这个。 因此，我们实际上可以

332
00:18:25,820 --> 00:18:28,490
 使用这个。并且我们具有不同的计算。现在，我们在

333
00:18:28,540 --> 00:18:31,500
 这里执行乘法。但是，我们也可以执行加法、

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

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

336
00:18:38,310 --> 00:18:40,800
 串联。我们可以将内容进行串联。我们将会看看

337
00:18:40,850 --> 00:18:43,370
 串联的一些例子。我们刚刚介绍了将会在今天

338
00:18:43,420 --> 00:18:45,490
 学习的一些主题。

339
00:18:46,670 --> 00:18:49,210
 好了。我们来看看这里的一些基本的语句。

340
00:18:50,150 --> 00:18:52,700
 因此，我将离开 

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

342
00:18:59,600 --> 00:19:02,600
 然后进入 SQL Management Studio。我们 再次利用 adventure

343
00:19:02,650 --> 00:19:05,450
 works 并且我们已在使用 adventure works。 因此，我们可以再次

344
00:19:05,500 --> 00:19:06,880
 执行选择。

345
00:19:06,930 --> 00:19:07,750
  1, 1, 1.

346
00:19:07,800 --> 00:19:09,860
  1.我将要首先执行它，以便每个人都可以看到

347
00:19:09,910 --> 00:19:12,330
 这是有效的。很酷的是，如果您对它不熟悉，

348
00:19:12,380 --> 00:19:14,610
 可以突出显示它并且执行它。

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

350
00:19:18,310 --> 00:19:21,510
 正如您所说的，Tobias，我们已经与 

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

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

353
00:19:29,670 --> 00:19:32,930
 从 sales 中选择..

354
00:19:33,760 --> 00:19:37,250
 星号。..Intellisense 很酷，因为我无法

355
00:19:37,300 --> 00:19:39,970
 确切记得要去哪里，我可以转到销售或

356
00:19:40,020 --> 00:19:43,970
 表，订单标头，然后我们..将突出显示它并且

357
00:19:44,020 --> 00:19:46,510
 执行该命令。

358
00:19:47,150 --> 00:19:49,750
 并且它现在向我们提供许多信息。可能太多了，

359
00:19:49,800 --> 00:19:52,440
 因为现在我们获得了每一行，当我真的不是想要

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

361
00:19:55,600 --> 00:19:58,950
 若干项。因此，我们可以再次更改它以便执行

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

363
00:20:04,480 --> 00:20:05,580
 我们来实际进行销售。..

364
00:20:06,130 --> 00:20:07,670
 我们将执行它，..将它都拼写出来。

365
00:20:09,600 --> 00:20:11,650
 并且我们将再取一个。

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

367
00:20:19,870 --> 00:20:22,680
 到期日期。然后，我们将从销售中指定这个 

368
00:20:24,130 --> 00:20:28,610
 sales.salesorderheader，并且我将双击

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

370
00:20:32,380 --> 00:20:33,300
 执行

371
00:20:33,350 --> 00:20:34,220
  As sales。

372
00:20:35,120 --> 00:20:36,020
 抱歉，

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

374
00:20:41,380 --> 00:20:42,950
 我听不到您在说什么。很抱歉。

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

376
00:20:45,540 --> 00:20:47,080
 您在使用 sales 加上点。

377
00:20:47,130 --> 00:20:48,980
  哦，用作 sales.明白了。

378
00:20:49,030 --> 00:20:50,100
 因为您添加了它。

379
00:20:51,570 --> 00:20:54,880
  From sales.sales.duedate,  sales.orderheader.

380
00:20:55,910 --> 00:20:59,110
 As sales...并不真的想这么早做这个，

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

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

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

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

385
00:21:11,160 --> 00:21:12,670
 看到所有行。

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

387
00:21:16,060 --> 00:21:17,030
 我们如何来做？

388
00:21:17,910 --> 00:21:19,790
 我们使用 request 子句来实现该任务。因此，..

389
00:21:19,840 --> 00:21:22,600
 我将..重复使用它。我要在

390
00:21:22,650 --> 00:21:24,370
 这里做什么？我要向上

391
00:21:24,420 --> 00:21:27,510
 并且到达这里，我要让销售订单

392
00:21:31,070 --> 00:21:35,550
 ID 等于或者小于

393
00:21:36,910 --> 00:21:38,720
 等于 45,000。

394
00:21:40,070 --> 00:21:42,560
 我们来..看看，不错，..我们使用 44。

395
00:21:44,600 --> 00:21:47,140
 因此，现在我们删除了这些数目的行。我们删除了这些

396
00:21:47,190 --> 00:21:49,950
 数目的列。现在我们正删除这些数目的行。

397
00:21:50,930 --> 00:21:53,770
 现在您看到，如果我们真的很快向上跳到了消息，

398
00:21:53,820 --> 00:21:55,630
 您将会看到我们有 342 行。

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

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

401
00:22:06,430 --> 00:22:09,590
 有助于减少返回给

402
00:22:09,640 --> 00:22:13,710
 您的行数，并且在您管理该类型的内容时给您 提供强大功能。

403
00:22:14,590 --> 00:22:17,760
 因此，我们还可以在这里变化一下。

404
00:22:17,810 --> 00:22:21,350
 我们还可以使用 order by。因此，我们针对..

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

406
00:22:24,040 --> 00:22:25,780
 您想要销售订单 ID。

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

408
00:22:28,440 --> 00:22:29,160
 这就是整个过程。

409
00:22:30,150 --> 00:22:32,860
 因此，我们开始做这件事。我们将要执行它并且

410
00:22:32,910 --> 00:22:35,770
 现在它将按订单 ID 排序。

411
00:22:36,440 --> 00:22:39,390
 好了。

412
00:22:39,440 --> 00:22:44,170
 只用了在

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

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

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

416
00:22:55,180 --> 00:22:57,810
 我们的命令的基础上构建。

417
00:22:58,600 --> 00:23:00,260
 好了。回到这里的 PowerPoint。

418
00:23:01,720 --> 00:23:07,110
 我已经使用这里的幻灯片做了什么？我想我已经

419
00:23:07,160 --> 00:23:08,740
 打开了某个地方。找到了。

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

421
00:23:14,610 --> 00:23:17,370
 为了回顾一下，我们引入了三种不同的命令：

422
00:23:17,420 --> 00:23:21,770
 DML、DCL、DDL。我们今天将使用它们。

423
00:23:21,820 --> 00:23:24,950
 我们讨论了不同类型的元素，例如谓词、运算符、

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

425
00:23:29,280 --> 00:23:31,800
 我们将要更细致地探讨它们。我们已经看到了

426
00:23:31,850 --> 00:23:35,160
 不同的元素以及处理它们的方式。我们从

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

428
00:23:39,220 --> 00:23:41,680
 以及 order by这是在您执行某一选择语句

429
00:23:41,730 --> 00:23:45,350
 时实际进行处理的顺序。第一个

430
00:23:45,400 --> 00:23:48,740
 部分到此就结束了，

431
00:23:48,790 --> 00:23:52,630
 我们将要继续提供与使用 SQL Server 的

432
00:23:52,680 --> 00:23:58,070
 基本元素有关的信息。