>> [მუსიკის დაკვრა]
DOUG LLOYD: ჩვენი ვიდეოები ვებ განვითარების საკითხებზე,
ჩვენ აღნიშნული კონცეფცია მონაცემთა ბაზის რამდენჯერმე, არა?
მონაცემთა ბაზის თქვენ ალბათ იცნობს
ვთქვათ გამოყენებით Microsoft Excel ან Google ცხრილები.
ეს არის ნამდვილად ორგანიზებული მითითებული მაგიდები, რიგები და სვეტები.
>> და მონაცემთა ბაზის არის, სადაც ჩვენს საიტზე მაღაზიები
ინფორმაცია, რომ მნიშვნელოვანია ჩვენი საიტი იმუშავებს.
ისევ და ისევ, ძალიან გავრცელებული მაგალითია აქ შენახვის სახელისა და პაროლის
მონაცემთა ბაზა, ისე, რომ როდესაც მომხმარებლის ჟურნალი შევიდა ჩვენს საიტზე,
მონაცემთა ბაზის შეიძლება შეუსაბამო ვხედავ თუ ამ მომხმარებლის არსებობს მონაცემთა ბაზაში.
და თუ ისინი, შემოწმების, რომ მათი დაგავიწყდათ სწორია.
და თუ მათი დაგავიწყდათ სწორია, მაშინ ჩვენ შეგვიძლია მათ რასაც გვერდი
ისინი ითხოვს.
>> ასე რომ, თქვენ ალბათ, კიდევ ერთხელ, ნაცნობი ამ იდეას, Excel ან Google
ცხრილები.
ჩვენ გვყავს მონაცემთა ბაზები, მაგიდები, რიგები და სვეტები.
და ეს მართლაც ერთგვარი ერთი ფუნდამენტური კომპლექტი
იერარქიული ავარია აქ.
ასე რომ, აქ Excel-.
და თუ თქვენ ოდესმე გახსნა ან სხვა მსგავსი პროგრამა
თქვენ იცით, რომ ეს აქ rows-- 1, 2, 3, 4, 5, 6, 7.
ეს არის სვეტები.
>> იქნებ აქ, მიუხედავად იმისა, რომ თქვენ შეიძლება არ გამოიყენოთ ეს ფუნქცია საშინლად much--
მე მიუახლოვდით ჩვენ ეს იდეა ფურცელი.
ასე რომ, შესაძლოა ეს ფურცლები, თუ მე ალტერნატიული უკან და მეოთხე,
სხვადასხვა მაგიდები, რომ არსებობს ჩემს მონაცემთა ბაზაში.
და თუ ჩვენ ვაგრძელებთ მაგალითად ყველა სხვათა შორის, სახელი ამ მონაცემთა ბაზაში
არის წიგნი 1.
იქნებ მე მაქვს წიგნი 2 და წიგნი 3.
ასე რომ, თითოეული Excel ფაილი არის მონაცემთა ბაზა, თითოეული ფურცელი მაგიდა,
და შიგნით თითოეულ მაგიდაზე მაქვს ეს იდეა რიგები და სვეტები.
>> ასე რომ, მე ვმუშაობ ამ მონაცემთა ბაზაში?
როგორ მივიღო ინფორმაცია მისგან?
ასევე არსებობს ენის მოუწოდა SQL-- რომელიც მე, როგორც წესი, მხოლოდ მოვუწოდებთ Sequel--
და იგი დგას სტრუქტურირებული შეკითხვის ენა.
და ეს არის პროგრამირების ენა, მაგრამ ეს არის საკმაოდ შეზღუდული პროგრამირების
ენა.
ეს არ არის საკმაოდ ისევე, როგორც სხვა რომ ჩვენ არ მუშაობდა.
მაგრამ ამ მიზნით პროგრამირების ენა
არის შეკითხვის მონაცემთა ბაზაში, ვთხოვთ ინფორმაცია მონაცემთა ბაზაში,
მოვძებნოთ ინფორმაცია მონაცემთა ბაზა, და ასე შემდეგ.
>> ჩვენ ასევე, CS50-- და ეს არის ძალიან საერთო პლატფორმა, ეს ე.წ. MySQL.
ეს არის ის, რაც ჩვენ ვიყენებთ, რა თქმა უნდა.
ეს არის ღია პლატფორმა, რომელიც ადგენს
ე.წ. რელატიური მონაცემთა ბაზა მონაცემთა ბაზა, ეფექტურად.
ჩვენ არ უნდა მიიღოს ძალიან ბევრი დეტალი
თუ რა რელატიური მონაცემთა ბაზა.
მაგრამ SQL ენა ძალიან კომპეტენტურ სამუშაო
ერთად MySQL და სხვა მსგავსი სტილის რელაციური მონაცემთა ბაზები.
>> და ბევრი დანადგარები MySQL მოდის რაღაც
მოუწოდა phpMyAdmin, რომელიც არის გრაფიკული მომხმარებლის
interface-- GUI--, რომ ხდის ცოტა მეტი
მეგობრული შეასრულოს მონაცემთა ბაზის შეკითხვებს,
რადგან ბაზაში არ მხოლოდ გამოყენებული მოწინავე პროგრამისტები, არა?
ზოგჯერ არსებობს ამ მცირე ბიზნესის,
და ისინი ვერ ახერხებს აყვანის გუნდი პროგრამისტების,
მაგრამ მაინც უნდა შესანახად ინფორმაციის მონაცემთა ბაზაში.
>> რაღაც phpMyAdmin რაც ძალიან ადვილია ვინმეს
რომელიც არასოდეს პროგრამირდება ადრე შეარჩიო და გაეცნოს როგორ
მუშაობა მონაცემთა ბაზაში.
პრობლემა ის არის, phpMyAdmin, ხოლო ის ფანტასტიკური ინსტრუმენტი სწავლის
შესახებ მონაცემთა ბაზები, ეს არის სახელმძღვანელო.
თქვენ აპირებთ უნდა შეხვიდეთ და შეასრულოს ბრძანებები და ტიპის
რამ ხელით.
>> და როგორც ვიცით ჩვენი მაგალითად PHP ვებ პროგრამირება,
ხელით გააკეთებს რამ ჩვენს საიტზე,
თუ ჩვენ გვინდა, დინამიური, აქტიური საპასუხო ნახვა, ალბათ არ არის საუკეთესო მიდგომა.
ჩვენ გვინდა, რომ იპოვოს გზა ალბათ ავტომატიზაცია ეს როგორღაც.
და SQL საშუალებას მოგვცემს, რომ ამის გაკეთება.
ასე რომ, როდესაც ჩვენ ვაპირებთ დაიწყოს მუშაობა SQL,
ჩვენ უნდა ჰქონდეს მონაცემთა ბაზა მუშაობა.
შექმნა მონაცემთა ბაზა რაღაც თქვენ ალბათ
გავაკეთებ phpMyAdmin, რადგან თქვენ მხოლოდ უნდა გავაკეთოთ, რომ ერთხელ,
და სინტაქსი ამით არის ბევრი უფრო მარტივია.
ეს ბევრი ადვილია ამის გაკეთება გრაფიკული ინტერფეისი
ვიდრე აკრეფით ის, როგორც ბრძანება.
ბრძანება შეიძლება კიდევ ცოტა რთული.
ანალოგიურად, შექმნა მაგიდა შეიძლება მიიღოს საკმაოდ ცოტა cumbersome ისევე.
და ასე რამ, როგორიცაა მონაცემთა ბაზის შექმნას და ქმნის მაგიდა, რომელიც თქვენ
ალბათ მხოლოდ აპირებს once-- ერთხელ მაგიდა, ერთხელ მონაცემთა ბაზა
ეს OK უნდა გავაკეთოთ, რომ გრაფიკული ინტერფეისი.
პროცესში შექმნის მაგიდა, თქვენ
ასევე უნდა მიუთითოთ ყველა სვეტები, რომელიც იქნება, რომ მაგიდასთან.
რა სახის ინფორმაციას ამის გსურთ შეინახოთ მაგიდაზე?
იქნებ მომხმარებლის სახელი და დაბადების თარიღი, პაროლი, მომხმარებლის ID ნომერი, და შესაძლოა,
ქალაქი და სახელმწიფო, უფლება?
>> და ყოველ ჯერზე ჩვენ გვინდა, რომ დაამატოთ შესახებ მონაცემთა ბაზა, ჩვენ გვინდა ექვსივე
იმ ცალი ინფორმაცია.
და ჩვენ გავაკეთოთ, რომ დამატებით რიგები მაგიდასთან.
ასე რომ, ჩვენ პირველი მონაცემთა ბაზის შექმნა, მაშინ ჩვენ შევქმნათ ცხრილი.
ნაწილი შექმნის მაგიდა, ჩვენ ვთხოვეთ
დააკონკრეტა, ყველა სვეტი, ჩვენ გვინდა ამ მაგიდასთან.
და შემდეგ, როგორც ჩვენ დავიწყებთ რჩეულებში მონაცემთა ბაზაში
და შეკითხვის მონაცემთა ბაზის მეტი ზოგადად არ არის მხოლოდ და დასძინა,
მაგრამ ყველაფერი ჩვენ გავაკეთოთ ჩვენ ვიქნებით საქმე
რიგები მაგიდა, რომელიც არის ერთ-ერთი მომხმარებლის ინფორმაციას მთელი კომპლექტი.
>> ასე რომ, ყოველ SQL სვეტი შეუძლია ჩატარების მონაცემები კონკრეტული მონაცემები ტიპის.
ასე რომ, ჩვენ ერთგვარი აღმოფხვრილი ეს იდეა მონაცემთა ტიპები PHP,
მაგრამ ისინი უკან აქ SQL.
და იქ ბევრი მონაცემთა ტიპები.
აქ მხოლოდ 20 მათგანი, მაგრამ ის კი არ არის ყველა მათგანი.
ასე რომ, ჩვენ გვაქვს იდეები, როგორიცაა ints Integers-- ჩვენ, ალბათ, იცით
რომ ამ სვეტის შეიძლება მოვაწყოთ რიცხვებით.
და არსებობს ვარიაციები thereon-- SMALLINT, TINYINT, MEDIUMINT, BIGINT.
შესაძლოა, ჩვენ ყოველთვის არ უნდა ოთხ ნაკბენები.
იქნებ ჩვენ უნდა რვა ბაიტი, და ამიტომ ჩვენ შეგიძლიათ გამოიყენოთ ეს ვარიაციები რიცხვებით
იყოს ცოტა მეტი სივრცე ეფექტური.
ჩვენ შეგვიძლია ამის გაკეთება ათობითი ნომრები, ჩვენ შეგიძლიათ გააკეთოთ მცურავი პუნქტიანი ნომრები.
ეს არის საკმაოდ მსგავსია.
არსებობს გარკვეული განსხვავებები, და თუ
მინდა ეძებოთ SQL ერთგვარი სახელმძღვანელო,
ხედავთ, რა უმნიშვნელო განსხვავებები მათ შორის.
>> იქნებ ჩვენ გვინდა შესანახად ინფორმაცია თარიღი და დრო.
იქნებ ჩვენ შენახვა სიმღერა როდესაც მომხმარებელი შეუერთდა ჩვენი ნახვა,
და იქნებ ჩვენ გვინდა აქვს სვეტი, რომელიც არის
თარიღი დრო ან დროის ნიშნულს, რომ მიუთითებს, როდესაც მომხმარებელს რეალურად
მოაწერა ხელი.
ჩვენ შეგვიძლია ამის გაკეთება გეომეტრია და linestrings.
ეს არის რეალურად საკმაოდ გრილი.
ჩვენ ვერ განვსაზღვრავთ გეოგრაფიული არეალი გამოყენებით
GIS კოორდინატები ნაკვეთი out ფართობი.
ასე რომ, შეგიძლიათ რეალურად შესანახად, რომ ერთგვარი ინფორმაციის, SQL სვეტი.
>> ტექსტი არის მხოლოდ გიგანტური Blobs ტექსტის, იქნებ.
Enums სახის საინტერესო.
ისინი რეალურად არსებობს C. ჩვენ არ გაიგო მათ შესახებ, რადგან ისინი არ
საშინლად გამოიყენება, მინიმუმ CS50.
მაგრამ ეს ჩამოთვლილ მონაცემების ტიპის, რომელიც შეუძლია ჩატარების შეზღუდული ღირებულებებს.
>> ძალიან კარგი მაგალითი აქ იქნება შექმნათ ENUM, სადაც შვიდი
შესაძლო მნიშვნელობებია კვირას, ორშაბათს, სამშაბათი, ოთხშაბათი, ხუთშაბათი, პარასკევი,
შაბათი, არა?
ეს მონაცემები ტიპის დღე კვირა არ არსებობს,
მაგრამ ჩვენ შეგვიძლია შევქმნათ ჩამოთვლილი მონაცემები ტიპის როგორიცაა
, რომ სვეტი შეიძლება მხოლოდ ოდესმე გამართავს ერთ-ერთი იმ შვიდი შესაძლო მნიშვნელობებია.
ჩვენ ჩამოთვლილ ყველა შესაძლო ღირებულებებს.
>> მაშინ ჩვენ გვაქვს CHAR და Varchar, და მე ფერი მწვანე
იმიტომ, რომ ჩვენ, ფაქტობრივად, აპირებს მეორე
ვისაუბროთ განსხვავება შორის ეს ორი რამ.
ასე რომ, CHAR განსხვავებით, C, სადაც CHAR იყო ერთჯერადი ხასიათი,
in SQL, char ეხება ფიქსირებული სიგრძის სტრიქონი.
და როდესაც ჩვენ ვქმნით ეს სვეტი, ჩვენ რეალურად
შეგიძლიათ მიუთითოთ სიგრძეზე სიმებიანი.
>> ასე რომ, ამ მაგალითად, შეიძლება ითქვას, CHAR (10).
ეს იმას ნიშნავს, რომ ყოველ ელემენტს, რომ სვეტი
შედგება 10 ბაიტი ინფორმაცია.
არც მეტი, არც ნაკლები.
ასე რომ, თუ ჩვენ ვცდილობთ და ამით 15 bit ან 15 ხასიათი ელემენტი
და ღირებულება ამ სვეტის, ჩვენ მხოლოდ მიიღოს პირველი 10.
თუ ჩვენ ამ ორ ხასიათი ხანგრძლივი ღირებულება,
ჩვენ ვაპირებთ, რომ აქვს ორი პერსონაჟი, და შემდეგ რვა null ნაკბენები.
ჩვენ არასოდეს არ იქნება უფრო ეფექტური, ვიდრე.
>> Varchar არის სახის მოსწონს ჩვენი ცნება სიმებიანი
რომ ჩვენ იცნობს ერთად ეხლა C ან PHP.
ეს არის ცვლადი სიგრძის სტრიქონი.
და როდესაც თქვენ შექმნით ამ სვეტის, უბრალოდ
დააკონკრეტა მაქსიმალური lengths.
ასე რომ, შესაძლოა 99 ან საყოველთაოდ 255.
ეს იქნება მაქსიმალური.
ასე რომ, თუ ჩვენ შენახვის 15 ხასიათის ტექსტი,
ჩვენ ვიყენებთ 15 ბაიტი, შესაძლოა, 16 bytes for null terminator.
თუ ჩვენ შენახვის სამი ხასიათის ტექსტი,
ჩვენ ვიყენებთ სამი ან ოთხი ბაიტი.
მაგრამ ჩვენ არ გამოიყენონ 99.
>> ასე რომ, რატომ ჩვენ ორივე?
ისე, თუ ჩვენ უნდა გაერკვნენ, თუ როგორ ხანგრძლივი რაღაც ერთად Varchar,
ჩვენ უნდა სახის iterate მთელი ეს უბრალოდ მინდა ჩვენ გააკეთა C
და გაერკვნენ, სადაც ის შეწყვეტს.
ხოლო თუ ჩვენ ვიცით, რომ ყველაფერი ამ სვეტის არის 10 ბაიტი, შესაძლოა,
ჩვენ ვიცით, რომ ინფორმაცია, ჩვენ შეგვიძლია ხტომა 10 ბაიტი, 10 ბაიტი, 10 ბაიტი, 10 ბაიტი,
და ყოველთვის დაწყებული სიმებიანი.
>> ასე რომ, ჩვენ შეიძლება ჰქონდეს გარკვეული შეეწირა სივრცეში CHAR,
მაგრამ იქნებ იქ სავაჭრო off, რომელსაც უკეთესი სიჩქარე
სანავიგაციო მონაცემთა ბაზაში.
მაგრამ იქნებ ჩვენ გვინდა მოქნილობის Varchar
ნაცვლად having-- თუ ჩვენი CHAR იყო 255, მაგრამ ჩვენი მომხმარებლები
იყო მხოლოდ შესაყვანი სამი ან ოთხი bytes ღირს ინფორმაციის ან სამი ან ოთხი
გმირები ღირებულების ინფორმაცია.
>> მაგრამ ზოგიერთ მომხმარებელს გამოყენებით მთელი 255, შესაძლოა,
Varchar იქნებოდა იქ.
ეს ერთგვარი სავაჭრო, და ზოგადად მიზნით CS50,
თქვენ არ უნდა ინერვიულოთ ძალიან ბევრი შესახებ თუ თქვენ იყენებთ CHAR ან Varchar.
მაგრამ რეალურ სამყაროში, ეს ყველაფერი არ აქვს მნიშვნელობა, იმიტომ, რომ ყველა ეს სვეტები
დასჭირდეს ფიზიკური სივრცე.
და ფიზიკური სივრცე, რეალურ სამყაროში, მოდის პრემია.
>> ასე რომ, ერთი სხვა განსახილველად როდესაც თქვენ აშენებთ მაგიდა
აირჩიოთ ერთი სვეტი უნდა იყოს რასაც პირველადი გასაღები.
და პირველადი გასაღები სვეტი სადაც თითოეული ღირებულება არის უნიკალური.
ეს იმას ნიშნავს, რომ თქვენ შეგიძლიათ მარტივად გამოარჩიეთ ერთ ზედიზედ მხოლოდ ეძებს
პირველადი გასაღები, რომ ზედიზედ.
ასე მაგალითად, თქვენ ზოგადად, წევრებს,
არ მინდა ორი წევრებს, რომლებიც აქვს იგივე მომხმარებლის ID ნომერი.
ასე რომ, შესაძლოა, თქვენ გაქვთ უამრავი ინფორმაცია,
და შესაძლოა ორ მომხმარებელს შეუძლია აქვს იგივე name--
თქვენ გაქვთ ჯონ სმიტი და ჯონ სმიტი.
ეს არ არის აუცილებლად პრობლემა, იმიტომ, რომ არსებობს მრავალი ადამიანი
მსოფლიოში სახელად ჯონ სმიტი.
მაგრამ ჩვენ მხოლოდ ერთი მომხმარებლის ID ნომერი 10, ერთი მომხმარებლის ID ნომერი 11, 12, 13.
ჩვენ არ გვაქვს ორი მომხმარებლები იგივე რაოდენობის,
და იქნებ მომხმარებლის ID ნომრები კარგი იქნებოდა, პირველადი გასაღები.
>> ჩვენ არ გვაქვს რაიმე დუბლირებას, და ახლა ჩვენ შეგვიძლია ცალსახად
იდენტიფიცირება თითოეული ზედიზედ მხოლოდ ეძებს, რომ სვეტი.
შერჩევა პირველადი გასაღები შეიძლება რეალურად რათა შემდგომ მაგიდა ოპერაციების
ბევრი ადვილია, რადგან თქვენ შეგიძლიათ ბერკეტები იმ ფაქტს, რომ გარკვეული რიგები იქნება
იყოს უნიკალური, ან გარკვეული სვეტი თქვენი მონაცემთა ბაზაში ან მაგიდასთან
იქნება უნიკალური აირჩიოთ გარეთ, კერძოდ რიგები.
>> თქვენ ასევე შეგიძლიათ ერთობლივი პირველადი გასაღები, რომელიც თქვენ შეიძლება აღმოაჩინოთ, შემთხვევა
გამოყენება, რომელიც მხოლოდ კომბინაცია ორი სვეტები,
გარანტირებული იყოს უნიკალური.
ასე რომ, შესაძლოა, თქვენ გაქვთ ერთი სვეტი, რომ როგორც და Bs,
ერთი სვეტი, ერთი, ორი, და სამი, მაგრამ თქვენ მხოლოდ ოდესმე
აქვს ერთი A1, ერთი A2, და ასე შემდეგ და ასე შემდეგ.
მაგრამ თქვენ ალბათ B2, რომელიც C2, ან A1, A2, A3, A4.
ასე, რომ თქვენ ალბათ მრავალი როგორც, სხვადასხვა BS, რამდენიმე პირობა, მრავალი twos,
მაგრამ თქვენ შეგიძლიათ მხოლოდ ოდესმე ერთ A1, B2, C3, და ასე შემდეგ.
ასე რომ, როგორც ვთქვი, SQL არის პროგრამირების ენა,
მაგრამ მას აქვს საკმაოდ შეზღუდული ლექსიკა.
ეს არ არის საკმაოდ ძვირადღირებული, როგორც C და PHP და სხვა ენებზე
რომ გაიგო, რა თქმა უნდა.
ეს უფრო verbose ენის ვიდრე ის, რაც ჩვენ
ვაპირებ ვისაუბრო ამ ვიდეო, იმიტომ, რომ ამ ვიდეო
ჩვენ ვაპირებთ ვისაუბროთ ოთხი ოპერაცია, რომ ჩვენ
შეუძლია შეასრულოს მაგიდა.
>> არსებობს უფრო მეტი, ვიდრე ეს.
ჩვენ შეგვიძლია ამის მეტი, მაგრამ ჩვენი მიზნებისთვის,
ჩვენ ზოგადად აპირებს გამოყენებით მხოლოდ ოთხი ოპერაციები ჩანართით,
აირჩიეთ განახლება და წაშლა.
და თქვენ ალბათ ინტუიციურად მისახვედრია, რა ოთხივე ეს ყველაფერი გავაკეთოთ.
მაგრამ ჩვენ წასვლას ცოტა დეტალურად თითოეული.
>> ასე რომ, იმ მიზნით, რომ ამ ვიდეო, მოდით ვივარაუდოთ,
ჩვენ გვაქვს შემდეგი ორი მაგიდები ერთ მონაცემთა ბაზაში.
ჩვენ მაგიდა სახელწოდებით მომხმარებელი, რომელსაც აქვს ოთხი columns-- ნომერი, სახელი,
პაროლი და სრული სახელი.
და ჩვენ გვაქვს მეორე მაგიდა იგივე მონაცემთა ბაზა
მოუწოდა Moms, რომ მხოლოდ ინახავს ინფორმაციას შესახებ სახელი და დედა.
ასე რომ, ყველა მაგალითები ამ ვიდეო, ჩვენ
გამოყენებით ამ ბაზაში და შემდგომი განახლება მას.
ასე ვთქვათ, ჩვენ გვინდა, რომ დაამატეთ ინფორმაცია მაგიდასთან.
ეს არის ის რაც ჩასმა ოპერაცია აქვს.
აეხსნა ყველა ეს ბრძანებები, მე ვაპირებ
გადმოგცეთ ზოგადი ჩონჩხი გამოიყენოს.
იმის გამო, რომ, ძირითადად, ეჭვი ვაპირებთ შევხედოთ საკმაოდ მსგავსია,
ჩვენ უბრალოდ უნდა შეცვლის ოდნავ განსხვავებული ცალი ინფორმაცია
უნდა გავაკეთოთ სხვადასხვა ნივთები მაგიდაზე.
>> ასე რომ, INSERT, ჩონჩხი გამოიყურება სახის მოსწონს ეს.
ჩვენ გვინდა, რომ ჩადეთ კონკრეტული მაგიდა.
მაშინ ჩვენ გვაქვს ღია ფრჩხილებში და სიაში სვეტები
რომ ჩვენ გვინდა, რომ ღირებულებები.
Close ფრჩხილებში, რომ შემდეგ ფასეულობებს და შემდეგ
კიდევ ერთხელ, ჩვენ გამოვაჩენინოთ ღირებულებები ჩვენ გვინდა, რომ მაგიდასთან.
>> ასე მაგალითად ეს იქნება შემდეგ.
მინდა ჩადეთ შევიდა მაგიდა მომხმარებლის შემდეგი columns--
სახელი, პაროლი და fullname.
ასე რომ, ახალი row, სადაც მე აყენებს იმ სამი სვეტით და ჩვენ
აპირებს დააყენოს ღირებულებების Newman, USMAIL და Newman.
ასე რომ, ამ შემთხვევაში, მე აყენებს ამას newman
შევიდა სახელი სვეტი, დაგავიწყდათ USMAIL და სრული სახელი კაპიტალის N
Newman შევიდა fullname სვეტი.
>> ასე რომ, აქ არის ის, რაც მონაცემთა ბაზა ჰგავდა ადრე.
აი, რა მომხმარებლები მაგიდა დაბრუნება ჰგავდა ადრე ეს გავაკეთეთ.
მას შემდეგ, რაც ჩვენ შეასრულოს ეს შეკითხვაზე, ჩვენ ეს.
ჩვენ დასძინა ახალი ზედიზედ მაგიდასთან.
მაგრამ შეამჩნია ეს ერთი რამ რომ მე არ დააკონკრეტა,
მაგრამ რატომღაც მე მივიღე მნიშვნელობა ამისთვის, რომელიც ამ 12 უფლება აქ.
მე არ ვამბობ, რომ მე მინდოდა ბოლო ID ნომერი იქ.
მინდოდა, რომ სახელი, დაგავიწყდათ, fullname.
და მე, რომ ეს ჯარიმა.
>> მაგრამ მე ასევე მივიღე ეს 12.
რატომ მივიღებ ამ 12-ში?
ისე, გამოდის, რომ როდესაც თქვენ განსაზღვრის
სვეტი, რომელიც იქნება თქვენი ძირითადი გასაღები, რომელიც, როგორც წესი,
როგორც ვთქვი, პირადობის მოწმობის ნომერი.
ეს არ არის ყოველთვის აუცილებლად იქნება პირადობის მოწმობის ნომერი,
მაგრამ ეს, როგორც წესი, კარგი იდეა იყოს გარკვეული მთელი მნიშვნელობა.
თქვენ გაქვთ ვარიანტი phpMyAdmin როდესაც თქვენ შექმნით თქვენს მონაცემთა ბაზაში
ან თქვენს მაგიდასთან, რომ მითითებული სვეტი, როგორც განცხადება ზრდა.
>> რა არის კარგი იდეა, როდესაც თქვენ მუშაობის ძირითადი გასაღები,
იმიტომ, რომ გსურთ ყველა ღირებულება რომ სვეტი იყოს უნიკალური.
და თუ თქვენ დაგავიწყდებათ მიუთითოთ ეს უფრო მეტია, ვიდრე ერთ ადამიანს,
თქვენ ახლა სიტუაცია, სადაც რომ სვეტი აღარ უნიკალური.
თქვენ გაქვთ ორი ბლანკები, ასე რომ თქვენ არ შეუძლია აღარ ცალსახად იდენტიფიცირება column--
ან შეგიძლიათ აღარ ცალსახად იდენტიფიცირება ზედიზედ ეფუძნება, რომ სვეტი.
ის დაკარგა ყველა მისი ღირებულება, როგორც პირველადი გასაღები.
>> ასე რომ, როგორც ჩანს, რაც მე არ კეთდება აქ არის კონფიგურირებული მომხმარებლის ID
სვეტი განცხადება ნამატი ისე, რომ ყოველ დრო დავამატო ინფორმაცია მაგიდა,
ეს ავტომატურად მომეცი მნიშვნელობა პირველადი გასაღები.
ასე რომ, მე ვერ უნდა დაგვავიწყდეს, იმიტომ, რომ მონაცემთა ბაზის გაკეთება ჩემთვის.
ასე რომ სახის ლამაზი.
ასე რომ, ამიტომ, ვიღებთ 12 იქ, იმიტომ, რომ მე
მითითებული, რომ სვეტი მდე ავტომობილი იყოს.
თუ მე დასძინა სხვისი ეს მინდა იყოს 13, თუ მე დასძინა
სხვისი ის მინდა იყოს 14, და ასე შემდეგ.
>> მოდით გავაკეთოთ კიდევ ერთი ჩანართი.
ჩვენ ჩადეთ moms მაგიდა, კერძოდ, სახელი და დედა
სვეტი, ფასეულობები კრამერი და Babs Kramer.
ასე რომ, ჩვენ გვქონდა ადრე.
მას შემდეგ, რაც ჩვენ შეასრულოს, რომ SQL query, ჩვენ გვაქვს.
ჩვენ დასძინა კრამერი და Babs Kramer რომ moms მაგიდასთან.
>> ასე რომ ჩასმა.
SELECT არის ის, რაც ჩვენ ვიყენებთ ამონაწერი ინფორმაცია მაგიდასთან.
ასე რომ, ეს არის, თუ როგორ მივიღებთ ინფორმაცია out of მონაცემთა ბაზაში.
ასე რომ, SELECT ბრძანებები იქნება ძალიან ხშირად გამოიყენება პროგრამირების.
ზოგადი ჩარჩო ზოგადი ჩონჩხი ასე გამოიყურება.
აირჩიეთ კომპლექტი სვეტები მაგიდა და შემდეგ სურვილისამებრ
თქვენ შეგიძლიათ მიუთითოთ condition-- ან ის, რაც ჩვენ, როგორც წესი, მოვუწოდებთ შემასმენელს,
ჩვეულებრივ, ტერმინი ჩვენ ვიყენებთ SQL.
>> მაგრამ ეს, ძირითადად, რა კერძოდ რიგები გსურთ მიიღოთ.
თუ გსურთ, ნაცვლად მიღების ყველაფერი, ვიწრო ის ქვემოთ,
ეს არის სადაც თქვენ ამის გაკეთება.
და მერე სურვილისამებრ, ასევე შეგიძლიათ შეკვეთა კონკრეტული სვეტი.
ასე რომ, შესაძლოა გსურთ აქვს რამ დალაგებულია ალფავიტის საფუძველზე ერთი სვეტი
ან ალფავიტის საფუძველზე სხვა.
>> ისევ და ისევ, სად და ORDER BY სურვილისამებრ.
მაგრამ ისინი, ალბათ, useful-- განსაკუთრებით
სადაც იქნება სასარგებლო ვიწრო ქვემოთ ასე რომ თქვენ არ
მიიღოთ თქვენი მთელი მონაცემთა ბაზაში და უკან უნდა გადაამუშავებს მას, თქვენ უბრალოდ
ცალი, რომ თქვენ აინტერესებს.
ასე მაგალითად, მე დაგვჭირდება აირჩიეთ ID ნომერი და fullname მომხმარებლებს.
ასე რომ, რა შეიძლება ამ გამოიყურებოდეს?
ასე რომ, აქ არის ჩემი მომხმარებლებს მაგიდასთან.
მინდა აირჩიოთ idnum და fullname მომხმარებლებს.
რა ვარ მე აპირებს მიიღოს?
მე ვაპირებ ამ.
მე არ ვიწრო ის ქვემოთ, ასე რომ მე მიღების ID ნომერი ყოველ სტრიქონს
და მე მიღების სრული ასახელებს ყოველ ზედიზედ.
>> OK.
რა მოხდება, თუ მე უნდა აირჩიოთ დაგავიწყდათ მომხმარებლებს, სად ასე რომ, ახლა
მე დასძინა მდგომარეობაში, predicate-- სადაც idnum ნაკლებია, ვიდრე 12.
ასე რომ, აქ ჩემს მონაცემთა ბაზაში, კიდევ ერთხელ, ჩემი მომხმარებლებს მაგიდასთან დაბრუნება.
რა ვარ მე აპირებს მიიღოს, თუ მინდა აირჩიეთ, რომ ინფორმაცია, დაგავიწყდათ,
სადაც მომხმარებლის ID ან idnum ნაკლებია, ვიდრე 12?
მე ვაპირებ, რომ ამ ინფორმაცია უკან, არა?
ეს ხდება, რომ idnum 10, ნაკლებად 12, პირადობის მოწმობის ნომერი 11 არანაკლებ 12.
მე მიღების დაგავიწყდათ მათთვის რიგები.
ეს არის ის, რაც მე სთხოვა.
ამაზე რას იტყვი?
რა მოხდება, თუ მე უნდა აირჩიოთ ვარსკვლავი საწყისი moms მაგიდასთან, სადაც სახელი ტოლია ჯერი?
OK, აირჩიეთ ვარსკვლავი არის სპეციალური სახის ველური ბარათი ე.წ.
რომ ჩვენ ვიყენებთ ყველაფერი.
ასე რომ, ისინი ამბობენ აირჩიეთ მომხმარებლის სახელი მძიმით დედა, რომელიც
მოხდა ისე, რომ მხოლოდ ორ ბურჯს ამ მაგიდასთან,
შემიძლია უბრალოდ აირჩიეთ ვარსკვლავი და ყველაფერი
სადაც სახელი ტოლია ჯერი.
და ისე, რომ ის, რაც მე კიდევ თუ მე, რომ კონკრეტული შეკითხვა.
>> ახლა, მონაცემთა ბაზები დიდი, რადგან ისინი საშუალებას
ჩვენს ორგანიზება ინფორმაცია, ალბათ, ცოტა უფრო ეფექტურად, ვიდრე ჩვენ
შესაძლოა, სხვაგვარად.
ჩვენ არ ემთხვეოდეს შესანახად ყველა შესაბამისი ინფორმაცია
დაახლოებით შესახებ იმავე მაგიდასთან.
ჩვენ გვქონდა ორი მაგიდები.
>> ჩვენ უნდა ჩაწეროთ ყველას დედის სახელი,
და იქნებ ჩვენ არ გვაქვს სოციალური დაცვის ნომერი, გვაქვს მათი დაბადების თარიღი.
ეს ყოველთვის არ უნდა უნდა იყოს იმავე მაგიდასთან.
რადგან ჩვენ შეგვიძლია განვსაზღვროთ შორის ურთიერთობების tables--
და რომ სადაც, რომ რელატიური მონაცემთა ბაზის ტერმინი სახის მოდის
შევიდა play-- რადგან ჩვენ შეგვიძლია განვსაზღვროთ შორის ურთიერთობების მაგიდები,
ჩვენ შეგვიძლია სახის compartmentalize ან აბსტრაქტული რამ გზა,
სადაც ჩვენ მხოლოდ მართლაც მნიშვნელოვანი ინფორმაცია
ჩვენ ვზრუნავთ ამ მომხმარებლის მაგიდასთან.
და მაშინ ჩვენ გვაქვს დამხმარე ინფორმაცია ან დამატებითი ინფორმაციის სხვა მაგიდები
რომ ჩვენ შეგვიძლია დაკავშირება დაბრუნება მთავარ მომხმარებლის მაგიდა კონკრეტული გზა.
>> ასე რომ აქ გვაქვს ამ ორ მაგიდას, მაგრამ იქ ურთიერთობა, მათ შორის,
არა?
როგორც ჩანს, სახელი შეიძლება რაღაც
რომ არსებობს გავრცელებული შორის ეს ორი სხვადასხვა მაგიდები.
მერე რა, რომ ჩვენ ახლა აქვს სიტუაციაში, როდესაც ჩვენ
გსურთ მიიღოთ მომხმარებლის სრული სახელი მომხმარებლის მაგიდა, და მათი დედის
ასახელებს დედა მაგიდასთან?
ჩვენ არ გვაქვს გზა რომ როგორც იგი დგას, არა?
არ არსებობს ერთი მაგიდა, რომელიც შეიცავს ორივე სრული სახელი და დედის სახელი.
ჩვენ არ გვაქვს, რომ ვარიანტი ის, რაც ჩვენ ვნახეთ ჯერჯერობით.
>> ასე რომ, ჩვენ უნდა გააცნოს იდეა შემოგვიერთდით.
და უერთდება, ალბათ, ყველაზე complex--
ეს მართლაც ყველაზე რთული ოპერაცია ჩვენ ვაპირებთ ვისაუბროთ ვიდეო.
ისინი ცოტა რთული, მაგრამ ერთხელ თქვენ შეეგუონ მას,
ისინი, ფაქტობრივად, არ არის ძალიან ცუდი.
ეს არის მხოლოდ სპეციალური შემთხვევაში SELECT.
ჩვენ ვაპირებთ, რომ შეარჩიოთ კომპლექტი სვეტები მაგიდა მიერთების
მეორე მაგიდა ზოგიერთ პრედიკატს.
>> ამ შემთხვევაში, ვიფიქროთ, რომ მინდა ამას მაგიდა არის ერთი წრე აქ,
მაგიდაზე ორი არის კიდევ ერთი წრე დასრულდა აქ.
და რომ შემასმენლის ნაწილი შუა, ეს
სახის, როგორიცაა, თუ ფიქრობთ, დაახლოებით როგორც ვენის დიაგრამა, რა
აქვთ მათ საერთო?
ჩვენ გვინდა, რომ ამ ორი მაგიდები საფუძველზე, რაც მათ საერთო აქვთ
და შექმნა ამ ჰიპოთეტური მაგიდა რომ არის შერწყმის ორი ერთად.
ამიტომ, ჩვენ დავინახავთ ამ წელს მაგალითად და შესაძლოა, რომ დავეხმარებით
გარკვევა ეს ცოტა.
იქნებ უნდა აირჩიოთ user.fullname და moms.mother
მომხმარებლებს გაწევრიანების moms მაგიდაზე ყველა სიტუაციაში
სადაც სახელი სვეტი არის იგივე მათ შორის.
და ეს არის ახალი სინტაქსი აქ, ამ შესახებ.
და დედა ..
თუ მე ვაკეთებ მრავალჯერადი მაგიდები ერთად, მე შეუძლია მიუთითოს მაგიდასთან.
მე შეიძლება გამოიყოს, კერძოდ, რომ ძალიან ბოლოში არსებობს.
მე შეიძლება გამოიყოს სახელი სვეტი მომხმარებლებს მაგიდა
საწყისი სახელი სვეტი moms მაგიდა, რომლებიც otherwise--
თუ ჩვენ უბრალოდ თქვა სახელი უდრის სახელი, რომელიც არ
არაფერს ნიშნავს.
ჩვენ გვინდა, რომ იქ, სადაც ისინი ემთხვევა.
>> ასე რომ, მე შეუძლია მიუთითოს, მაგიდა და სვეტის სახელი შემთხვევაში სიტუაცია
სადაც ეს იქნება გაურკვეველია რა მე ვსაუბრობ.
ასე რომ, ყველა მე ვაკეთებ არ ვარ ვამბობ, რომ ეს სვეტი ამ მაგიდასთან,
და რომ ძალიან ზუსტი.
ასე რომ კიდევ ერთხელ, მე შერჩევით სრული სახელი და დედის სახელი
საწყისი მომხმარებლის მაგიდა გაერთიანებულს ერთად moms მაგიდაზე ყველა სიტუაციაში
სადაც ისინი იზიარებენ, რომ column-- ისინი იზიარებენ, რომ სახელი ცნება.
>> ასე რომ, აქ მაგიდები გვქონდა ადრე.
ეს არის სახელმწიფო, ჩვენი მონაცემთა ბაზის ის არსებობს ახლავე.
ინფორმაცია ჩვენ მოპოვების არის ეს უნდა დაიწყოს.
ეს არის ახალი მაგიდა, ჩვენ ვაპირებთ უნდა შეიქმნას აერთიანებს ამ ერთად.
და შენიშნავს, რომ ჩვენ არ შეფერადება Newman ის ზედიზედ მომხმარებლის მაგიდა,
და ჩვენ არ შეფერადება Kramer ის ზედიზედ moms მაგიდა
იმიტომ, რომ არც ერთი არსებობს ორივე sets-- ორივე მაგიდები.
>> ერთადერთი ინფორმაცია, რომელიც საერთო მათ შორის არის ჯერი ორივე მაგიდები
და gcostanza არის ორივე მაგიდები.
ასე რომ, როდესაც ჩვენ გავაკეთებთ SQL შემოგვიერთდით, რასაც ჩვენ მივიღო და ჩვენ ამით რეალურად მიიღოს.
ეს ერთგვარი დროებითი ცვლადი.
ეს იგივეა, ჰიპოთეტური შერწყმის ორი მაგიდები.
ჩვენ რეალურად კიდევ რაღაც ასე, სადაც
ჩვენ გაერთიანდა მაგიდები ინფორმაცია, რომ მათ საერთო აქვთ.
>> ასე რომ შეამჩნია, რომ users.username და moms.username სვეტი,
ეს არის ზუსტად იგივე.
ეს იყო ინფორმაცია, რომ იყო თანმიმდევრული მომხმარებლებს
მაგიდა და moms მაგიდასთან.
ასე რომ, ჩვენ შეუერთდა მათ ერთად.
ჩვენ განადგურდეს Kramer, რადგან მას არ არსებობს მომხმარებლებს მაგიდა,
და ჩვენ განადგურდეს Newman, რადგან მას არ არსებობს moms მაგიდასთან.
ასე რომ, ეს არის უსაფუძვლო შერწყმა გამოყენებით შემოგვიერთდით ოპერაციის SELECT.
>> და მაშინ ჩვენ ეძებდნენ მომხმარებლის სრული სახელი და მომხმარებლის დედა,
და ასე რომ, ეს არის ინფორმაცია, რომ ჩვენ რომ მიიღონ საერთო შეკითხვაზე
რომ ჩვენ დამზადებული SELECT.
ასე რომ, ჩვენ შეუერთდა მაგიდები ერთად და ჩვენ მოპოვებული იმ ორი მწკრივი,
და ისე, რომ ის, რაც ჩვენ არ მიიღოს.
მაგრამ SQL უერთდება სახის რთული.
თქვენ, ალბათ, ამას არ გააკეთებს მათ ძალიან ბევრი, მაგრამ მხოლოდ გარკვეული წარმოდგენა ჩონჩხი
რომ თქვენ შეიძლება გამოიყენოთ შერწყმა ორი მაგიდები ერთად, თუ საჭირო.
ბოლო ორი არის ცოტა მარტივი გპირდებით.
ასე განახლებაზე, ჩვენ შეგვიძლია გამოვიყენოთ UPDATE შეცვალოს ინფორმაცია მაგიდა.
ზოგადი ფორმატი განახლების ზოგიერთი მაგიდა, მითითებული ზოგიერთი სვეტი გარკვეული მნიშვნელობა
სადაც რამდენიმე შემასმენლის კმაყოფილია.
ასე მაგალითად, ჩვენ დაგვჭირდება განახლება მომხმარებლებს მაგიდა
და მითითებული დაგავიწყდათ იადა იადა, სადაც ID ნომერი 10.
>> ასე რომ, ამ შემთხვევაში, ჩვენ განახლებაზე მომხმარებლები მაგიდასთან.
პირადობის ნომერი 10 რომ პირველი რიგის იქ,
და ჩვენ გვინდა, რომ განახლება პაროლი იადა იადა.
და ისე, რომ, რა მოხდებოდა.
ეს საკმაოდ მარტივია, არა?
ეს არის უბრალოდ ძალიან მარტივია მოდიფიკაცია მაგიდასთან.
>> წაშლა ოპერაცია გამოიყენება ამოიღონ ინფორმაციას მაგიდასთან.
DELETE FROM table WHERE ზოგიერთი შემასმენლის კმაყოფილია.
ჩვენ გვინდა, რომ წაშლა მომხმარებლის მაგიდა მაგალითად
სადაც სახელი არის Newman.
ალბათ, ხვდებით, რა ხდება მოხდება მას შემდეგ, რაც ჩვენ შეასრულოს, რომ SQL
შეკითხვაზე, Newman წავიდა მაგიდასთან.
>> ასე რომ, ყველა ეს ოპერაციები, როგორც მე უკვე აღვნიშნე, ძალიან ადვილია ამის გაკეთება phpMyAdmin.
ეს არის ძალიან მოსახერხებელი ინტერფეისი.
მაგრამ ეს არ მოითხოვს სახელმძღვანელო ძალისხმევა.
ჩვენ არ გვინდა დასაქმება მექანიკური ძალისხმევა.
ჩვენ გვინდა, ჩვენი პროგრამების ამისათვის ჩვენთვის, არა?
ასე რომ, ჩვენ დაგვჭირდება, ამ პროგრამულად.
ჩვენ გვინდა, რომ ითვალისწინებდეს SQL და რაღაც უნდა გააკეთოს ეს ჩვენთვის.
>> მაგრამ რა ჩვენ ვხედავთ, რომელიც საშუალებას აძლევს ჩვენს პროგრამულად რაღაც?
ჩვენ ვნახეთ PHP, არა?
იგი წარუდგენს ზოგიერთი დინამიზმის ჩვენს პროგრამებს.
ასე რომ, საბედნიეროდ, SQL და PHP ითამაშოს ძალიან ლამაზად ერთად.
არსებობს ფუნქცია PHP მოუწოდა შეკითხვაზე, რომელიც შეიძლება იქნას გამოყენებული.
და თქვენ ვერ გაივლის პარამეტრი ან არგუმენტი
შეკითხვის SQL query, რომ გსურთ, რათა შესრულდეს.
და PHP ამის გაკეთება თქვენი სახელით.
>> ასე რომ, მას შემდეგ, რაც თქვენ უკავშირდება თქვენს მონაცემთა ბაზაში, PHP,
არსებობს ორი პრაიმერის თქვენ ამის გაკეთება.
არსებობს რაღაც მოუწოდა MySQLi და რაღაც მოუწოდა სახალხო დამცველის აპარატი.
ჩვენ არ წასვლას დიდი თანხის დეტალური არსებობს.
In CS50 ჩვენ ვიყენებთ სახალხო დამცველის აპარატი.
მას შემდეგ, რაც თქვენ უკავშირდება თქვენს მონაცემთა ბაზაში, თქვენ
ამის შემდეგ შეგიძლიათ გააკეთოთ შეკითხვებს თქვენს მონაცემთა ბაზაში გავლით შეკითხვებს არგუმენტები
to PHP ფუნქციები.
და როდესაც თქვენ, რომ თქვენ შესანახად შედეგად დადგენილი ასოციაციურ მასივში.
>> და ჩვენ ვიცით, თუ როგორ უნდა იმუშაოს ასოციაციური მასივების PHP.
ასე რომ, მე შეიძლება ითქვას, მოსწონს ეს $ results--
ეს არის PHP ტოლია შეკითხვაზე.
და შემდეგ შიგნით შეკითხვის ფუნქცია, რომ არგუმენტი
რომ მე გავლით შეკითხვის რომ ჰგავს SQL.
და ის ფაქტი, რომ SQL.
სწორედ შეკითხვის სიმებიანი რომ მე მინდა შეასრულოს ჩემს მონაცემთა ბაზაში.
>> ასე რომ, წითელი, ეს არის PHP.
ეს არის SQL, რომ მე ვარ ინტეგრაციის PHP მიღების
ეს არგუმენტი შეკითხვის ფუნქცია.
მინდა აირჩიოთ fullname საწყისი მომხმარებლის სადაც საიდენტიფიკაციო ნომერი ტოლია 10.
და მაშინ იქნებ შემდეგ მე ვაკეთებ, რომ, შეიძლება ითქვას, რაღაც მსგავსი.
მინდა ამობეჭდოთ გაგზავნა მადლობა შესასვლელად.
>> და მე მინდა, რომ ეს interpolate-- მინდა რომ interpolate $ შედეგები fullname.
ასე რომ, ის, თუ როგორ ვმუშაობ, რომ ასოციაციურ მასივში, რომ მე მივიღე უკან.
$ შედეგები fullname გვინდა ძირითადად დასრულდება მდე ბეჭდვა,
მადლობა შესასვლელად, ჯერი Seinfeld.
ეს იყო სრული სახელი სადაც idnum ტოლია 10.
>> ასე რომ, ყველა მე ვაკეთებ არის მე, ახლა მე ინახება
ჩემს შეკითხვაზე, შედეგების ჩემს შეკითხვაზე და შედეგების ასოციაციურ მასივში,
და fullname არის სახელი სვეტი მე დღითიდღე.
ასე რომ, ჩემი გასაღები შედეგები ასოციაციურ მასივში, რომ მინდა.
ასე რომ, მადლობა შესასვლელად, $ შედეგები, fullname ამობეჭდოთ, გამყარებაში
მარჯვენა შორის იმ curly braces, ჯერი Seinfeld.
და მე მინდა ამობეჭდოთ გაგზავნა მადლობა შესასვლელად ჯერი Seinfeld.
>> ახლა, ჩვენ, ალბათ, არ მინდა, რომ მყარი კოდი რამ, როგორიცაა, რომ, არა?
ჩვენ დაგვჭირდება რაღაც ბეჭდვითი f, სადაც ჩვენ შეგვიძლია ჩავანაცვლოთ და შესაძლოა
შეაგროვოს სხვადასხვა ინფორმაციას, ან იქნებ აქვს შეკითხვის პროცესი
სხვადასხვა ინფორმაცია.
ასე რომ, შეკითხვაზე, შეკითხვის ფუნქცია აქვს ეს ცნება ერთგვარი სათადარიგოთა
ძალიან ჰგავს ბეჭდვითი ვ პროცენტს s და პროცენტი გ, არის კითხვის ნიშნები.
>> და ჩვენ შეგვიძლია გამოვიყენოთ კითხვა ნიშნები ძალიან ანალოგიურად
ბეჭდვა ვ შემცვლელი ცვლადები.
ასე რომ, შესაძლოა თქვენი მომხმარებლის ხართ ადრე, და თქვენ გადაარჩინა მათი მომხმარებლის ID ნომერი
ამ $ _session of PHP super გლობალური გასაღები ID.
ასე რომ, შესაძლოა, მას შემდეგ რაც ხართ შესული სისტემაში, თქვენ მითითებული $ _session ID ტოლია 10
ექსტრაპოლაციის მაგალითზე ჩვენ ვნახეთ, მეორე წინ.
>> ამიტომ, როდესაც ჩვენ რეალურად შეასრულოს ამ შეკითხვის შედეგების ახლა,
ეს იქნებოდა დანამატის 10, ან რასაც $ _SESSION ID მნიშვნელობა.
ასე რომ, რომელიც საშუალებას გვაძლევს ცოტა უფრო დინამიური.
ჩვენ არ კოდირების რამ აღარ.
ჩვენ გადარჩენის ინფორმაცია სადღაც და მერე
ჩვენ შეგვიძლია გამოვიყენოთ ეს ინფორმაცია კიდევ ერთხელ უნდა ერთგვარი განზოგადება, რაც ჩვენ გვინდა გავაკეთოთ,
და მხოლოდ დანამატი და ცვლილება ქცევის ჩვენი გვერდი
რის საფუძველზე მომხმარებლის ID ნომერი რეალურად მას შემდეგ, რაც ისინი შესული სისტემაში.
ასევე შესაძლებელია, თუმცა, რომ თქვენი შედეგების მითითებული
შეიძლება შედგებოდეს მრავალი რიგები.
ამ შემთხვევაში, თქვენ უნდა მასივი მასივების
მასივი ასოციაციური მასივების.
თქვენ უბრალოდ უნდა iterate მეშვეობით.
და ჩვენ ვიცით, როგორ iterate მეშვეობით მასივი PHP, არა?
ასე რომ, აქ არის ალბათ ყველაზე კომპლექსი, რაც ჩვენ ვნახეთ ჯერჯერობით.
ეს ფაქტიურად აერთიანებს სამ ენაზე ერთად.
>> აქ წითელი, ეს არის გარკვეული HTML.
მე აშკარად starting-- ეს გვიჩვენებს snippet ზოგიერთი HTML, რომ მაქვს.
მე დაწყებული ახალი პუნქტი, რომელიც ამბობს, რომ moms სატელევიზიო Seinfeld.
და მაშინ დაუყოვნებლივ რის შემდეგაც მე დაწყებული მაგიდასთან.
და შემდეგ, მე აქვს გარკვეული PHP, არა?
მაქვს ყველა ამ PHP კოდი არსებობს.
მე აშკარად აპირებს, რომ შეკითხვაზე.
და რათა შეკითხვაზე, მე ვაპირებ გამოყენებით SELECT დედები moms.
>> ასე რომ, ეს getting-- ეს არის SQL.
ასე რომ, ლურჯი SQL.
წითელი ჩვენ ვნახეთ, მეორე წინ იყო HTML.
და მწვანე აქ არის PHP.
ასე რომ, მე მიღების მოთხოვნის ჩემს მონაცემთა ბაზაში, მე
შერჩევის ყველა დედები moms მაგიდასთან.
არა მხოლოდ შევიწროება ის ქვემოთ კონკრეტული ზედიზედ, მე გეკითხებით ყველა მათგანი.
>> მერე შეამოწმეთ თუ შედეგი არ არის არ უდრის უდრის ყალბი.
ეს არის მხოლოდ ჩემი გზა შემოწმების სახის საქართველოს თუ შედეგი არ არის ტოლი null,
რომ ჩვენ ვხედავთ გ მაგალითად.
ძირითადად ეს მხოლოდ შემოწმების რათა დარწმუნებული ვარ, რომ ის რეალურად მივიღე მონაცემები უკან.
იმიტომ, რომ მე არ მინდა, რომ დაიწყოს ბეჭდვა out მონაცემები, თუ მე არ მიიღოს ნებისმიერი მონაცემები.
მაშინ თითოეული შედეგების შედეგად foreach სინტაქსი PHP, ყველა მე ვაკეთებ
არის ბეჭდვის out $ შედეგი დედები.
ასე რომ, მე ვაპირებ, რომ მიიღოთ ნაკრები ყველა დედები ყოველ
ეს მასივი ასოციაციურ მასივების და მე დაბეჭდვისას
თითოეული მათგანი, როგორც საკუთარი რიგის მაგიდასთან.
და ეს მართლაც საკმაოდ ბევრი ყველა იქ არის ეს.
მე ვიცი, რომ ცოტა ცოტა ხდება აქ
ამ ბოლო მაგალითი მასივების მასივების მასივების ასოციაციური მასივების.
მაგრამ ეს ნამდვილად არ მხოლოდ იმატებს ქვემოთ SQL მიღების შეკითხვაზე,
როგორც წესი, შერჩევით შემდეგ ჩვენ უკვე ბოლო ინფორმაციის მაგიდა,
და შემდეგ უბრალოდ უბიძგებენ მას.
>> და ეს არის, რომ ჩვენ გაიყვანოს ეს out ამ კონკრეტულ შემთხვევაში.
ჩვენ გვინდა ამონაწერი ყველა ინდივიდუალური დედები საწყისი moms მაგიდასთან.
ჩვენ მივიღეთ მთელი რიგი მათ, და ჩვენ გსურთ iterate მეშვეობით და ამობეჭდოთ
თითოეული.
ასე რომ კიდევ ერთხელ, ეს არის ალბათ ყველაზე რთული მაგალითად
ჩვენ ვნახეთ, რადგან ჩვენ შერევით სამი სხვადასხვა ენებზე ერთად, არა?
>> კიდევ ერთხელ, ჩვენ HTML აქ წითელი, შერეული ზოგიერთი SQL აქ ლურჯი,
შერეული ზოგიერთი PHP მწვანე.
მაგრამ ყველა ამ თამაში ლამაზად ერთად, ის
უბრალოდ საკითხია ვითარდება კარგი ჩვევები ისე, რომ თქვენ შეგიძლიათ მიიღოთ
მათ ერთად მუშაობა გზა გსურთ.
და ერთადერთი გზა, მართლაც რომ პრაქტიკაში, პრაქტიკა, პრაქტიკა.
მე Doug Lloyd, ეს არის CS50.