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
మీరు ఈ ఇక్కడ ఉన్నారు తెలుసు
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
నేను మేము కలిగి జూమ్ చేస్తాము
ఒక షీట్ ఈ ఆలోచన.

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
ఒక అని పిలవబడే రిలేషనల్ డేటాబేస్
ఒక డేటాబేస్, ప్రభావవంతంగా.

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
ఒక 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-- చేయబోవడం
పట్టిక ఒకసారే, ఒకసారి డేటాబేస్ శాతం

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
మరియు డేటాబేస్ కంటే ప్రశ్నించడానికి
సాధారణంగా కేవలం జోడించడం లేదు,

97
00:04:49,580 --> 00:04:51,610
కానీ అన్నిటికీ మేము
అలా మేము వ్యవహరించే ఉంటాం

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-- వంటి ఆలోచనలు కలిగి
మేము బహుశా తెలిసిన పూర్ణ

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
>> TEXT ఉండవచ్చు, టెక్స్ట్ కేవలం దిగ్గజం blobs ఉంది.

126
00:06:11,390 --> 00:06:12,840
Enums రకమైన ఆసక్తికరమైన ఉంటాయి.

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
>> ఒక మంచి ఉదాహరణకు ఇక్కడ ఉంటుంది
ఒక 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
>> అప్పుడు మేము చార్ మరియు 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
కాబట్టి చార్ కాకుండా 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
>> ఈ ఉదాహరణలో,
మేము చార్ (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
No more, ఏ తక్కువ.

148
00:07:15,770 --> 00:07:21,780
మేము ప్రయత్నించండి మరియు ఒక 15 లో ఉంచితే కాబట్టి
bit లేదా 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
మేము రెండు చూడాలని
అక్షరాలు, ఆపై ఎనిమిది శూన్య గాట్లు.

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
మేము ఉండవచ్చు, 16 15 బైట్లు వుపయోగించాలి
శూన్య టెర్మినేటర్ బైట్లు.

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
Well, మేము ఎలా దొరుకుతుందని అవసరం ఉంటే
దీర్ఘ ఏదో ఒక VARCHAR తో ఉంది,

167
00:08:08,210 --> 00:08:10,680
మేము iterate యొక్క రకాన్ని కలిగి
ఇది కేవలం ఇష్టం అంతటా మేము సి లో చేసిన

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

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
మీరు గురించి చాలా ఆందోళన అవసరం లేదు
మీరు ఒక చార్ లేదా ఒక 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
మరియు ఉండవచ్చు రెండు వినియోగదారులు
అదే పేరు అనుకుందాం కలిగి

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
కాబట్టి బహుశా మీరు ఒక కలిగి
మరియు Bs అని కాలమ్,

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
కాబట్టి మీరు బహుళ, బహుళ కలిగి ఉండవచ్చు
Bs, చాలావాటికి, బహుళ తీయడం,

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
ఇది చాలా వంటి విస్తారమైన కాదు
సి మరియు 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
మరియు మీరు బహుశా intuitively అంచనా
ఈ అన్ని విషయాలను నాలుగు ఏమి.

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-- 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
>> ఇన్సర్ట్, అస్థిపంజరం కాబట్టి
రకమైన ఈ కనిపిస్తోంది.

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
యూజర్ పేరు, పాస్వర్డ్, మరియు FULLNAME.

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
FULLNAME కాలమ్ లోకి న్యూమాన్.

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
నేను వినియోగదారు పేరు చాలు అనుకున్నారు
పాస్వర్డ్, FULLNAME.

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
కాబట్టి బాలినేని ఆదేశాలను ఉంటాయని
చాలా తరచుగా ప్రోగ్రామింగ్ ఉపయోగిస్తారు.

303
00:14:59,589 --> 00:15:02,130
సాధారణ ఫ్రేమ్
సాధారణ అస్థిపంజరం ఈ కనిపిస్తోంది.

304
00:15:02,130 --> 00:15:06,550
నిలువు సమితి నుండి ఎంచుకోండి
ఒక పట్టిక, మరియు వైకల్పికంగా

305
00:15:06,550 --> 00:15:11,090
మీరు ఒక పరిస్థితి పేర్కొనవచ్చు లేదా
మేము సాధారణంగా ఒక ఆధారం కాల్ ఏమి,

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
>> మళ్ళీ, శాసనం ద్వారా వైకల్పికం ఎక్కడ మరియు.

314
00:15:30,610 --> 00:15:32,681
కానీ వారు బహుశా ఉంటాం
ఉపయోగకరంగా ముఖ్యంగా

315
00:15:32,681 --> 00:15:34,680
WHERE కు ఉపయోగకరంగా ఉంటుంది
మీరు లేదు కాబట్టి తగ్గించండి

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 సంఖ్య మరియు FULLNAME.

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
నేను దానిని తగ్గించండి లేదు, కాబట్టి నేను ఉన్నాను
ప్రతి వరుసలో కోసం 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
నేను నుండి స్టార్ ఎంచుకోండి ఉంటే
యూజర్పేరు జెర్రీ సమానం తల్లులు పట్టిక?

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
play-- కాలం మేము నిర్వచించలేదు వంటి లోకి
పట్టికలు మధ్య సంబంధాలు,

357
00:17:32,130 --> 00:17:35,545
మేము విధమైన compartmentalize చేయవచ్చు
లేదా నైరూప్య విషయాలను ఒక మార్గం,

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
తల్లి పట్టిక నుండి NAME?

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
మరియు చేరతాడు బహుశా ఉంటాయి
అత్యంత క్లిష్టంగా

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
>> అది ఈ వంటి గురించి ఈ సందర్భంలో, అనుకుంటున్నాను
పట్టిక ఒకటి, ఇక్కడ పైగా ఒక సర్కిల్

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
ఒక్కటీ ఒక లో ఉంది ఎందుకంటే
రెండిటి పట్టికలలో సెట్లు.

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 మనం
పొందుతారు మరియు మేము ఈ పొందండి వాస్తవానికి చేయడం.

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
కాబట్టి ఈ ఊహాత్మక విలీనం ఉంది
బాలినేని యొక్క చేరండి ఆపరేషన్ ఉపయోగించి.

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
మేము ఎంచుకోండి చేసిన.

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
సాధారణ ఫార్మాట్ UPDATE కొన్ని
పట్టిక, కొన్ని విలువ కొన్ని కాలమ్ సెట్

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
మరియు yada పాస్వర్డ్ను సెట్
ID నంబర్ 10 ఉన్న yada.

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
>> మేము ఉపయోగిస్తున్న ఆపరేషన్ తొలగించు
ఒక పట్టిక నుండి సమాచారాన్ని తొలగించండి.

451
00:22:22,250 --> 00:22:24,817
పట్టిక 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
కాబట్టి మేము చేయాలనుకుంటున్నారా ఉండవచ్చు
ఈ programmatically.

462
00:22:53,190 --> 00:22:56,410
మేము SQL పొందుపరచడానికి కావలసిన మరియు కలిగి
ఏదో మనకు దీన్ని.

463
00:22:56,410 --> 00:23:02,710
>> కానీ మనం అనుమతించే చూసిన
మాకు programmatically ఏదో చేయాలని?

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 ఎంచుకోండి
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-- కావలసిన
$ ఫలితాలు 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
>> కాబట్టి అన్ని నేను ఏమి చేస్తున్నానో
నేను ఇప్పుడు నేను నిల్వ ఉన్నాను

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
మేము ప్రింట్ వంటి ఏదో అనుకోవచ్చు
మేము ప్రత్యామ్నాయంగా మరియు బహుశా ఇక్కడ 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 చాలా పోలి
మరియు శాతం సి, ప్రశ్నార్థకాలుగా ఉంది.

511
00:25:32,310 --> 00:25:34,290
>> మరియు మేము ప్రశ్న ఉపయోగించవచ్చు
మార్కులు చాలా analogously

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 సూపర్ $ _ సెషన్ లో
కీ ID లో ప్రపంచ.

515
00:25:51,710 --> 00:25:55,947
వారు లాగిన్ కాబట్టి బహుశా తర్వాత,
మీరు ID 10 సమానం $ _ సెషన్ సెట్

516
00:25:55,947 --> 00:25:58,280
ఉదాహరణకు నుండి extrapolating
మేము కేవలం రెండవ క్రితం చూసింది.

517
00:25:58,280 --> 00:26:01,960
>> కాబట్టి మేము నిజంగా అమలు
ఈ, ఇప్పుడు ఫలితాలు ప్రశ్నించడానికి

518
00:26:01,960 --> 00:26:08,440
10, ప్లగ్ లేదా సంసార ఉంటుంది
$ _ సెషన్ 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
ఈ సందర్భంలో, మీరు కలిగి
శ్రేణుల యొక్క వ్యూహం

528
00:26:33,990 --> 00:26:35,334
సహయోగ శ్రేణుల యొక్క వ్యూహం.

529
00:26:35,334 --> 00:26:37,000
మరియు మీరు కేవలం అది ద్వారా iterate అవసరం.

530
00:26:37,000 --> 00:26:41,950
మరియు మేము iterate ఎలా తెలుసు
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
నేను ఒక కొత్త పేరా ఆ మొదలు వెబ్
TV యొక్క సీన్ఫెల్డ్ తల్లులు చెప్పారు.

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
మరియు ప్రశ్న తయారు, నేను వెళుతున్న
తల్లులు నుండి ఎంచుకోండి తల్లులు ఉపయోగించి.

541
00:27:14,180 --> 00:27:15,970
>> సో ఈ SQL ఉంది getting-- ఉంది.

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
ఈ విధమైన తనిఖీలకు కేవలం నా మార్గం
ఫలితాలు శూన్యం సమానం కాదు యొక్క,

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
ఇది సహయోగ యొక్క వ్యూహం ఉంది
శ్రేణుల మరియు నేను ముద్రించిన చేస్తున్నాను

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
శ్రేణితో ఈ గత ఉదాహరణకు
సహయోగ శ్రేణుల శ్రేణుల శ్రేణుల.

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
మేము వాటిని మొత్తం సెట్ వచ్చింది, మరియు మేము
ద్వారా iterate మరియు ముద్రించాలా కావలసిన

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