1
00:00:00,000 --> 00:00:03,493
>> [音乐播放]

2
00:00:03,493 --> 00:00:04,934

3
00:00:04,934 --> 00:00:07,100
道格·劳埃德：在我们的视频
关于Web开发的话题，

4
00:00:07,100 --> 00:00:10,560
我们已经提到的概念
数据库几次，对不对？

5
00:00:10,560 --> 00:00:12,700
所以数据库你
可能是熟悉的

6
00:00:12,700 --> 00:00:15,780
说使用Microsoft Excel
或谷歌电子表格。

7
00:00:15,780 --> 00:00:20,650
它实际上只是一个有组织的
设置表，行和列。

8
00:00:20,650 --> 00:00:23,140
>> 而数据库是哪里
我们的网站商店

9
00:00:23,140 --> 00:00:26,760
这一点很重要信息
为我们的网站能正常工作。

10
00:00:26,760 --> 00:00:30,150
此外，一个非常常见的例子在这里
在存储用户名和密码

11
00:00:30,150 --> 00:00:32,824
在数据库中，使得当
用户登录到我们的网站，

12
00:00:32,824 --> 00:00:36,690
该数据库可被查询，看
如果该用户在数据库中存在。

13
00:00:36,690 --> 00:00:39,260
如果是这样，检查
他们的密码是正确的。

14
00:00:39,260 --> 00:00:43,420
而如果他们的密码是正确的，
那么，我们可以给他们任何网页

15
00:00:43,420 --> 00:00:45,370
他们请求。

16
00:00:45,370 --> 00:00:48,590
>> 所以，你很可能再次熟悉
这个想法从Excel或谷歌

17
00:00:48,590 --> 00:00:49,430
电子表格。

18
00:00:49,430 --> 00:00:52,980
我们有数据库，
表，行和列。

19
00:00:52,980 --> 00:00:56,450
这就是真正的排序
基本集

20
00:00:56,450 --> 00:00:58,470
这里分层分解。

21
00:00:58,470 --> 00:00:59,800
因此，这里的Excel电子表格。

22
00:00:59,800 --> 00:01:02,640
如果你曾经开了这
或其他类似的程序

23
00:01:02,640 --> 00:01:06,780
你知道，这些这里有
rows-- 1，2，3，4，5，6，7。

24
00:01:06,780 --> 00:01:08,760
这些都是列。

25
00:01:08,760 --> 00:01:11,790
>> 也许到这里，虽然你可能
不使用此功能非常much--

26
00:01:11,790 --> 00:01:15,370
我会放大in--我们
这一想法的片材。

27
00:01:15,370 --> 00:01:17,930
因此，也许这些表，如果
我交替往复，

28
00:01:17,930 --> 00:01:21,600
不同的表
存在于我的数据库。

29
00:01:21,600 --> 00:01:25,210
如果我们继续这个例子所有
顺便说一下，这个数据库的名称

30
00:01:25,210 --> 00:01:26,940
是书1。

31
00:01:26,940 --> 00:01:28,710
也许我有第二册和第三册。

32
00:01:28,710 --> 00:01:33,270
所以，每一个Excel文件是一个
数据库中，每个片是一个表，

33
00:01:33,270 --> 00:01:39,530
每个表格里面我有
这一想法的行和列。

34
00:01:39,530 --> 00:01:41,900
>> 那么，如何使用这个数据库的工作？

35
00:01:41,900 --> 00:01:43,630
我如何获得它的信息？

36
00:01:43,630 --> 00:01:47,540
那么有一个叫做语言SQL--
我通常只是打电话Sequel--

37
00:01:47,540 --> 00:01:50,010
它代表的是
结构化查询语言。

38
00:01:50,010 --> 00:01:52,981
而且它是一种编程语言，
但它是一个相当有限编程

39
00:01:52,981 --> 00:01:53,480
语言。

40
00:01:53,480 --> 00:01:56,407
这不是很喜欢别人
我们已经合作过。

41
00:01:56,407 --> 00:01:58,240
但这样做的目的
程序设计语言

42
00:01:58,240 --> 00:02:01,570
是查询数据库，以
问一个数据库的信息，

43
00:02:01,570 --> 00:02:04,480
找到一个信息
数据库，等等。

44
00:02:04,480 --> 00:02:08,449
>> 我们在CS50--这是一个非常
共同的平台，这就是所谓的MySQL。

45
00:02:08,449 --> 00:02:10,600
这就是我们在使用过程中使用的。

46
00:02:10,600 --> 00:02:12,880
这是一个开放源码
平台建立

47
00:02:12,880 --> 00:02:16,732
所谓关系型数据库 - 
一个数据库，有效。

48
00:02:16,732 --> 00:02:18,440
我们并不需要得到
太多细节

49
00:02:18,440 --> 00:02:20,930
对什么是关系数据库。

50
00:02:20,930 --> 00:02:24,650
但是，SQL语言
非常善于工作

51
00:02:24,650 --> 00:02:29,760
与MySQL和其它类似
样式的关系数据库。

52
00:02:29,760 --> 00:02:34,010
>> 而很多的安装
MySQL的来的东西

53
00:02:34,010 --> 00:02:37,760
所谓的phpMyAdmin，这
是一个图形用户

54
00:02:37,760 --> 00:02:40,970
interface--一个GUI--的
使得它多一点

55
00:02:40,970 --> 00:02:44,410
用户友好的执行
数据库查询，

56
00:02:44,410 --> 00:02:48,980
因为数据库不仅用于
由高级程序员，对吗？

57
00:02:48,980 --> 00:02:51,510
有时有
这些小企业，

58
00:02:51,510 --> 00:02:53,900
他们无法承受
聘请程序员的团队，

59
00:02:53,900 --> 00:02:56,700
但他们仍然需要存储
在数据库中的信息。

60
00:02:56,700 --> 00:02:59,300
>> 类似的phpMyAdmin
使得它很容易为​​别人

61
00:02:59,300 --> 00:03:03,630
谁之前从未编程
拿起和熟悉如何

62
00:03:03,630 --> 00:03:07,710
与数据库一起工作。

63
00:03:07,710 --> 00:03:11,800
问题是，phpMyAdmin的，而
这是一个奇妙的工具，学习

64
00:03:11,800 --> 00:03:14,850
有关数据库，它是手动的。

65
00:03:14,850 --> 00:03:18,050
你将不得不登录
它与执行命令和类型

66
00:03:18,050 --> 00:03:19,910
事情手动研究。

67
00:03:19,910 --> 00:03:23,160
>> 而且，因为我们知道我们的
例如PHP的Web编程，

68
00:03:23,160 --> 00:03:26,550
有做手工
在我们的网站上的东西，

69
00:03:26,550 --> 00:03:30,970
如果我们想要一个充满活力，积极响应
网站，也许不是最好的方法。

70
00:03:30,970 --> 00:03:33,980
我们希望找到一种方法，
也许是自动完成这一莫名其妙。

71
00:03:33,980 --> 00:03:37,864
和SQL将使我们能够做到这一点。

72
00:03:37,864 --> 00:03:39,780
所以，当我们要
开始使用SQL工作，

