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
ಮೈಕ್ರೊಸಾಫ್ಟ್ ಎಕ್ಸೆಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೇಳುತ್ತಾರೆ
ಅಥವಾ 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
>> ಆದ್ದರಿಂದ ನೀವು ಮತ್ತೆ, ಬಹುಶಃ, ಪರಿಚಿತವಾಗಿರುವ
ಎಕ್ಸೆಲ್ ಅಥವಾ 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
ಇಲ್ಲಿ ಒಂದು ಎಕ್ಸೆಲ್ ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಇಲ್ಲಿದೆ.

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
ಆದ್ದರಿಂದ ಪ್ರತಿ ಎಕ್ಸೆಲ್ ಕಡತವನ್ನು ಒಂದು
ಡೇಟಾಬೇಸ್, ಪ್ರತಿ ಹಾಳೆ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದೆ,

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
ಎಂಬ ಸರಹದ್ದು, ಇದು
ಚಿತ್ರಾತ್ಮಕ ಬಳಕೆದಾರ ಆಗಿದೆ

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
>> ಸರಹದ್ದು ರೀತಿಯ
ಯಾರಾದರೂ ಅದು ತುಂಬಾ ಸುಲಭ

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
ಸಮಸ್ಯೆ ಹಾಗೆಯೇ, ಸರಹದ್ದು ಆಗಿದೆ
ಇದು ಕಲಿಕೆಯ ಅದ್ಭುತ ಸಾಧನ ಇಲ್ಲಿದೆ

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
>> ನಾವು ತಿಳಿದಿರುವಂತೆ ನಮ್ಮ
ಪಿಎಚ್ಪಿ ವೆಬ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉದಾಹರಣೆಗೆ,

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
ಏಕೆಂದರೆ, ಸರಹದ್ದು ಮಾಡುತ್ತಾರೆ
ನೀವು ಮಾತ್ರ, ಒಮ್ಮೆ ಮಾಡಲು ಅಗತ್ಯವಿದೆ

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
ಬಹುಶಃ ಒಂದು ಬಳಕೆದಾರ ಹೆಸರು ಮತ್ತು ಜನ್ಮ ದಿನಾಂಕ,
ಪಾಸ್ವರ್ಡ್, ಬಳಕೆದಾರ 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
ನಾವು ರೀತಿಯ ಈ ನಿರ್ಮೂಲನ
ಪಿಎಚ್ಪಿ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಕಲ್ಪನೆಯನ್ನು

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
ಜಿಐಎಸ್ ಪ್ರದೇಶವನ್ನು ಔಟ್ ನಕ್ಷೆ ಸಂಘಟಿಸುತ್ತದೆ.

124
00:06:05,110 --> 00:06:08,580
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಆ ರೀತಿಯ ಸಂಗ್ರಹಿಸಬಹುದು
ಒಂದು SQL ಅಂಕಣದಲ್ಲಿ ಮಾಹಿತಿಯ.

125
00:06:08,580 --> 00:06:11,390
>> ಪಠ್ಯವನ್ನು ಬಹುಶಃ, ಪಠ್ಯ ಕೇವಲ ದೈತ್ಯ Blobs ಆಗಿದೆ.

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
>> ನಾವು ಚಾರ್ ಮತ್ತು 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
ಆದ್ದರಿಂದ ಚಾರ್, ಭಿನ್ನವಾಗಿ ಸಿ ಅಲ್ಲಿ
ಚಾರ್ ಒಂದು ಪಾತ್ರವಾಗಿ,

141
00:06:55,780 --> 00:07:00,730
SQL ನಲ್ಲಿ ಚಾರ್ ಸೂಚಿಸುತ್ತದೆ
ಒಂದು ನಿರ್ದಿಷ್ಟ ಉದ್ದದ ಸ್ಟ್ರಿಂಗ್.

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
ಯಾವುದೇ, ಯಾವುದೇ ಕಡಿಮೆ.

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
ನಾವು ಎರಡು ಎಂದು ನೀನು
ಪಾತ್ರಗಳು, ಮತ್ತು ನಂತರ ಎಂಟು ಶೂನ್ಯ ಕಡಿತದ.

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
ನಾವು ಪರಿಚಿತವಾಗಿರುವ
ಸಿ ಅಥವಾ ಪಿಎಚ್ಪಿ ರಿಂದ.

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
ಸರಿ, ನಾವು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ ಅಗತ್ಯವಿದೆ ವೇಳೆ
ದೀರ್ಘ ಏನೋ ಒಂದು VarChar ಆಗಿದೆ,

