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

2
00:00:02,000 --> 00:00:04,000
[CHRISTOPHER BARTHOLOMEW] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,000 --> 00:00:06,000
[ಈ CS50 IS] [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
>> ಈಗ [ಸೆ-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 ಹೇಳಿಕೆಗಳನ್ನು ಬರೆಯಲು APPLIANCE ಸ್ಥಾಪಿಸಿದ.

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
ಚಿಹ್ನೆಗಳಿಂದ ಪ್ರತಿ ಕಾಲಮ್ ಗಡಿಗುರುತಿಸುವಿಕೆಯ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಬರೆಯುವ ಮೂಲಕ.

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
ಬಾಹ್ಯಾಕಾಶ ಇಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ ಬಾಹ್ಯಾಕಾಶ ನಮ್ಮ ಷರತ್ತುಬದ್ಧ ಕಾಲಮ್, 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
ನಂತರ, ನಾವು ಒಂದು ಇನ್ಸರ್ಟ್ ಹೇಳಿಕೆಯನ್ನು ಬರೆಯಲು ನೀನು.

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
ಕಡಲೆಕಾಯಿ ಬೆಣ್ಣೆ 'ಅಲ್ಪವಿರಾಮ' ತಿಳಿ ಕಂದು 'ಅಲ್ಪವಿರಾಮ ಟ್ರೂ.

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
's ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಅವಕಾಶ.

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
ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೊಂದಿದೆ: ಅಪ್ಡೇಟ್ ಸ್ಥಳವನ್ನು ನಮ್ಮ ಟೇಬಲ್, cupcake_cupboard, ಸ್ಥಳವನ್ನು ಹೊಂದಿಸಿ ಸ್ಪೇಸ್

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 ತಪ್ಪಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ ಒಂದು ಕಪ್ಕೇಕ್ ಇದ್ದರೆ

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
ಈ ವಾಕ್ಯ ಹೊಂದಿದೆ: ನಮ್ಮ ಟೇಬಲ್, cupcake_cupboard, ಬಾಹ್ಯಾಕಾಶ ಸ್ಥಳದಿಂದ ಜಾಗ DELETE.

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
ನನ್ನ "ಎಲ್ಲಿ" ಷರತ್ತು ಕೆಂಪು ವೆಲ್ವೆಟ್ ಕೇಕ್ 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
ಹಾಗೆಯೇ, ಈಗ ನಾವು ಈ ಕಪ್ಕೇಕ್ ಅಸ್ತಿತ್ವವನ್ನು ಅಂಶವೂ ನೀವು

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 ಹೊಂದಿದೆ.