1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [SQL]

2
00:00:02,000 --> 00:00:04,000
[כריסטופר ברתולומיאו] [אוניברסיטת הרווארד]

3
00:00:04,000 --> 00:00:06,000
[זה CS50] [CS50 טלביזיה]

4
00:00:07,950 --> 00:00:11,620
אז, מתכנתים להשתמש במסדי נתונים ככלי לשמירה ולארגון

5
00:00:11,620 --> 00:00:13,620
הנתונים הקבועים שלנו בתוך טבלאות.

6
00:00:13,620 --> 00:00:18,960
זה אומר שהנתונים שלך מאוחסנים בחציונים בלתי נדיפים, כגון כונן קשיח,

7
00:00:18,960 --> 00:00:22,940
וגם כאשר המחשב כבוי, הנתונים עדיין לא נפגעו.

8
00:00:22,940 --> 00:00:29,530
וכמו מתכנתים, התוכניות שלנו לנצל את מאגרי מידע לתרחישים כגון אחסון

9
00:00:29,530 --> 00:00:32,890
מידע משתמש מטפסים באינטרנט, מחפש את המלאי,

10
00:00:32,890 --> 00:00:36,210
או עדכון מידע על מה שאתרים להציג.

11
00:00:37,150 --> 00:00:40,070
אבל איך אנחנו בעצם אינטראקציה עם מסד הנתונים שלנו,

12
00:00:40,070 --> 00:00:43,150
או מה אנחנו משתמשים לקריאה, לאחסן, למחוק,

13
00:00:43,150 --> 00:00:46,070
ולעדכן את הנתונים שלנו בתוך טבלאות מסד נתונים אלה?

14
00:00:47,280 --> 00:00:49,700
ובכן, התשובה היא שאנו משתמשים בסוג מיוחד של שפת מסד נתונים

15
00:00:49,700 --> 00:00:53,400
שאינטראקציה ישירות עם טבלאות מסד הנתונים שלנו.

16
00:00:53,400 --> 00:00:56,740
שמה של שפת שאילתות מובנית,

17
00:00:56,740 --> 00:00:58,740
[שפת שאילתות מובנית]

18
00:00:58,740 --> 00:01:00,740
או מה שאני מכנה SQL.

19
00:01:00,740 --> 00:01:05,100
>> עכשיו, [Se-Quel], או SQL, היא לא שפת תכנות,

20
00:01:05,100 --> 00:01:08,580
אבל במקום זה, זה שפה שמספקת ערכה סטנדרטית של פקודות

21
00:01:08,580 --> 00:01:13,520
כדי לאחזר ולטפל בנתונים ממגוון מערכות ניהול מסדי נתונים.

22
00:01:13,520 --> 00:01:17,630
לצורך CS50, תלכו על פני ארבע פקודות בסיסיות:

23
00:01:17,630 --> 00:01:21,210
בחר, להוסיף, לעדכן ולמחוק.

24
00:01:21,210 --> 00:01:26,230
יתר על כן, אנו לנצל ממשק אינטרנט אתר בשם phpMyAdmin,

25
00:01:26,230 --> 00:01:29,890
שמותקן במכשיר כדי לכתוב משפטי SQL שלנו.

26
00:01:30,830 --> 00:01:33,050
לכן, כדי לעזור לך לזכור פקודות אלה,

27
00:01:33,050 --> 00:01:37,080
אני הבאתי עוגות בארון כדי לסייע בתרחישים שלנו.

28
00:01:39,650 --> 00:01:42,210
תגיד יש לך מסד נתונים של הקאפקייקס,

29
00:01:42,210 --> 00:01:44,490
בו תוכל לשמור את כל המידע על העוגות שלך.

30
00:01:44,490 --> 00:01:48,220
עכשיו, מסדי נתונים יכולים להכיל טבלאות רבות

31
00:01:48,220 --> 00:01:50,950
והלוחות עצמם יכולים להכיל הרבה עמודים.

