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
דאג LLOYD: בקטעי הווידאו שלנו
בנושאי פיתוח האינטרנט,

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
או גיליונות אלקטרוניים של Google.

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 או Google

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
אתה יודע כי אלה הם כאן
1 rows--, 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
אולי יש לי ספר 2 וספר 3.

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
database-- יחסי שנקרא
מסד הנתונים, בצורה יעילה.

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,

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--
פעם אחת לכל שולחן, פעם בdatabase--

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
אולי השם של משתמש ותאריך לידה,
סיסמא, מספר זיהוי משתמש, ואולי

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
אולי אנחנו צריכים שמונה בתים, וכדי ש
ניתן להשתמש בוריאציות אלה במספרים שלמים

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
אנחנו יכולים לעשות את הגיאומטריות וLineStrings.

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
Enums הן סוג מעניינת של.

127
00:06:12,840 --> 00:06:16,080
הם קיימים בפועל בג אנחנו לא
לדבר עליהם, כי הם לא

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
>> דוגמא ממש טובה כאן תהיה
כדי ליצור enum בי שבע

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
אנחנו הולכים יש שני
דמויות, ולאחר מכן שמונה עקיצות null.

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
בתים עבור שליחות קטלנית null.

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
לא רוצה שני משתמשים ש
יש את אותו מספר זיהוי המשתמש.

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
אבל יש לנו מספר זיהוי משתמש אחד בלבד
10, משתמש אחד זיהוי מספר 11, 12, 13.

199
00:09:40,766 --> 00:09:42,640
אין לנו שני משתמשים
עם אותו המספר,

200
00:09:42,640 --> 00:09:46,010
ואז אולי מספרי זיהוי המשתמש
יהיה מפתח ראשי טוב.

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
אז אולי יש לך אחד
טור זה וכארוחת בוקר,

211
00:10:16,410 --> 00:10:19,290
עמודה אחת זה אחד, שתיים,
ושלושה, אבל אתה היחיד שאי פעם

212
00:10:19,290 --> 00:10:23,660
יש לי A1 בודד, בודד
A2, וכן הלאה וכן הלאה.

213
00:10:23,660 --> 00:10:28,980
אבל אולי יש לך B2,
C2, או 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
יש לנו משתמשי שולחן נקרא שיש
ארבעה columns-- מספר תעודת זהות, שם משתמש,

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, ושמו המלא ההון N

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
אני לא אמרתי שאני רוצה
לשים את מספר תעודת זהות לשם.

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
כמו שאמרתי, מספר תעודת זהות.

273
00:13:16,510 --> 00:13:18,718
זה לא תמיד בהכרח
הולך להיות מספר תעודת זהות,

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
>> וכך, ככל הנראה, מה שעשיתי
כאן מוגדר זיהוי המשתמש

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
SELECT הוא מה שאנחנו משתמשים כדי לחלץ
מידע מהשולחן.

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
>> שוב, איפה ו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
כך למשל, אולי אני רוצה לבחור
מספר תעודת זהות ושם מלא ממשתמשים.

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
וFULLNAME ממשתמשים.

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
אני לא לצמצם אותה, ולכן אני
מקבל מספר תעודת זהות לכל שורה

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
שבו זיהוי משתמש או idnum הוא פחות מ 12?

332
00:16:21,550 --> 00:16:24,910
אני הולך לקבל את זה
מידע בחזרה, נכון?

333
00:16:24,910 --> 00:16:29,170
זה קורה כי idnum הוא 10, פחות
מ -12, מספר תעודת זהות 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
מה אם אני רוצה לבחור כוכב מ
שולחן אמהות שבו שם משתמש שווה ג'רי?

338
00:16:39,170 --> 00:16:43,780
אישור, כוכב נבחרים הוא מיוחד
סוג של כרטיס פראי שנקרא

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
ללנגן-- כל עוד אנו יכולים להגדיר
יחסים בין השולחנות,

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
>> ולכן אנחנו צריכים להציג
הרעיון של הצטרפות.

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
זה רק מקרה מיוחד של SELECT.

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
>> במקרה זה, יחשוב על זה ככה זה--
שולחן אחד הוא מעגל אחד לכאן,

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
שם עמודת שם המשתמש
הוא אותו ביניהם.

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
מעמודת שם המשתמש של
שולחן אמהות, שהם 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 הצטרפות, מה ש
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
אז זה המיזוג היפותטי
באמצעות פעולת JOIN של SELECT.

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
אז עדכון, אנו יכולים להשתמש בעדכון
כדי לשנות מידע בטבלה.

440
00:21:48,040 --> 00:21:53,880
הפורמט הכללי הוא עדכון מסוים
שולחן, להגדיר כמה עמודת ערך כלשהו

441
00:21:53,880 --> 00:21:55,540
שבו כמה נשוא הוא מרוצה.

442
00:21:55,540 --> 00:21:57,850
כך למשל, אנו עשויים רוצים
כדי לעדכן את שולחן המשתמשים

443
00:21:57,850 --> 00:22:04,400
ולהגדיר את הסיסמה לבלה
בלה, שבו מספר תעודת הזהות הוא 10.

444
00:22:04,400 --> 00:22:06,400
>> אז במקרה הזה, אנחנו
עדכון שולחן המשתמשים.

445
00:22:06,400 --> 00:22:08,275
מספר תעודת הזהות הוא 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 משולחן שבו
כמה נשוא הוא מרוצה.

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
אז אני יכול להגיד משהו
כמו זה-- $ 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
אני רוצה לבחור fullname מ
משתמשים בי מספר תעודת זהות שווה 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--
לשרבב fullname תוצאות $.

494
00:24:32,530 --> 00:24:36,280
ואז זה איך אני עובד עם ש
מערך אסוציאטיבי שחזרתי.

495
00:24:36,280 --> 00:24:39,730
$ Fullname התוצאות היית
בעצם בסופו של הדפסה החוצה,

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
וfullname הוא שמו של
הטור שאני מקבל ל.

501
00:24:56,330 --> 00:25:01,010
אז זה המפתח שלי לתוצאות
מערך אסוציאטיבי שאני רוצה.

502
00:25:01,010 --> 00:25:05,930
אז תודה על כניסה, תוצאות $,
fullname יהיה להדפיס, ידבק

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
אנחנו אולי רוצים לעשות משהו כמו הדפסה
ו, שבו אנחנו יכולים להחליף ואולי

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 אחוזים של
ואחוזים ג, הוא סימני שאלה.

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
אז אולי המשתמש שלך מחובר קודם לכן,
ואתה הצלת את מספר תעודת הזהות של המשתמש שלהם

514
00:25:44,120 --> 00:25:51,710
ב_session $ של סופר PHP
עולמי בזיהוי המפתח.

515
00:25:51,710 --> 00:25:55,947
אז אולי אחרי שהם מחוברים,
אתה מגדיר _session $ מספר שווה 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 $ הוא.

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
על סמך מה מספר תעודת הזהות של המשתמש
למעשה הוא אחרי שהם מחוברים.

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
>> אז אני בודק אם תוצאה היא
לא שווים שווה שווא.

549
00:27:33,290 --> 00:27:37,410
זוהי רק הדרך של בדיקת סוג שלי
אם תוצאות שלו לא שווה ל null,

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
אז לכל תוצאות כתוצאה
תחביר foreach מPHP, כל מה שאני עושה

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