167
00:08:08,210 --> 00:08:10,680
ನಾವು ಮರಳಿ ರೀತಿಯ ಮಾಡಬೇಕು
ಇದು ಕೇವಲ ಅಡ್ಡಲಾಗಿ ನಾವು ಸಿ ಮಾಡಿದರು

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-- ನಮ್ಮ ಚಾರ್ ವೇಳೆ
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
ಆದ್ದರಿಂದ ಬಹುಶಃ ನೀವು ಒಂದನ್ನು ಹೊಂದಿದ್ದರೆ
ಹಾಗೆ ಮತ್ತು ಬಿಎಸ್ ಎಂದು ಕಾಲಮ್,

211
00:10:16,410 --> 00:10:19,290
ಎರಡು, ಒಂದು ಎಂದು ಒಂದು ಕಾಲಮ್,
ಮತ್ತು ಮೂರು, ಆದರೆ ನೀವು ಎಂದಾದರೂ ಮಾಡುತ್ತೇವೆ

212
00:10:19,290 --> 00:10:23,660
ಒಂದು ಎ 1, ಒಂದೇ ಹೊಂದಿವೆ
, ಹೀಗೆ ಹೀಗೆ ಎ 2.

213
00:10:23,660 --> 00:10:28,980
ಆದರೆ ನೀವು B2 ಹೊಂದಿರಬಹುದು, ಒಂದು
ಸಿ 2, ಅಥವಾ ಎ 1, ಎ 2, A3, A4.

214
00:10:28,980 --> 00:10:32,840
ಆದ್ದರಿಂದ ನೀವು ಅನೇಕ, ಬಹಳಷ್ಟು ಹೊಂದಿರಬಹುದು
BS, ಅನೇಕ ಪದಗಳಿಗಿಂತ ಅನೇಕ ಎರಡು ಓಟಗಳನ್ನು,

215
00:10:32,840 --> 00:10:38,567
ಆದರೆ ನೀವು ಎಂದಾದರೂ ಹೊಂದಬಹುದು
ಏಕ ಎ 1, 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-- 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, ಮತ್ತು ಪೂರ್ಣ ಹೆಸರು ಬಂಡವಾಳ ಎನ್

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
ನೀವು ಸರಹದ್ದು ಒಂದು ಆಯ್ಕೆಯನ್ನು ಹೊಂದಿರುತ್ತಾರೆ
ನೀವು ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ ರಚಿಸುತ್ತಿದೆ

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, ಮತ್ತು 'd.

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
ಆದರೆ ಬಹುಶಃ ಮಾಡುತ್ತೇವೆ
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
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾನು ಆಯ್ಕೆ ಬಯಸಬಹುದು
ಬಳಕೆದಾರರಿಂದ 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
ತಾಯಿ ಟೇಬಲ್ ಹೆಸರು?

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
ಇದು ಕೇವಲ ಒಂದು ಆಯ್ಕೆ ವಿಶೇಷ ಕೇಸ್.

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, ಸೇರಲು ನಾವು
ಸಿಗುವುದು ಮತ್ತು ಈ ಪಡೆಯಲು ವಾಸ್ತವವಾಗಿ ಮಾಡುವ.

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
ಆದ್ದರಿಂದ ನವೀಕರಿಸುವುದು ಅಪಡೇಟ್ ಬಳಸಬಹುದು
ಒಂದು ಕೋಷ್ಟಕದಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಬದಲಾಯಿಸಲು.

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
ಮತ್ತು ಯಾಡಾ ಗೆ ಗುಪ್ತಪದವನ್ನು
ID ಸಂಖ್ಯೆ 10 ಅಲ್ಲಿ ಯಾಡಾ,.

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
ಟೇಬಲ್ ಎಲ್ಲಿಂದ ಅಳಿಸಿ
ಕೆಲವು ಆಖ್ಯಾತ ತೃಪ್ತಿ ಇದೆ.

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
>> ಆದ್ದರಿಂದ ಈ ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳು, ನಾನು ಹೇಳುತ್ತಿದ್ದೆ ಎಂದು
ಸರಹದ್ದು ಮಾಡಲು ಬಹಳ ಸುಲಭ.

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
ನಾವು, ಪಿಎಚ್ಪಿ ನೋಡಿದಿರಿ?

465
00:23:03,690 --> 00:23:05,760
ಇದು ಕೆಲವು ಪರಿಚಯಿಸುತ್ತದೆ
ನಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಚೈತನ್ಯದ.

466
00:23:05,760 --> 00:23:10,430
ಆದ್ದರಿಂದ ಅದೃಷ್ಟವಶಾತ್, SQL ಮತ್ತು
ಪಿಎಚ್ಪಿ ಒಟ್ಟಿಗೆ ತುಂಬಾ ಚೆನ್ನಾಗಿ ಆಡಲು.