32
00:01:50,950 --> 00:01:57,020
במאגר של הקאפקייקס שלנו, יש לנו טבלה בשם cupcake_cupboard.

33
00:01:57,020 --> 00:02:00,500
טבלה זו תשמש לאחסון כל המידע על קאפקייקס

34
00:02:00,500 --> 00:02:02,990
שהם, ובכן, בארון שלך.

35
00:02:02,990 --> 00:02:07,770
העמודות הנמצאות בתוך השולחן שלך מייצגות את התכונות של הקאפקייקס.

36
00:02:07,770 --> 00:02:14,560
לדוגמה, העמודות של cupcake_cupboard הן

37
00:02:14,560 --> 00:02:15,920
עוגת זהות, CakeType, CakeColor, וCakeIsNice.

38
00:02:15,920 --> 00:02:23,040
טור וליאני-מוקלד זה משמש כדי לקבוע אם העוגה היא יפה או לא יפה.

39
00:02:23,040 --> 00:02:26,560
אנחנו הולכים להתחיל לכתוב משפט בחירה.

40
00:02:26,560 --> 00:02:32,160
הצהרות בחרו משמשות לאחזור נתונים מטבלת מסד נתונים מסוימת.

41
00:02:32,160 --> 00:02:34,890
בתרחיש זה, אנחנו רוצים לדעת הכל

42
00:02:34,890 --> 00:02:39,080
על כל העוגות שקיימות בארון שלנו.

43
00:02:39,080 --> 00:02:48,670
התחביר כדי לעשות זאת הוא כוכב "בחר" בחלל, או *, שטח משטח השולחן שלנו,

44
00:02:48,670 --> 00:02:52,050
אשר cupcake_cupboard.

45
00:02:52,050 --> 00:02:54,640
בואו נלך קדימה ולבצע את זה.

46
00:02:56,670 --> 00:03:00,140
>> כפי שניתן לראות, כל אלה הם העוגות בארון שלנו.

47
00:03:00,140 --> 00:03:05,110
חשוב לציין ש*, או כוכבי, היא דמות ג'וקר

48
00:03:05,110 --> 00:03:08,830
שמציין את ההתכנסות של כל העמודות של טבלה כלשהי.

49
00:03:08,830 --> 00:03:13,650
בדרך כלל, אנו יכולים לגשת לעמודה או עמודות ספציפיות

50
00:03:13,650 --> 00:03:16,950
על ידי החלפה * עם שם העמודה בפועל.

51
00:03:16,950 --> 00:03:21,220
אם אנו רוצים עמודות מרובות, אבל לא כולם, אנחנו יכולים להשיג את זה

52
00:03:21,220 --> 00:03:25,620
על ידי כתיבת שמות העמודות התוחמים כל עמודה בפסיק.

53
00:03:25,620 --> 00:03:28,620
לדוגמה, בואו לאחזר CakeId וCakeType בטבלת cupcake_cupboard בלבד.

54
00:03:28,620 --> 00:03:38,370
התחביר כדי לעשות את זה הוא: פסיק CakeID חלל SELECT

55
00:03:38,370 --> 00:03:44,370
מרחב CakeType מהשולחן, cupcake_cupboard.

56
00:03:44,370 --> 00:03:46,370
בואו נלך קדימה ולבצע את זה.

57
00:03:49,340 --> 00:03:52,670
והנה, עכשיו יש לנו שתי עמודות המפורטים בלבד

58
00:03:52,670 --> 00:03:54,670
לכל הקאפקייקס בארון שלנו.

59
00:03:54,670 --> 00:03:57,710
אנחנו גם יכולים לחדד את תוצאות השאילתות שלנו על ידי ציון

60
00:03:57,710 --> 00:04:00,910
"איפה" סעיף רק אחרי שם הטבלה.

61
00:04:02,000 --> 00:04:05,410
לדוגמה, נראה שיש עוגה בארון שלנו

