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

2
00:00:02,000 --> 00:00:04,000
[క్రిస్టోఫర్ BARTHOLOMEW] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,000 --> 00:00:06,000
[ఈ CS50 IS] [CS50 TV]

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
ఇది మీ డేటా అనగా హార్డ్ డ్రైవ్ వంటి కాని అస్థిర medians నిల్వ దీని అర్థం

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
Well, సమాధానం మేము డేటాబేస్ భాష యొక్క ఒక ప్రత్యేక రకం ఉపయోగించే ఉంది

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
>> ఇప్పుడు, [సే-క్వెల్], లేదా 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
కేక్ ID, 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
కామాతో ద్వారా ప్రతి కాలమ్ delimiting కాలమ్ పేర్లు వ్రాయడం ద్వారా.

53
00:03:25,620 --> 00:03:28,620
ఉదాహరణకు, యొక్క మాత్రమే cupcake_cupboard పట్టికలో CakeId మరియు CakeType తిరిగి తెలియజేయండి.

54
00:03:28,620 --> 00:03:38,370
దీన్ని వాక్యనిర్మాణం: ఎంపిక స్పేస్ CakeID కామా

55
00:03:38,370 --> 00:03:44,370
మా పట్టిక, cupcake_cupboard నుండి CakeType స్పేస్.

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
స్పేస్ WHERE ఈ కేసులో జాగా మా నియత కాలమ్, 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 డేటాబేస్ పరంగా, variant అక్షరాలు

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
తరువాత, మేము ఒక చొప్పించు ప్రకటన ఎలా రాయాలో చేస్తున్నారు.

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
మేము చాలా కప్ కేక్ తినేవాళ్ళు నిర్వహిస్తారు నుండి, మేము ఈ కొత్త కప్ కేక్ ఇన్సర్ట్ చెయ్యడానికి చూడాలని

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
CakeType కామా CakeColor CakeIsNice కామా) స్పేస్.

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
పీనట్ బట్టర్ 'కామాతో లైట్ BROWN' కామాతో ట్రూ.

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
 "నో రెండు అదే ID లు ఎప్పుడూ ఈ పట్టిక లో ఉండవచ్చు."

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 విలువ FALSE ఉంది.

99
00:07:08,300 --> 00:07:12,050
యొక్క మా శనగ వెన్న కప్ కేక్ ఓవెన్ ఉండగా భావిస్తాయి లెట్

100
00:07:12,050 --> 00:07:15,790
మేము మా అంతగా లేని nice కప్ కేక్ మంచిపని చేశారు.

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 = 'CHOCOLATE.'

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 ఫాల్స్ విలువ కలిగి ఒక కప్ కేక్ లేకపోతే

122
00:08:50,520 --> 00:08:54,130
మరియు CakeType, విలువ CHOCOLATE కలిగి

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
ఈ వాక్యనిర్మాణం: మా పట్టిక, 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
నా "ఎక్కడ" నిబంధన, Red వెల్వెట్ కేక్ ID.

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
Well, ఇప్పుడు మేము ఈ కప్ కేక్ యొక్క ఉనికి బలిగొంది చేసిన

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
నేను క్రిస్టోఫర్ BARTHOLOMEW ఉన్నాను. ఈ CS50 ఉంది.