467
00:23:10,430 --> 00:23:13,230
ಪಿಎಚ್ಪಿ ಕಾರ್ಯ ಇಲ್ಲ
ಬಳಸಬಹುದು ಎಂದು ಪ್ರಶ್ನೆಗೆ,.

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
ಮತ್ತು ಪಿಎಚ್ಪಿ ನಿಮ್ಮ ಪರವಾಗಿ ಮಾಡುತ್ತಾನೆ.

471
00:23:23,250 --> 00:23:25,564
>> ನೀವು ಸಂಪರ್ಕ ಮಾಡಿದ ನಂತರ
ಪಿಎಚ್ಪಿ ನಿಮ್ಮ ಡೇಟಾಬೇಸ್,

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
ಪಿಎಚ್ಪಿ ಕಾರ್ಯಗಳನ್ನು.

479
00:23:42,730 --> 00:23:46,460
ನೀವು ಹಾಗೆ ಮಾಡಿದಾಗ, ನೀವು ಸಂಗ್ರಹಿಸಲು
ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ಸೆಟ್ ಪರಿಣಾಮವಾಗಿ.

480
00:23:46,460 --> 00:23:50,290
>> ಮತ್ತು ನಾವು ಕೆಲಸ ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ
ಪಿಎಚ್ಪಿ ಸಹಾಯಕ ರಚನೆಗಳು.

481
00:23:50,290 --> 00:23:52,630
ಹಾಗಾಗಿ ಏನಾದರೂ ಹೇಳಬಹುದು
ಹಾಗೆ this-- $ 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
>> ಆದ್ದರಿಂದ ಕೆಂಪು, ಈ ಪಿಎಚ್ಪಿ.

488
00:24:09,250 --> 00:24:11,890
ನಾನು ಮನುಷ್ಯ ಎಂದು SQL ಆಗಿದೆ
ಮೂಲಕ ಪಿಎಚ್ಪಿ ಸಂಯೋಜಿಸುವ

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
ನಾವು ಮುದ್ರಣ ರೀತಿಯ ಮಾಡಲು ಬಯಸಬಹುದು
ನಾವು ಬದಲಿಗೆ ಮತ್ತು ಬಹುಶಃ ಅಲ್ಲಿ ಎಫ್,

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
ಆದ್ದರಿಂದ ಬಹುಶಃ ನಿಮ್ಮ ಬಳಕೆದಾರ ಮೊದಲು ಲಾಗಿನ್,
ಮತ್ತು ನೀವು ಅವರ ಬಳಕೆದಾರ ID ಸಂಖ್ಯೆ ಉಳಿಸಿದ

514
00:25:44,120 --> 00:25:51,710
ಪಿಎಚ್ಪಿ ಸೂಪರ್ $ _SESSION ರಲ್ಲಿ
ಕೀಲಿ ID ಜಾಗತಿಕ.

515
00:25:51,710 --> 00:25:55,947
ಅವರು ಲಾಗ್ ಇನ್ ಆದ್ದರಿಂದ ಬಹುಶಃ ನಂತರ,
ನೀವು ಐಡಿ = 10 $ _SESSION ಸೆಟ್

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
ಏನು ಬಳಕೆದಾರನ 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
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು
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
ನಾವು ತಿರುಗಿ ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ
ಪಿಎಚ್ಪಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮೂಲಕ, ಬಲ?

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-- ಬಾಗುತ್ತೇನೆ
ನಾನು ಕೆಲವು ಎಚ್ಟಿಎಮ್ಎಲ್ ಒಂದು ತುಣುಕನ್ನು.

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
ಮತ್ತು ಆ ನಂತರ, ನಾನು
ಬಲ, ಕೆಲವು ಪಿಎಚ್ಪಿ ಹೊಂದಿವೆ?

538
00:27:06,060 --> 00:27:08,229
ನಾನು ಈ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಎಲ್ಲಾ ಹೊಂದಿವೆ.

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
ನಾವು ಎರಡನೇ ಹಿಂದೆ ಕಂಡ ಕೆಂಪು ಎಚ್ಟಿಎಮ್ಎಲ್ ಆಗಿತ್ತು.

544
00:27:19,680 --> 00:27:21,360
ಇಲ್ಲಿ ಹಸಿರು ಪಿಎಚ್ಪಿ.

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
ನಂತರ ಪರಿಣಾಮವಾಗಿ ಪ್ರತಿ ಫಲಿತಾಂಶಗಳಿಗಾಗಿ
ಪಿಎಚ್ಪಿ 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
ಇದು ಸಹಾಯಕ ಒಂದು ಶ್ರೇಣಿಯನ್ನು
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
ಹಸಿರು ಕೆಲವು ಪಿಎಚ್ಪಿ ಬೆರೆಸಿ.

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