73
00:03:39,780 --> 00:03:41,220
我们首先需要有一个
数据库一起工作。

74
00:03:41,220 --> 00:03:42,510
创建一个数据库
一些你可能

75
00:03:42,510 --> 00:03:45,350
会做的phpMyAdmin的，因为
你只需要做一次，

76
00:03:45,350 --> 00:03:49,690
和语法这样做
很多更简单。

77
00:03:49,690 --> 00:03:51,940
这是一个更容易做到这一点
在图形用户界面

78
00:03:51,940 --> 00:03:53,520
不是打字它作为一个命令。

79
00:03:53,520 --> 00:03:55,186
该命令可能会变得有些繁琐。

80
00:03:55,186 --> 00:03:58,889
同样，在创建一个表可以
得到相当有点麻烦，以及。

81
00:03:58,889 --> 00:04:01,930
所以像创建数据库
并创建一个表，你

82
00:04:01,930 --> 00:04:06,270
大概只打算做once--
每一次表，每一次数据库 - 

83
00:04:06,270 --> 00:04:09,040
它是确定做，在
图形界面。

84
00:04:09,040 --> 00:04:11,570
在过程中
创建一个表，你会

85
00:04:11,570 --> 00:04:14,840
还必须指定所有的
列，就可以在该表中。

86
00:04:14,840 --> 00:04:18,149
什么样的信息做
要存储在表中？

87
00:04:18,149 --> 00:04:24,520
也许用户的姓名和出生日期，
口令，用户ID号，也许

88
00:04:24,520 --> 00:04:26,170
城市和国家，对不对？

89
00:04:26,170 --> 00:04:30,080
>> 而对于每一次我们要添加一个用户
到数据库中，我们希望得到所有六个

90
00:04:30,080 --> 00:04:31,890
的这些信息。

91
00:04:31,890 --> 00:04:34,840
同时，我们也通过添加
行到表。

92
00:04:34,840 --> 00:04:37,800
因此，我们首先创建一个数据库，
然后我们创建一个表。

93
00:04:37,800 --> 00:04:40,100
作为创建的一部分
一个表中，我们被要求

94
00:04:40,100 --> 00:04:44,280
指定每列
我们希望在此表中。

95
00:04:44,280 --> 00:04:47,247
然后，当我们开始增加
信息到数据库

96
00:04:47,247 --> 00:04:49,580
和查询数据库的更多
generally--不仅仅是增加，

97
00:04:49,580 --> 00:04:51,610
但一切我们
do--我们会处理

98
00:04:51,610 --> 00:04:58,870
与行的表，这是一个
从整组用户的信息。

99
00:04:58,870 --> 00:05:03,210
>> 所以，每一个SQL列能够
保持一个特定数据类型的数据。

100
00:05:03,210 --> 00:05:06,560
因此，我们的排序消除了这种
在PHP中的数据类型的想法，

101
00:05:06,560 --> 00:05:08,747
但他们回到这里SQL。

102
00:05:08,747 --> 00:05:10,080
而且有很多的数据类型。

103
00:05:10,080 --> 00:05:13,420
这里的只有20人，但
它甚至不是所有的人。

104
00:05:13,420 --> 00:05:16,240
因此，我们有一些理念，如INTs--
Integers--我们大概知道

105
00:05:16,240 --> 00:05:17,760
该列可以容纳整数。

106
00:05:17,760 --> 00:05:21,077
而有变化thereon--
SMALLINT，TINYINT，MEDIUMINT，BIGINT。

107
00:05:21,077 --> 00:05:22,660
也许我们并不总是需要四个叮咬。

108
00:05:22,660 --> 00:05:26,800
也许我们需要8个字节，所以我们
可以使用整数这些变化

109
00:05:26,800 --> 00:05:28,510
要多一点空间，高效。

110
00:05:28,510 --> 00:05:31,899
我们可以做的十进制数，我们
可以做浮点数。

111
00:05:31,899 --> 00:05:32,940
这是非常相似的。

112
00:05:32,940 --> 00:05:34,773
有一定的差异，
如果你愿意

113
00:05:34,773 --> 00:05:37,330
想查找
SQL排序指导，你

114
00:05:37,330 --> 00:05:40,670
可以看到轻微
区别是它们之间。

115
00:05:40,670 --> 00:05:43,250
>> 也许我们要存储
关于日期和时间信息。

116
00:05:43,250 --> 00:05:47,047
也许我们跟踪
当用户加入了我们的网站，

117
00:05:47,047 --> 00:05:48,880
所以，也许我们要
有一列的

118
00:05:48,880 --> 00:05:52,820
日期时间或时间戳
表示当用户实际上

119
00:05:52,820 --> 00:05:54,130
注册。

120
00:05:54,130 --> 00:05:56,132
我们可以做的几何形状和线串。

121
00:05:56,132 --> 00:05:57,340
这实际上是很酷。

122
00:05:57,340 --> 00:06:01,410
我们可以绘制出
使用地理区域

123
00:06:01,410 --> 00:06:05,110
GIS坐标绘制出的区域。

124
00:06:05,110 --> 00:06:08,580
所以实际上可以存储排序
在一个SQL列信息。

125
00:06:08,580 --> 00:06:11,390
>> 文本是文本的只是巨大的斑点，也许。

126
00:06:11,390 --> 00:06:12,840
枚举是一种有趣的。

127
00:06:12,840 --> 00:06:16,080
他们实际上存在于C.我们不
谈论他们，因为他们不

128
00:06:16,080 --> 00:06:19,110
非常常用，至少CS50。

129
00:06:19,110 --> 00:06:22,680
但它是一个枚举数据类型，
能够保持限制值。

130
00:06:22,680 --> 00:06:25,940
>> 一个真正很好的例子是
创建一个枚举，其中七

131
00:06:25,940 --> 00:06:29,394
可能的值是星期日，星期一，
周二，周三，周四，周五，

132
00:06:29,394 --> 00:06:30,060
周六，对不对？

133
00:06:30,060 --> 00:06:33,311
对这些数据类型的天
周不存在，

134
00:06:33,311 --> 00:06:35,310
但我们可以创建一个
枚举数据类型，

135
00:06:35,310 --> 00:06:39,400
这列永远只能容纳
其中的一个七个可能的值。

136
00:06:39,400 --> 00:06:44,300
我们列举所有
的可能值。

137
00:06:44,300 --> 00:06:47,630
>> 然后我们有CHAR和VARCHAR，
我已经上色这些绿色

138
00:06:47,630 --> 00:06:49,505
因为我们实际上
要采取第二

139
00:06:49,505 --> 00:06:51,950
谈论的区别
这两件事情之间。

140
00:06:51,950 --> 00:06:55,780
所以CHAR，不像C，其中
CHAR是单个字符，

141
00:06:55,780 --> 00:07:00,730
SQL中的CHAR指
一个固定长度的字符串。

142
00:07:00,730 --> 00:07:02,620
而当我们创建这个
专栏中，我们实际上

143
00:07:02,620 --> 00:07:05,070
可以指定字符串的长度。

144
00:07:05,070 --> 00:07:08,080
>> 所以在这个例子中，
我们可以说CHAR（10）。