62
00:04:05,410 --> 00:04:08,660
כי הוא, ובכן, לא כל כך נחמד להסתכל.

63
00:04:08,660 --> 00:04:13,950
בואו להבין את כל העוגות בארון שלנו שהם, ובכן, לא כל כך נחמדים מחפשים

64
00:04:13,950 --> 00:04:16,110
באמצעות "איפה" סעיף.

65
00:04:16,110 --> 00:04:26,390
התחביר כדי לעשות את זה הוא: חלל * החלל בחר מcupcake_cupboard החלל

66
00:04:26,390 --> 00:04:34,080
מרחב שבו מרחב העמודה מותנה שלנו, במקרה זה CakeIsNice =,

67
00:04:34,080 --> 00:04:36,900
והערך בוליאני של שקר.

68
00:04:36,900 --> 00:04:42,750
חשוב לציין שאם אתה משתמש במחרוזות, יש לתחום אותו במרכאות בודדות.

69
00:04:42,750 --> 00:04:49,620
זה נכון לכל המחרוזות בSQL, או, במונחי מסד נתוני SQL, תווי חלופה

70
00:04:49,620 --> 00:04:51,620
מכונה varchar datatype.

71
00:04:51,620 --> 00:04:57,660
במקרה זה, אנו משתמשים אמת או שקר, שהוא ערך בוליאני ולא מחרוזת.

72
00:04:59,120 --> 00:05:00,660
בואו נלך קדימה ולבצע פקודה זו.

73
00:05:00,660 --> 00:05:05,340
>> והנה, זה המקרה שיש לנו שוקולד 1

74
00:05:05,340 --> 00:05:07,920
לא כל כך נחמד הקאפקייקס בארון שלנו.

75
00:05:09,620 --> 00:05:11,460
בשלב בא, אנחנו הולכים לכתוב משפט INSERT.

76
00:05:11,460 --> 00:05:15,560
הצהרות הכניסו משמשות להוספה או להוסיף

77
00:05:15,560 --> 00:05:17,770
שורות נוספות של נתונים לתוך הטבלה במסד הנתונים שלך.

78
00:05:17,770 --> 00:05:23,160
בחינה מחדש התרחיש שלנו, בואו נניח שאנחנו פשוט עשינו הקאפקייקס מותג חדש.

79
00:05:25,910 --> 00:05:30,080
מאז אנחנו מאוד מאורגנים אוכלי cupcake, אנחנו הולכים לצריכים להכניס הקאפקייקס החדש

80
00:05:30,080 --> 00:05:32,330
בטבלת cupcake_cupboard.

81
00:05:32,330 --> 00:05:40,690
התחביר כדי לעשות זאת הוא זו: הכנס מרחב לתוך שטח השולחן שלנו,

82
00:05:40,690 --> 00:05:46,830
cupcake_cupboard, שטח (,

83
00:05:46,830 --> 00:05:51,060
וכאן אנו מציינים את שמות עמודות, מופרד באמצעות פסיק,

84
00:05:51,060 --> 00:05:59,790
פסיק פסיק CakeIsNice) חלל CakeColor CakeType.