145
00:07:08,080 --> 00:07:11,190
这意味着，每
该列的元件

146
00:07:11,190 --> 00:07:13,910
将包括10字节的信息。

147
00:07:13,910 --> 00:07:15,770
没有更多，不会少。

148
00:07:15,770 --> 00:07:21,780
因此，如果我们试图把一个15
位或15字符元素

149
00:07:21,780 --> 00:07:25,340
或值此列，
我们只拿到了前10。

150
00:07:25,340 --> 00:07:27,290
如果我们把在两
字符长的值，

151
00:07:27,290 --> 00:07:30,700
我们将有两个
字符，然后8空叮咬。

152
00:07:30,700 --> 00:07:34,990
我们永远不会比这更有效。

153
00:07:34,990 --> 00:07:37,727
>> 一个varchar是一种像
我们一串概念

154
00:07:37,727 --> 00:07:39,560
我们已经很熟悉
从C或从PHP。

155
00:07:39,560 --> 00:07:40,830
这是一个可变长度的字符串。

156
00:07:40,830 --> 00:07:42,560
当你创建
这个专栏中，你只要

157
00:07:42,560 --> 00:07:44,860
指定的最大可能长度。

158
00:07:44,860 --> 00:07:49,065
因此，也许99或通常255。

159
00:07:49,065 --> 00:07:50,440
这将是最大长度。

160
00:07:50,440 --> 00:07:52,890
所以，如果我们存储
15文字串，

161
00:07:52,890 --> 00:07:56,157
我们将使用15个字节，也许16
字节的空终止。

162
00:07:56,157 --> 00:07:57,990
如果我们存储
三个字符的字符串，

163
00:07:57,990 --> 00:08:01,120
我们将使用三个或四个字节。

164
00:08:01,120 --> 00:08:03,050
但是，我们不会使用完整的99。

165
00:08:03,050 --> 00:08:05,190
>> 那么，为什么我们兼得？

166
00:08:05,190 --> 00:08:08,210
那么，如果我们需要弄清楚如何
长的东西是一个VARCHAR，

167
00:08:08,210 --> 00:08:10,680
我们有一种迭代的
通过它就像我们用C做

168
00:08:10,680 --> 00:08:12,230
并找出它停止。

169
00:08:12,230 --> 00:08:15,920
而如果我们知道这一切
在此列是10个字节，也许

170
00:08:15,920 --> 00:08:19,220
我们知道的信息，我们可以跳
10字节，10字节，10字节，10字节，

171
00:08:19,220 --> 00:08:21,790
始终找不到了
开头的字符串。

172
00:08:21,790 --> 00:08:25,210
>> 因此，我们可能有一些
浪费的空间用CHAR，

173
00:08:25,210 --> 00:08:28,510
但也许有一个贸易
关闭有更好的速度

174
00:08:28,510 --> 00:08:30,160
在导航数据库。

175
00:08:30,160 --> 00:08:32,330
但也许我们想要的
VARCHAR类型的灵活性

176
00:08:32,330 --> 00:08:36,710
而不是having--如果我们的CHAR
是255的，但我们的大多数用户

177
00:08:36,710 --> 00:08:40,537
只输入三个或四个字节
的信息价值或三个或四个

178
00:08:40,537 --> 00:08:41,870
字符的信息价值。

179
00:08:41,870 --> 00:08:44,324
>> 但是，一些用户使用
整个255，也许

180
00:08:44,324 --> 00:08:45,990
VARCHAR会比较合适那里。

181
00:08:45,990 --> 00:08:49,840
这有点交易的关闭，
一般为了CS50的，

182
00:08:49,840 --> 00:08:54,107
你不必太担心
无论您使用的是CHAR或VARCHAR。

183
00:08:54,107 --> 00:08:57,190
但在现实世界中，这些东西
做的事，因为所有这些列

184
00:08:57,190 --> 00:08:59,300
占用实际的物理空间。

185
00:08:59,300 --> 00:09:04,150
和物理空间，在
现实世界中，是有溢价。

186
00:09:04,150 --> 00:09:06,800
>> 所以有其他考虑
你建立一个表时，

187
00:09:06,800 --> 00:09:09,840
是选择一列是
什么叫做一个主键。

188
00:09:09,840 --> 00:09:14,350
和主键是一列
其中，每一个值是唯一的。

189
00:09:14,350 --> 00:09:19,980
这意味着，你可以很容易地
挑选出的单行只是看

190
00:09:19,980 --> 00:09:22,450
在该行的主键。

191
00:09:22,450 --> 00:09:24,580
因此，例如，你
通常，与用户，

192
00:09:24,580 --> 00:09:27,210
不想让两个用户谁
具有相同的用户ID号。

193
00:09:27,210 --> 00:09:28,960
所以，也许你有
大量的信息，

194
00:09:28,960 --> 00:09:30,793
也许两个用户
具有相同的name--

195
00:09:30,793 --> 00:09:32,650
你有约翰·史密斯和约翰·史密斯。

196
00:09:32,650 --> 00:09:34,520
这不一定是一个问题，
因为有多人

197
00:09:34,520 --> 00:09:35,830
在名为约翰·史密斯的世界。

198
00:09:35,830 --> 00:09:40,766
但是，我们只有一个用户ID号
10，一个用户ID号11，12，13。

199
00:09:40,766 --> 00:09:42,640
我们没有两个用户
用相同的号码，

200
00:09:42,640 --> 00:09:46,010
所以也许用户ID号
将是一个好主键。

201
00:09:46,010 --> 00:09:48,610
>> 我们没有任何重复，
我们现在可以唯一地

202
00:09:48,610 --> 00:09:52,619
只是识别每一行
通过查看该列。

203
00:09:52,619 --> 00:09:55,410
选择主键实际上可以
进行后续表操作

204
00:09:55,410 --> 00:09:59,710
轻松很多，因为你可以利用
一个事实，即某些行会

205
00:09:59,710 --> 00:10:02,720
是唯一的，或者某些列
你的数据库或表

206
00:10:02,720 --> 00:10:06,030
将是唯一的挑
出特定的行。

207
00:10:06,030 --> 00:10:08,790
>> 你也可以有一个联合主
密钥，你会发现机会

208
00:10:08,790 --> 00:10:11,720
使用，这仅仅是一个
两列的组合，其

209
00:10:11,720 --> 00:10:13,280
保证是唯一的。

210
00:10:13,280 --> 00:10:16,410
因此，也许你有一个
列的AS和B，

211
00:10:16,410 --> 00:10:19,290
一列这是一个，两个，
三，但你永远只

212
00:10:19,290 --> 00:10:23,660
有一个单一的A 1，单
A2，等等等等。

213
00:10:23,660 --> 00:10:28,980
但是，你可能有一个B2，一
C 2，或A1，A2，A3，A4。

214
00:10:28,980 --> 00:10:32,840
所以，你可能有多个如，多
烧烤，多的，多三三两两，

215
00:10:32,840 --> 00:10:38,567
但你永远只能有一个
单A1，B2，C3等。

216
00:10:38,567 --> 00:10:40,400
所以，正如我所说的，SQL是一种
编程语言，