85
00:05:59,790 --> 00:06:06,540
בעקבות זאת, אנו כותבים את מילת מרחב הערכים (וכאן

86
00:06:06,540 --> 00:06:12,170
אנחנו נכנסים הערך עבור כל עמודת בהתאמה, גם מופרדים באמצעות פסיק.

87
00:06:12,170 --> 00:06:17,830
ציטוט אחד, כי הם כל ערכי varchar אנחנו מקיפים אותם בגרשיים בודדים,

88
00:06:17,830 --> 00:06:26,780
הפסיק 'הפסיק' חמאת בוטני החום הבהיר האמיתי.

89
00:06:26,780 --> 00:06:30,480
עכשיו, זה חשוב לתת לכל שורה מספר ייחודי המזהה את עצמו.

90
00:06:30,480 --> 00:06:33,660
Autoincrementing טור מספק זה כ

91
00:06:33,660 --> 00:06:37,410
 "אין שתי תעודות זהות אי פעם יכולות להתקיים בטבלה זו."

92
00:06:37,410 --> 00:06:39,480
בואו נלך קדימה ולבצע.

93
00:06:39,480 --> 00:06:45,380
הנה זה בא, כל מאורגן.

94
00:06:49,720 --> 00:06:52,100
>> משפט SQL הבא שאנחנו נכתוב הוא הצהרת עדכון.

95
00:06:52,100 --> 00:06:55,650
הצהרת העדכון ניתן להשתמש כדי לשנות את הנתונים בעמודה

96
00:06:55,650 --> 00:06:58,440
עבור כל שורה קיימת בטבלה במסד הנתונים שלך.

97
00:06:59,670 --> 00:07:03,420
מוקדם יותר בתרחיש שלנו, תוך שימוש במשפט בחירה, זיהה הקאפקייקס

98
00:07:03,420 --> 00:07:08,300
בתוך השולחן שלנו cupcake_cupboard ערך CakeIsNice היה שקר.

99
00:07:08,300 --> 00:07:12,050
בואו נניח שבעוד הקאפקייקס חמאת הבוטנים שלנו היה בתנור,

100
00:07:12,050 --> 00:07:15,790
עשינו הקאפקייקס לא כל כך נחמד שלנו מאוד נחמד.

101
00:07:18,020 --> 00:07:22,240
להיות כל כך מאורגן במיוחד, אנחנו רוצים הקאפקייקס שלנו כדי לשקף ערך זה

102
00:07:22,240 --> 00:07:24,240
בטבלת cupcake_cupboard.

103
00:07:24,240 --> 00:07:28,710
לכן, בואו לעדכן הקאפקייקס השוקולד שלנו במסד הנתונים כדי לשקף את זה.

104
00:07:28,710 --> 00:07:39,720
התחביר הוא: חלל UPDATE שולחננו, cupcake_cupboard, מרחב SET חלל

105
00:07:39,720 --> 00:07:44,240
הטור שאנחנו רוצים לשנות, CakeIsNice =.

106
00:07:44,240 --> 00:07:49,210
אז הנה אנחנו במקום חלל הערך האמיתי החדש שלנו.

107
00:07:49,210 --> 00:07:54,290
עכשיו, בגלל שאנחנו לא רוצים לעדכן את כל השורות עם ערך זה,

108
00:07:54,290 --> 00:07:57,400
אנו רוצים לספק "איפה" סעיף שיגרום להם להתרכז

109
00:07:57,400 --> 00:07:59,830
לשורה המדויקת שברצונך לשנות.

110
00:07:59,830 --> 00:08:03,690
במקרה זה, אנחנו יודעים שיש רק מאפיין אחד

111
00:08:03,690 --> 00:08:06,670
שיש לו ערך CakeIsNice של שקר.

112
00:08:06,670 --> 00:08:11,030
יתר על כן, אנו גם להבטיח כי אנו מעדכנים את השורה הנכונה

113
00:08:11,030 --> 00:08:13,030
באמצעות "והסעיף".

114
00:08:14,340 --> 00:08:17,270
אנו משתמשים "וסעיף" כדי לחדד השאילתה שלנו עוד יותר.

115
00:08:17,270 --> 00:08:20,380
במקרה זה, משום שאנו יודעים כי הקאפקייקס הוא שוקולד,

116
00:08:20,380 --> 00:08:23,160
אנו נשתמש בעמודת CakeType זה.

117
00:08:23,160 --> 00:08:31,500
שבו שטח החלל שלנו מותנה עמודת חלל CakeIsNice = שקר,

118
00:08:31,500 --> 00:08:38,330
ו 'שוקולד'. חלל CakeType =

119
00:08:38,330 --> 00:08:41,880
לכן, לשים את הכל ביחד, הצהרת עדכון זה אומרת

120
00:08:41,880 --> 00:08:44,670
למצוא את כל העוגות בארון הקאפקייקס שלנו,

121
00:08:44,670 --> 00:08:50,520
ואם יש עוגה שהטור שלו CakeIsNice מכיל את ערך False

122
00:08:50,520 --> 00:08:54,130
וCakeType מכיל שוקולד הערך,

123
00:08:54,130 --> 00:08:58,240
אנחנו רוצים לעדכן את ערך CakeIsNice שורות הספציפיות לנכון.

124
00:08:58,240 --> 00:09:01,140
אז, בואו נלך קדימה ולהוציא לפועל את ההצהרה.

125
00:09:03,860 --> 00:09:05,860
ועכשיו, אנחנו מאורגנים.

126
00:09:06,650 --> 00:09:09,220
>> כל הדיבורים האלה של עוגות הפכו אותי קצת רעבים.

127
00:09:09,220 --> 00:09:11,360
אני חושב שאני צריך לעזור לעצמי אחד.

128
00:09:11,360 --> 00:09:17,670
אבל אם אני באמת אוכל העוגה הזאת, אני צריך לפחות גם להסיר את קיומה

129
00:09:17,670 --> 00:09:19,670
 משולחן cupcake_cupboard.

130
00:09:20,650 --> 00:09:22,590
כדי לעשות זאת, אנו נשתמש בהצהרה "מחק".

131
00:09:22,590 --> 00:09:27,400
ההצהרה "מחק" ניתן להשתמש כדי להסיר את כל או חלק משורות בטבלה.

132
00:09:27,400 --> 00:09:29,920
אם ברצונך להסיר חלק מהשורה ספציפית בטבלה,

133
00:09:29,920 --> 00:09:34,360
אז אתה חייב לספק סעיף "איפה", ובכך לציין עמודה

134
00:09:34,360 --> 00:09:37,660
שצריך להיות ייחודיים לשורה שברצונך להסיר.

135
00:09:37,660 --> 00:09:47,370
זה תחביר: DELETE חלל; השולחן, cupcake_cupboard, המרחב שלנו.

136
00:09:47,370 --> 00:09:51,760
עכשיו, בשלב זה, כל פעם שאתה כל כך רחוק בהצהרת המחיקה שלך

137
00:09:51,760 --> 00:09:54,240
אתה רוצה להיות זהיר מאוד.

138
00:09:54,240 --> 00:09:59,970
לדוגמה, אם אני רוצה להריץ שאילתא זה כמו שהוא ללא מתן חלק "איפה" סעיף

139
00:09:59,970 --> 00:10:04,500
אני אאבד את כל הנתונים בטבלת cupcake_cupboard זה,

140
00:10:04,500 --> 00:10:09,590
אלא משום שאני כבר יודע שתעודות הזהות של העוגה שלי הן ייחודיות, אני אשתמש

141
00:10:09,590 --> 00:10:12,410
זיהוי הקטיפה האדום עוגה לסעיף של "איפה".

142
00:10:14,550 --> 00:10:20,670
שבו שטח הטור שלנו, CakeID 1 =.

143
00:10:20,670 --> 00:10:25,010
בגלל זה הוא ערך שלם שאין צורך להקיף אותו במרכאות בודדות.

144
00:10:25,010 --> 00:10:27,020
אז, בואו להפעיל את המשפט.

145
00:10:33,560 --> 00:10:35,990
ובכן, עכשיו שאנחנו כבר נגבנו את קיומו של הקאפקייקס זה

146
00:10:35,990 --> 00:10:40,360
משולחן cupcake_cupboard, יש לנו דבר אחד שמאל בלבד:

147
00:10:41,680 --> 00:10:43,680
לגרום לזה להיעלם.

148
00:10:43,680 --> 00:10:46,990
אני כריסטופר רתולומיאו. זה CS50.