217
00:10:40,400 --> 00:10:42,024
但它有一个相当有限的词汇。

218
00:10:42,024 --> 00:10:44,880
这是不是很广阔的
C和PHP等语言

219
00:10:44,880 --> 00:10:46,350
我们在谈的过程中。

220
00:10:46,350 --> 00:10:49,960
它是更详细的一
语言比我们

221
00:10:49,960 --> 00:10:52,789
要在此谈谈
视频，因为在这个视频

222
00:10:52,789 --> 00:10:54,830
我们要谈
四则运算我们

223
00:10:54,830 --> 00:10:55,720
可以对表执行。

224
00:10:55,720 --> 00:10:56,761
>> 还有比这更多。

225
00:10:56,761 --> 00:10:58,730
我们可以做的比这更多，
但我们的目的，

226
00:10:58,730 --> 00:11:02,250
我们通常将要使用
短短四年operations--插入，

227
00:11:02,250 --> 00:11:05,360
选择，更新和删除。

228
00:11:05,360 --> 00:11:08,750
你大概可以直观地猜测
什么所有这四个事情要做。

229
00:11:08,750 --> 00:11:12,520
但是，我们将进入一个位
细节上的每一个。

230
00:11:12,520 --> 00:11:15,780
>> 所以为便于这
视频，让我们假设

231
00:11:15,780 --> 00:11:18,870
我们有以下两种
表在单个数据库中。

232
00:11:18,870 --> 00:11:23,460
我们有有一个表称为用户
4 columns-- ID号，用户名，

233
00:11:23,460 --> 00:11:25,350
密码和全名。

234
00:11:25,350 --> 00:11:27,430
我们有一个第二
表在同一数据库中

235
00:11:27,430 --> 00:11:32,129
叫妈妈，只是存储信息
关于用户名和母亲。

236
00:11:32,129 --> 00:11:33,920
因此，对于所有的实施例
在这段视频中，我们将

237
00:11:33,920 --> 00:11:37,945
使用此数据库并
后续更新它。

238
00:11:37,945 --> 00:11:40,070
因此，让我们说，我们要
信息添加到表中。

239
00:11:40,070 --> 00:11:44,460
这就是插入操作做什么。

240
00:11:44,460 --> 00:11:46,550
在解释所有
这些命令，我​​要去

241
00:11:46,550 --> 00:11:48,860
给你一个总体框架来使用。

242
00:11:48,860 --> 00:11:51,661
因为基本上，查询
打算看非常相似，

243
00:11:51,661 --> 00:11:54,660
我们只是要改变
略微不同的信息

244
00:11:54,660 --> 00:11:56,750
做不同的事情与表。

245
00:11:56,750 --> 00:11:59,200
>> 所以对于INSERT，骨架
看起来有点像这样。

246
00:11:59,200 --> 00:12:02,230
我们要插入到
一个特定的表。

247
00:12:02,230 --> 00:12:05,290
然后，我们有一个开放的括号
和列的列表

248
00:12:05,290 --> 00:12:08,070
我们希望把值放入。

249
00:12:08,070 --> 00:12:10,974
关闭括号中，
下面的值，然后

250
00:12:10,974 --> 00:12:13,390
再次，我们列出的值
我们希望把在表中。

251
00:12:13,390 --> 00:12:15,950
>> 这所以一个例子
将是如下。

252
00:12:15,950 --> 00:12:19,170
我想插入到表
用户以下columns--

253
00:12:19,170 --> 00:12:21,010
用户名，密码和全名。

254
00:12:21,010 --> 00:12:25,282
因此，一个新行，其中我把
在这三列，我们很

255
00:12:25,282 --> 00:12:30,030
打算把在值
纽曼，USMAIL，和纽曼。

256
00:12:30,030 --> 00:12:32,730
因此，在这种情况下，我
把小写纽曼

257
00:12:32,730 --> 00:12:38,710
入用户名栏，密码
USMAIL，并全称资本ñ

258
00:12:38,710 --> 00:12:41,940
纽曼进入全名列。

259
00:12:41,940 --> 00:12:44,240
>> 因此，这里就是数据库
看起来像以前一样。

260
00:12:44,240 --> 00:12:48,250
下面是用户表上
顶级前看着我们这样做等。

261
00:12:48,250 --> 00:12:50,760
当我们执行这个
查询，我们得到这个。

262
00:12:50,760 --> 00:12:54,790
我们增加了一个新行到表中。

263
00:12:54,790 --> 00:12:56,810
但请注意这样一件事
我没有具体说明，

264
00:12:56,810 --> 00:12:59,880
但不知何故，我已经有了一个值
对，这就是这12个就在这里。

265
00:12:59,880 --> 00:13:02,820
我并没有说我想
把ID号在那里。

266
00:13:02,820 --> 00:13:04,900
我希望把用户名，
密码，全称。

267
00:13:04,900 --> 00:13:06,440
而我做了，这很好。

268
00:13:06,440 --> 00:13:07,760
>> 但我也得到了这个12。

269
00:13:07,760 --> 00:13:09,490
为什么我得到这12？

270
00:13:09,490 --> 00:13:12,904
嗯，事实证明，
当你定义

271
00:13:12,904 --> 00:13:15,570
这将是一列你
主键，通常是，

272
00:13:15,570 --> 00:13:16,510
就像我说的，一个ID号。

273
00:13:16,510 --> 00:13:18,718
这并不一定总是
将是一个ID号码，

274
00:13:18,718 --> 00:13:22,380
但它通常是一个好主意
是某种整数值。

275
00:13:22,380 --> 00:13:25,950
你必须在phpMyAdmin的选择
你创建数据库时

276
00:13:25,950 --> 00:13:31,130
或者你的表设置
列自动递增。

277
00:13:31,130 --> 00:13:34,520
>> 这是一个非常好的主意时，
你有一个主键的工作，

278
00:13:34,520 --> 00:13:39,330
因为你想每个值
该列中是唯一的。

279
00:13:39,330 --> 00:13:43,310
如果你忘记指定
它为一个以上的人，

280
00:13:43,310 --> 00:13:46,240
你现在有一个情况
该列不再是唯一的。

281
00:13:46,240 --> 00:13:50,200
你有两个空格，这样你就可以没有
较长的唯一标识一个column--

282
00:13:50,200 --> 00:13:54,150
或者你可以不再唯一
确定根据该列一行。

283
00:13:54,150 --> 00:13:57,010
它失去了它的所有
值作为主键。

284
00:13:57,010 --> 00:14:02,010
>> 所以显然我做了什么
这里被配置的用户ID

285
00:14:02,010 --> 00:14:07,790
列自动递增，使每个
时间我想补充信息表，

286
00:14:07,790 --> 00:14:12,220
它会自动给我
对于主键的值。

287
00:14:12,220 --> 00:14:15,570
所以，我永远也不会忘记这样做，因为
数据库会为我做的。

288
00:14:15,570 --> 00:14:16,587
所以这是一种很好的。

289
00:14:16,587 --> 00:14:18,670
所以这就是为什么我们得到
12在那里，因为我

290
00:14:18,670 --> 00:14:21,772
设置列设置为自动递增。

291
00:14:21,772 --> 00:14:23,730
如果我加别人
这将会是13，如果我加入

292
00:14:23,730 --> 00:14:27,890
人家这将会是14，依此类推。

293
00:14:27,890 --> 00:14:30,190
>> 因此，让我们只是做一个更多的插入。

294
00:14:30,190 --> 00:14:34,530
我们会插入到妈妈表中，
特别是，用户名和母

295
00:14:34,530 --> 00:14:37,390
列，值
克莱默和巴布斯克雷默。

296
00:14:37,390 --> 00:14:39,140
因此，我们以前有这个。

297
00:14:39,140 --> 00:14:41,800
当我们执行该
SQL查询，我们有这个。

298
00:14:41,800 --> 00:14:47,290
我们增加了克莱默和巴布斯
克莱默向妈妈表。

299
00:14:47,290 --> 00:14:48,350
>> 所以这是插入。

300
00:14:48,350 --> 00:14:51,850
选择是我们用它来提取
从表中的信息。

301
00:14:51,850 --> 00:14:54,390
因此，这是我们如何得到
信息从数据库中。

302
00:14:54,390 --> 00:14:59,589
所以SELECT命令都将是
非常经常用于编程。

303
00:14:59,589 --> 00:15:02,130
一般framework--的
普通的骨架看起来是这样的。

304
00:15:02,130 --> 00:15:06,550
选择一组列
一个表，然后任选

305
00:15:06,550 --> 00:15:11,090
你可以指定一个condition--或
我们通常所说的谓语，

306
00:15:11,090 --> 00:15:13,010
通常我们在SQL中使用的术语。

307
00:15:13,010 --> 00:15:16,490
>> 但它基本上是什么
你要特别行获得。

308
00:15:16,490 --> 00:15:19,100
如果你想要的，而不是获取
一切，缩小它，

309
00:15:19,100 --> 00:15:20,060
这是在那里你会做到这一点。

310
00:15:20,060 --> 00:15:22,777
然后选择性地，你也可以
命令由一个特定的列。

311
00:15:22,777 --> 00:15:25,860
因此，也许你想拥有的东西排序
按字母顺序的基础上一列

312
00:15:25,860 --> 00:15:27,540
按字母顺序或基于另一个。

313
00:15:27,540 --> 00:15:30,610
>> 再次，WHERE和ORDER BY是可选的。

314
00:15:30,610 --> 00:15:32,681
但是，他们很可能会
useful--特别

315
00:15:32,681 --> 00:15:34,680
哪里会是有益的
缩小让你不

316
00:15:34,680 --> 00:15:37,460
让你的整个数据库背部和
必须处理它，你只得到

317
00:15:37,460 --> 00:15:39,300
它的作品，你所关心的。

318
00:15:39,300 --> 00:15:44,932
因此，举例来说，我可能要选择
从用户的ID号和全名。

319
00:15:44,932 --> 00:15:46,140
所以，什么才是这个样子呢？

320
00:15:46,140 --> 00:15:48,270
因此，这里是我的用户表。

321
00:15:48,270 --> 00:15:51,080
我想选择IDNUM
和全名的用户。

322
00:15:51,080 --> 00:15:52,300
我该怎么走？

323
00:15:52,300 --> 00:15:53,580
我要得到这一点。

324
00:15:53,580 --> 00:15:56,930
我并没有缩小它，所以我
获得的ID号的每一行

325
00:15:56,930 --> 00:16:00,850
而我得到的全部
从每列名。

326
00:16:00,850 --> 00:16:02,210
>> 好。

327
00:16:02,210 --> 00:16:05,640
如果我要选择密码
从用户WHERE--所以现在

328
00:16:05,640 --> 00:16:10,370
我加入一个条件，一个predicate--
其中IDNUM小于12。

329
00:16:10,370 --> 00:16:13,660
因此，这里是我的数据库再次，
我的用户表的顶部。

330
00:16:13,660 --> 00:16:17,030
我该怎么得到，如果我想
选择信息，密码，

331
00:16:17,030 --> 00:16:21,550
其中用户ID或IDNUM小于12？

332
00:16:21,550 --> 00:16:24,910
我要得到这
信息反馈，对不对？

333
00:16:24,910 --> 00:16:29,170
它发生IDNUM是10以下，
超过12，ID号11小于12。

334
00:16:29,170 --> 00:16:32,160
我得到的密码，这些行。

335
00:16:32,160 --> 00:16:33,914
这就是我要的。

336
00:16:33,914 --> 00:16:34,580
那这个呢？

337
00:16:34,580 --> 00:16:39,170
如果我要选择从星
妈妈表其中username等于杰里？

338
00:16:39,170 --> 00:16:43,780
OK，选择明星是特
排序外卡的所谓

339
00:16:43,780 --> 00:16:45,670
我们用它来搞定一切。

340
00:16:45,670 --> 00:16:48,620
所以他们说选择
用户名逗号的母亲，这

341
00:16:48,620 --> 00:16:51,060
碰巧是仅
两列此表，

342
00:16:51,060 --> 00:16:53,260
我可以选择星级
并得到一切

343
00:16:53,260 --> 00:16:55,030
其中，用户名等于杰里。

344
00:16:55,030 --> 00:16:59,380
所以这就是我会得到
如果我做了特定的查询。

345
00:16:59,380 --> 00:17:01,810
>> 现在，数据库
伟大的，因为他们允许

346
00:17:01,810 --> 00:17:06,074
我们也许是组织信息
多一点效率比我们

347
00:17:06,074 --> 00:17:06,740
否则可能会。

348
00:17:06,740 --> 00:17:10,240
我们并不一定存储
信息各相关件

349
00:17:10,240 --> 00:17:12,230
大约在同一表的用户。

350
00:17:12,230 --> 00:17:13,730
我们有两个表存在。

351
00:17:13,730 --> 00:17:15,734
>> 我们需要存储
每个人的母亲的名字，

352
00:17:15,734 --> 00:17:18,900
也许我们没有社会保障
数，我们有他们的出生日期。

353
00:17:18,900 --> 00:17:21,819
这并不总是需要
是在同一个表。

354
00:17:21,819 --> 00:17:25,339
只要我们可以定义
在tables--之间的关系

355
00:17:25,339 --> 00:17:28,440
而这也正是这关系
哪种数据库术语起源

356
00:17:28,440 --> 00:17:32,130
进入play--只要我们可以定义
表之间的关系，

357
00:17:32,130 --> 00:17:35,545
之类的，我们可以划分
或抽象事物的方式，

358
00:17:35,545 --> 00:17:37,670
在这里我们只有
真正重要的信息

359
00:17:37,670 --> 00:17:39,270
我们关心用户的表。

360
00:17:39,270 --> 00:17:43,220
然后我们有辅助信息
在其他表或额外的信息

361
00:17:43,220 --> 00:17:48,260
我们可以回到连接到主
用户表中的某个特定的方式。

362
00:17:48,260 --> 00:17:52,200
>> 所以在这里，我们有这两个表，但
有它们之间的关系，

363
00:17:52,200 --> 00:17:53,010
对？

364
00:17:53,010 --> 00:17:55,070
这似乎是用户名
可能是什么

365
00:17:55,070 --> 00:17:59,909
中存在之间的共同
这两个不同的表。

366
00:17:59,909 --> 00:18:01,700
那么，如果我们现在有
的情况下，我们

367
00:18:01,700 --> 00:18:06,046
希望从中获取用户的全名
用户的表，和他们的母亲

368
00:18:06,046 --> 00:18:07,170
从母亲表名？

369
00:18:07,170 --> 00:18:10,960
我们没有办法让
那样子，对不对？

370
00:18:10,960 --> 00:18:17,790
有不包含单个表
双方的全名和母亲的名字。

371
00:18:17,790 --> 00:18:20,400
我们没有这个选项
从我们到目前为止看到的。

372
00:18:20,400 --> 00:18:22,950
>> 因此，我们就来介绍
一个JOIN的想法。

373
00:18:22,950 --> 00:18:24,857
并加入可能
最complex--

374
00:18:24,857 --> 00:18:27,940
这真是最复杂的操作
我们要谈的视频。

375
00:18:27,940 --> 00:18:30,040
他们是有点复杂，
但一旦你得到了它的窍门，

376
00:18:30,040 --> 00:18:31,248
他们实际上是不是太糟糕。

377
00:18:31,248 --> 00:18:32,820
这只是一个选择的一个特例。

378
00:18:32,820 --> 00:18:37,120
我们要选择一组
加入从表中的列

379
00:18:37,120 --> 00:18:40,650
在一些谓词第二个表。

380
00:18:40,650 --> 00:18:45,340
>> 在这种情况下，考虑一下像this--
表一是一圈过来，

381
00:18:45,340 --> 00:18:47,530
表二是另一个圈子在这里。

382
00:18:47,530 --> 00:18:49,410
并说明上游部分
在中间，它的

383
00:18:49,410 --> 00:18:51,701
有点像，如果你认为
关于作为一个维恩图，是什么

384
00:18:51,701 --> 00:18:52,670
他们有什么共同点？

385
00:18:52,670 --> 00:18:55,960
我们想链接这两个表
根据他们的共同点

386
00:18:55,960 --> 00:19:01,230
创造这个假设的表
这是两人在一起的合并。

387
00:19:01,230 --> 00:19:03,480
所以我们会看到这一点的
例如，也许这会帮助

388
00:19:03,480 --> 00:19:04,521
它清除掉一点点。

389
00:19:04,521 --> 00:19:09,260
因此，也许你想选择
user.fullname和moms.mother

390
00:19:09,260 --> 00:19:13,220
从用户的加入，在
在任何情况下妈妈表

391
00:19:13,220 --> 00:19:16,790
其中username列
是它们之间的相同。

392
00:19:16,790 --> 00:19:19,240
这是一个新的
语法在这里，这个用户。

393
00:19:19,240 --> 00:19:20,460
和妈妈..

394
00:19:20,460 --> 00:19:26,697
如果我做多个表
在一起，我可以指定一个表。

395
00:19:26,697 --> 00:19:29,530
我可以在特定的区别
上在最底层那里。

396
00:19:29,530 --> 00:19:33,220
我可以区分用户名
用户表列

397
00:19:33,220 --> 00:19:36,010
从的username列
妈妈表，它是otherwise--

398
00:19:36,010 --> 00:19:38,070
如果我们刚才说的用户名等于
用户名，并没有真正

399
00:19:38,070 --> 00:19:38,970
意味着什么。

400
00:19:38,970 --> 00:19:41,440
我们想这样做，他们匹配。

401
00:19:41,440 --> 00:19:46,080
>> 所以，我可以指定表和
在壳体的情况列名

402
00:19:46,080 --> 00:19:48,370
哪里会不清楚
我在说什么。

403
00:19:48,370 --> 00:19:51,880
所以，这就是我做的有我
从这个表说此列，

404
00:19:51,880 --> 00:19:54,020
而且是非常明确的。

405
00:19:54,020 --> 00:19:56,810
所以，再一次，我选择
全名和母亲的名字

406
00:19:56,810 --> 00:20:00,950
从用户表连接在一起
在任何情况下的妈妈表

407
00:20:00,950 --> 00:20:05,960
在那里他们共享column--
它们共享该用户名的概念。

408
00:20:05,960 --> 00:20:08,580
>> 因此，这里是我们以前的表。

409
00:20:08,580 --> 00:20:12,210
这是我们的国家
数据库作为它存在现在。

410
00:20:12,210 --> 00:20:16,390
我们提取信息
这是开始。

411
00:20:16,390 --> 00:20:19,820
这是新的表格，我们要去
创建这些结合在一起。

412
00:20:19,820 --> 00:20:23,585
同时注意我们不突出
纽曼的行中的用户的表，

413
00:20:23,585 --> 00:20:25,960
我们不是在突出
克莱默的行中的妈妈表

414
00:20:25,960 --> 00:20:31,250
因为没有一个存在于
无论sets--两个表。

415
00:20:31,250 --> 00:20:36,260
>> 这是仅有一个共同的信息
它们之间是杰里的两个表中

416
00:20:36,260 --> 00:20:39,100
和gcostanza既是表。

417
00:20:39,100 --> 00:20:42,620
所以，当我们在SQL JOIN，我们
get--我们做真正得到这一点。

418
00:20:42,620 --> 00:20:44,830
这有点一个临时变量。

419
00:20:44,830 --> 00:20:47,330
这就像一个假设
合并这两个表中。

420
00:20:47,330 --> 00:20:49,930
实际上，我们得到的东西
这样，在

421
00:20:49,930 --> 00:20:54,730
我们在表合并在一起
它们在共同的信息。

422
00:20:54,730 --> 00:20:58,334
>> 所以请注意users.username
和moms.username列，

423
00:20:58,334 --> 00:20:59,250
它是完全一样的。

424
00:20:59,250 --> 00:21:01,820
这是信息
是来自用户的一致

425
00:21:01,820 --> 00:21:02,890
表和妈妈表。

426
00:21:02,890 --> 00:21:04,270
所以，我们合并在一起。

427
00:21:04,270 --> 00:21:06,919
我们丢弃的克莱默，因为他
在用户表中不存在，

428
00:21:06,919 --> 00:21:09,710
我们抛弃纽曼，因为
他没有在母亲表中存在。

429
00:21:09,710 --> 00:21:16,450
因此，这是假设合并
使用SELECT的JOIN操作。

430
00:21:16,450 --> 00:21:21,250
>> 然后，我们正在寻找的
用户的全名和用户的妈妈，

431
00:21:21,250 --> 00:21:24,999
因此，这是信息
我们会从整个查询

432
00:21:24,999 --> 00:21:26,040
我们用SELECT进行。

433
00:21:26,040 --> 00:21:28,873
因此，我们加入了表一起
我们提取这两列，

434
00:21:28,873 --> 00:21:31,610
所以，这就是我们会得到。

435
00:21:31,610 --> 00:21:33,370
但是SQL连接是一种复杂的。

436
00:21:33,370 --> 00:21:36,770
你可能不会做他们太多，
但只是有骨架的一些想法

437
00:21:36,770 --> 00:21:41,992
你可以用它来合并两个
表如果你一起需要。

438
00:21:41,992 --> 00:21:43,700
最后两个是一
简单一点我保证。

439
00:21:43,700 --> 00:21:48,040
所以在更新，我们可以使用UPDATE
改变表中的信息。

440
00:21:48,040 --> 00:21:53,880
一般格式是更新一些
表中，设置一些列的一些值

441
00:21:53,880 --> 00:21:55,540
WHERE一些谓词是满意的。

442
00:21:55,540 --> 00:21:57,850
因此，例如，我们可能要
更新用户表

443
00:21:57,850 --> 00:22:04,400
并设置密码亚达
亚达，其中ID号是10。

444
00:22:04,400 --> 00:22:06,400
>> 因此，在这种情况下，我们
更新用户表。

445
00:22:06,400 --> 00:22:08,275
ID号是10，用于
那里，第一行中，

446
00:22:08,275 --> 00:22:10,690
我们要更新
密码内容十分重要。

447
00:22:10,690 --> 00:22:12,170
所以这是会发生什么。

448
00:22:12,170 --> 00:22:13,628
这是非常简单的，对不对？

449
00:22:13,628 --> 00:22:17,990
这只是一个很简单的
修改该表。

450
00:22:17,990 --> 00:22:22,250
>> DELETE是我们用来操作
从表中删除的信息。

451
00:22:22,250 --> 00:22:24,817
DELETE FROM表WHERE
一些谓词是满意的。

452
00:22:24,817 --> 00:22:26,900
我们要从中删除
用户表例如

453
00:22:26,900 --> 00:22:28,254
其中，用户名是纽曼。

454
00:22:28,254 --> 00:22:31,420
你可能已经猜到了什么事情
在这里发生之后，我们执行的SQL

455
00:22:31,420 --> 00:22:35,790
查询，纽曼走了从表中。

456
00:22:35,790 --> 00:22:40,460
>> 因此，所有这些操作，因为我已经说过了，
是很容易做到在phpMyAdmin。

457
00:22:40,460 --> 00:22:43,020
这是一个非常友好的用户界面。

458
00:22:43,020 --> 00:22:45,930
但它确实需要手动操作。

459
00:22:45,930 --> 00:22:47,840
我们不想聘请手动操作。

460
00:22:47,840 --> 00:22:51,280
我们希望我们的节目
做到这一点对我们来说，对不对？

461
00:22:51,280 --> 00:22:53,190
因此，我们可能想要做的
这种编程方式。

462
00:22:53,190 --> 00:22:56,410
我们希望将SQL和有
别的东西，为我们做到这一点。

463
00:22:56,410 --> 00:23:02,710
>> 但是，我们已经看到，它允许
我们以编程方式做一些事情？

464
00:23:02,710 --> 00:23:03,690
我们已经看到了PHP的，对不对？

465
00:23:03,690 --> 00:23:05,760
它介绍了一些
动力到我们的节目。

466
00:23:05,760 --> 00:23:10,430
所以幸运的是，SQL和
PHP玩的很漂亮起来。

467
00:23:10,430 --> 00:23:13,230
有一个在PHP函数
称为查询，它都可以使用。

468
00:23:13,230 --> 00:23:15,870
你可以通过为
参数或参数

469
00:23:15,870 --> 00:23:19,210
查询一个SQL查询
您想执行。

470
00:23:19,210 --> 00:23:23,250
和PHP会做以您的名义。

471
00:23:23,250 --> 00:23:25,564
>> 所以，你已经接通后
用PHP数据库，

472
00:23:25,564 --> 00:23:26,980
有两大初选你这样做。

473
00:23:26,980 --> 00:23:29,230
有一种叫做MySQLi的
而一些所谓的PDO。

474
00:23:29,230 --> 00:23:31,063
我们不会进入一个巨大的
大量的细节那里。

475
00:23:31,063 --> 00:23:32,957
在CS50，我们使用PDO。

476
00:23:32,957 --> 00:23:34,790
您已经连接后
你的数据库，

477
00:23:34,790 --> 00:23:40,980
然后可以进行查询数据库
通过把查询作为参数

478
00:23:40,980 --> 00:23:42,730
到PHP函数。

479
00:23:42,730 --> 00:23:46,460
当你这样做，你存储
在关联数组结果集。

480
00:23:46,460 --> 00:23:50,290
>> 而且我们知道如何一起工作
关联数组在PHP。

481
00:23:50,290 --> 00:23:52,630
所以，我可能会说
像this-- $ results--

482
00:23:52,630 --> 00:23:55,470
这是在PHP--等于查询。

483
00:23:55,470 --> 00:23:57,660
和然后把里面的
查询功能参数

484
00:23:57,660 --> 00:24:00,130
那我传递查询
看起来像SQL。

485
00:24:00,130 --> 00:24:01,160
而事实上这是SQL。

486
00:24:01,160 --> 00:24:05,700
这是查询字符串，我会
喜欢在我的数据库中执行。

487
00:24:05,700 --> 00:24:09,250
>> 因此红色，这是PHP。

488
00:24:09,250 --> 00:24:11,890
这是SQL，我很
纳入PHP通过

489
00:24:11,890 --> 00:24:15,020
它的参数，查询功能。

490
00:24:15,020 --> 00:24:19,640
我想从选择全名
其中，用户ID号等于10。

491
00:24:19,640 --> 00:24:22,560
然后，也许以后我做到了这一点，
我可能会说这样的事情。

492
00:24:22,560 --> 00:24:25,550
我想打印出来的
消息谢谢登录。

493
00:24:25,550 --> 00:24:32,530
>> 我希望它interpolate--我想
插值$结果全名。

494
00:24:32,530 --> 00:24:36,280
所以，这就是我与该是如何工作的
我回来关联数组。

495
00:24:36,280 --> 00:24:39,730
$结果全称会
基本上结束了打印输出，

496
00:24:39,730 --> 00:24:42,870
感谢登录，杰里宋飞。

497
00:24:42,870 --> 00:24:46,570
这是全名
其中，IDNUM等于10。

498
00:24:46,570 --> 00:24:48,850
>> 所以我做的
是我now--我存储

499
00:24:48,850 --> 00:24:52,780
我的查询，我的查询结果
并导致一个关联数组，

500
00:24:52,780 --> 00:24:56,330
和全名是名
在专栏中，我渐渐的。

501
00:24:56,330 --> 00:25:01,010
所以这是我的钥匙插入结果
我想关联数组。

502
00:25:01,010 --> 00:25:05,930
所以感谢登录，$结果，
全名会打印出来，将继续坚持

503
00:25:05,930 --> 00:25:08,654
就在这些花间
牙套，杰里宋飞。

504
00:25:08,654 --> 00:25:11,820
我会想打印出的信息
感谢您登录杰里宋飞。

505
00:25:11,820 --> 00:25:16,652
>> 现在，我们可能不希望辛苦
代码之类的东西在，对吧？

506
00:25:16,652 --> 00:25:19,860
我们可能想要做类似打印
f，其中我们可以代替，也许

507
00:25:19,860 --> 00:25:22,443
收集不同的信息，
或者有查询过程

508
00:25:22,443 --> 00:25:23,370
不同的信息。

509
00:25:23,370 --> 00:25:27,920
因此查询时，查询功能有
排序换人的这一概念

510
00:25:27,920 --> 00:25:32,310
非常相似的打印˚F百分之小号
和百分比C，是问号。

511
00:25:32,310 --> 00:25:34,290
>> 我们可以使用问题
标志非常类似

512
00:25:34,290 --> 00:25:38,400
打印f以替代变量。

513
00:25:38,400 --> 00:25:44,120
因此，也许你的用户登录前，
和保存他们的用户ID号

514
00:25:44,120 --> 00:25:51,710
在$的PHP超_session
全球性的密钥ID。

515
00:25:51,710 --> 00:25:55,947
他们登录因此，也许以后，
你设置$ _SESSION ID等于10，

516
00:25:55,947 --> 00:25:58,280
从实例推断
我们只是在一秒钟前看到的。

517
00:25:58,280 --> 00:26:01,960
>> 所以，当我们真正执行
此查询的结果现在，

518
00:26:01,960 --> 00:26:08,440
它会插上10，或任何
在$ _SESSION ID值。

519
00:26:08,440 --> 00:26:10,790
所以，让我们来
有点更有活力。

520
00:26:10,790 --> 00:26:12,699
我们不是硬编码了的东西。

521
00:26:12,699 --> 00:26:14,490
我们保存信息
某处，然后

522
00:26:14,490 --> 00:26:18,924
我们可以再次使用这些信息来
排序概括了我们想做的事情，

523
00:26:18,924 --> 00:26:21,090
和公正的插件和变化
我们网页的行为

524
00:26:21,090 --> 00:26:26,489
基于什么用户的ID号码
实际上，他们已经登录后。

525
00:26:26,489 --> 00:26:28,530
它也可以，不过，
您的结果集

526
00:26:28,530 --> 00:26:30,840
可能包括多个行。

527
00:26:30,840 --> 00:26:33,990
在这种情况下，你有
arrays--的阵列

528
00:26:33,990 --> 00:26:35,334
关联数组的数组。

529
00:26:35,334 --> 00:26:37,000
而你只需要遍历它。

530
00:26:37,000 --> 00:26:41,950
而且我们知道如何遍历
通过在PHP中的数组，对不对？

531
00:26:41,950 --> 00:26:45,600
因此，这里可能是最
我们到目前为止看到的复杂的东西。

532
00:26:45,600 --> 00:26:49,640
它实际上是把
三种语言在一起。

533
00:26:49,640 --> 00:26:52,920
>> 在这里，在红，这是一些HTML。

534
00:26:52,920 --> 00:26:56,872
我显然starting--这是
一些HTML，我有一个片段。

535
00:26:56,872 --> 00:26:59,580
我开始一个新的段落
电视的宋飞的妈妈说。

536
00:26:59,580 --> 00:27:02,350
然后随即
我开始的表。

537
00:27:02,350 --> 00:27:06,060
并在那之后，我
有一些PHP的，对不对？

538
00:27:06,060 --> 00:27:08,229
我有这一切的PHP代码在那里。

539
00:27:08,229 --> 00:27:09,645
我显然会进行查询。

540
00:27:09,645 --> 00:27:14,180
而为了让查询，我要去
可以使用SELECT母亲们的妈妈。

541
00:27:14,180 --> 00:27:15,970
>> 因此，这是getting--这是SQL。

542
00:27:15,970 --> 00:27:17,300
所以蓝色是SQL。

543
00:27:17,300 --> 00:27:19,680
我们看到在一秒钟前，红色是HTML。

544
00:27:19,680 --> 00:27:21,360
在这里，绿色的是PHP。

545
00:27:21,360 --> 00:27:23,400
所以，我正在做一个查询
到我的数据库，我

546
00:27:23,400 --> 00:27:26,040
选择所有的
母亲在母亲表。

547
00:27:26,040 --> 00:27:30,710
不只是缩小它归结为特定的
行，我问了所有的人。

548
00:27:30,710 --> 00:27:33,290
>> 然后我检查，如果结果是
不等于等于false。

549
00:27:33,290 --> 00:27:37,410
这只是我的检查方式排序
如果结果不等于空，

550
00:27:37,410 --> 00:27:40,260
我们会看到下例子。

551
00:27:40,260 --> 00:27:44,000
基本上这只是检查，以
确保它实际上得到的数据备份。

552
00:27:44,000 --> 00:27:47,041
因为我不想开始打印
出的数据，如果我没有得到任何数据。

553
00:27:47,041 --> 00:27:50,690
然后为每个结果作为结果的
从PHP的foreach语法，我做的

554
00:27:50,690 --> 00:27:53,399
正在打印$结果母亲。

555
00:27:53,399 --> 00:27:55,940
所以我要得到一套
所有each--的母亲的

556
00:27:55,940 --> 00:27:59,980
它的关联数组
arrays--，我打印出

557
00:27:59,980 --> 00:28:03,649
每一个作为它自己的一个表中的行。

558
00:28:03,649 --> 00:28:05,690
而这真的很漂亮
很多都在那里给它。

559
00:28:05,690 --> 00:28:07,750
我知道有一点
位怎么回事

560
00:28:07,750 --> 00:28:13,210
在这个最后的例子与阵列
arrays--关联数组的数组。

561
00:28:13,210 --> 00:28:17,340
但它确实刚烧开
倒在SQL中，查询数据，

562
00:28:17,340 --> 00:28:21,102
通常选择后，我们已把
把信息到表，

563
00:28:21,102 --> 00:28:22,310
然后就拉出来。

564
00:28:22,310 --> 00:28:25,710
>> 这是我们把它
在这种特殊情况下。

565
00:28:25,710 --> 00:28:31,120
我们将提取所有个人
母亲从妈妈表。

566
00:28:31,120 --> 00:28:35,970
我们得到了一整套他们，而我们
要遍历并打印出

567
00:28:35,970 --> 00:28:37,630
每一个。

568
00:28:37,630 --> 00:28:40,510
如此反复，这可能是
最复杂的例子

569
00:28:40,510 --> 00:28:44,510
我们已经看到，因为我们是混合三种
不同的语言在一起，对不对？

570
00:28:44,510 --> 00:28:50,100
>> 同样，我们在这里的HTML红色，
一些SQL这里的蓝色混合，

571
00:28:50,100 --> 00:28:52,049
在绿一些PHP混合。

572
00:28:52,049 --> 00:28:53,840
但所有这些玩
很好地在一起，这是

573
00:28:53,840 --> 00:28:57,060
发展中的问题而已
良好的生活习惯，这样你可以得到

574
00:28:57,060 --> 00:28:58,780
他们你想要的方式一起工作。

575
00:28:58,780 --> 00:29:03,790
而只有这样，才能真正做到这一点
就是练习，练习，再练习。

576
00:29:03,790 --> 00:29:06,740
我是道格·劳埃德，这是CS50。

577
00:29:06,740 --> 00:29:08,647