>> [השמעת מוסיקה]
דאג LLOYD: בקטעי הווידאו שלנו בנושאי פיתוח האינטרנט,
אנחנו כבר הזכרנו את המושג מסד הנתונים כמה פעמים, נכון?
אז מסד נתונים אתה בוודאי מכיר מ
אומר באמצעות Microsoft Excel או גיליונות אלקטרוניים של Google.
זה באמת רק מאורגן קבוצה של שולחנות, שורות ועמודות.
>> ובסיס נתונים שבו החנויות באתר שלנו
מידע חשוב לאתר האינטרנט שלנו לעבוד כמו שצריך.
שוב, דוגמא נפוצה מאוד כאן הוא אחסון שמות משתמש וסיסמאות
במסד נתונים, כך שכאשר משתמש נכנס לאתר האינטרנט שלנו,
מסד הנתונים ניתן שאילתא לראות אם משתמש שקיים באתר.
ואם הם, בדיקה ש הסיסמה שלהם היא נכונה.
ואם הסיסמה שלהם היא נכונה, אז אנחנו יכולים לתת להם כל מה שדף
הם מבקשים.
>> אז אתה כנראה, שוב, מוכר עם הרעיון הזה מ- Excel או Google
גיליונות אלקטרוניים.
יש לנו מאגרי מידע, שולחנות, שורות ועמודות.
וזה באמת סוג של הסט הבסיסי
התמוטטות היררכית כאן.
אז הנה גיליון אלקטרוני Excel.
ואם אי פעם נפתח או תכנית אחרת דומה
אתה יודע כי אלה הם כאן 1 rows--, 2, 3, 4, 5, 6, 7.
אלה הם עמודים.
>> אולי כאן למטה, אם כי ייתכן ש לא להשתמש בתכונה זו מאוד much--
אני להתקרב in-- יש לנו הרעיון הזה של גיליון.
אז אולי גיליונות אלה, אם אני חלופי קדימה ואחורה,
שולחנות שונים ש קיימים במסד הנתונים שלי.
ואם ימשיכו כל הדוגמא אגב, שמו של מסד נתונים זה
הוא 1 ספר.
אולי יש לי ספר 2 וספר 3.
אז כל קובץ Excel הוא מסד הנתונים, כל גיליון הוא שולחן,
ובתוך כל שולחן יש לי הרעיון הזה של שורות ועמודות.
>> אז איך אני עובד עם מסד נתונים זה?
כיצד אוכל לקבל מידע ממנו?
ובכן יש שפה שנקראת SQL-- שאני בדרך כלל רק קורא Sequel--
והיא עומדת ל שפת שאילתות מובנית.
וזה הוא שפת תכנות, אבל זה תכנות מוגבל למדי
שָׂפָה.
זה לא בדיוק כמו אחרים כי יש לנו עבדנו עם.
אבל המטרה של זה שפת תכנות
הוא שאילתת מסד נתונים, ל תשאל מידע של מסד הנתונים,
למצוא מידע ב מסד הנתונים, וכן הלאה.
>> אנחנו גם, בCS50-- וזה מאוד פלטפורמה משותפת, זה נקרא MySQL.
זה מה שאנו משתמשים בקורס.
זה קוד פתוח פלטפורמה שקובעת
database-- יחסי שנקרא מסד הנתונים, בצורה יעילה.
אנחנו לא צריכים לקבל ליותר מדי פרטים
על מה מסדי נתונים יחסיים הוא.
אבל שפת SQL היא מאוד מיומן בעבודה
עם MySQL ואחר דומה סגנונות של מסדי נתונים יחסיים.
>> והתקנות רבות של MySQL לבוא עם משהו
phpMyAdmin נקרא, ש הוא משתמש גרפי
interface-- GUI-- ש עושה את זה קצת יותר
ידידותי למשתמש לבצע שאילתות מסד נתונים,
בגלל מסדי נתונים לא משמשים רק על ידי מתכנתים מתקדמים, נכון?
לפעמים יש עסקים קטנים אלה,
והם לא יכולים להרשות לעצמו לשכור צוות של מתכנתים,
אבל הם עדיין צריכים לאחסן מידע במסד נתונים.
>> משהו כמו phpMyAdmin עושה את זה קל מאוד עבור מישהו
שמעולם לא תכנת לפני ל להרים ולהכיר כיצד
לעבוד עם מסד נתונים.
הבעיה היא, phpMyAdmin, ואילו זה כלי נפלא ללמידה
על מאגרי מידע, זה ידני.
אתה הולך להתחבר ל זה ולבצע פקודות וסוג
דברים באופן ידני.
>> וכפי שאנו מכירים משלנו דוגמא על תכנות האינטרנט PHP,
יש לעשות באופן ידני דברים באתר שלנו,
אם אנחנו רוצים דינמיים, מגיבים פעילים אתר, אולי לא הגישה הטובה ביותר.
ברצוננו למצוא דרך אולי להפוך איכשהו זה.
ו- SQL יאפשר לנו לעשות את זה.
לכן, כאשר אנחנו הולכים ל להתחיל לעבוד עם SQL,
אנחנו צריכים ראשון יש מסד הנתונים לעבוד איתו.
יצירת מסד נתונים משהו שאתה כנראה
יעשה בphpMyAdmin, כי אתה רק צריך לעשות את זה פעם אחת,
והתחביר לכך הוא הרבה יותר פשוט.
זה הרבה יותר קל לעשות את זה בממשק משתמש גרפי
מאשר להקליד את זה כפקודה.
הפקודה יכולה לקבל קצת מסורבלת.
באופן דומה, יצירת שולחן יכולה לקבל לא מעט מסורבל, כמו גם.
וכך דברים כמו יצירת מסד נתונים ויצירת שולחן, שבו אתה נמצא
כנראה רק הולך לעשות once-- פעם אחת לכל שולחן, פעם בdatabase--
זה בסדר לעשות את זה ב ממשק גרפי.
בתהליך של יצירת שולחן, אתה
גם צריך לציין את כל עמודות שתהיינה בטבלה.
איזה סוג של מידע לעשות אתה רוצה לאחסן בטבלה?
אולי השם של משתמש ותאריך לידה, סיסמא, מספר זיהוי משתמש, ואולי
עיר ומדינה, נכון?
>> ועל כל פעם שאנחנו רוצים להוסיף משתמש למסד הנתונים, אנחנו רוצים לקבל את כל שש
אלה פיסות מידע.
ואנחנו עושים את זה על ידי הוספה שורות לטבלה.
אז אנחנו יוצרים מסד הנתונים ראשון, אז ליצור טבלה.
כחלק מיצירה שולחן, אנחנו מתבקשים
כדי לציין כל עמודה ש ברצוננו בטבלה זו.
ואז כפי שאנחנו מתחילים להוסיף מידע באתר
ושאילתא מסד נתונים יותר generally-- לא רק הוספה,
אבל אנחנו כל דבר אחר do-- נהיה התמודדות
עם שורות של הטבלה, שהוא אחד המידע של משתמש מכל הקבוצה.
>> אז כל עמודת SQL מסוגלת מחזיק נתונים של סוג נתונים מסוים.
אז אנחנו סוג של בוטלו זה רעיון של סוגי נתונים ב- PHP,
אבל הם יחזרו לכאן ב- SQL.
ויש הרבה סוגי נתונים.
הנה רק 20 מהם, אבל זה אפילו לא כולם.
אז יש לנו רעיונות כמו INTs-- Integers-- אנחנו כנראה יודעים
שהטור הזה יכול להחזיק מספרים שלמים.
ויש וריאציות thereon-- SMALLINT, TINYINT, MEDIUMINT, bigint.
אולי אנחנו לא תמיד צריכים ארבעה ביסים.
אולי אנחנו צריכים שמונה בתים, וכדי ש ניתן להשתמש בוריאציות אלה במספרים שלמים
להיות יעיל קצת יותר מקום.
אנחנו יכולים לעשות את המספרים עשרוניים, אנחנו יכול לעשות מספרי נקודה צפה.
אלה הם די דומים.
יש כמה הבדלים, ואם היית
רוצה להסתכל למעלה סוג SQL של ​​מדריך, אתה
יכול לראות מה קל הבדלים ביניהם.
>> אולי אנחנו רוצים לאחסן מידע על תאריך ושעה.
אולי אנחנו עוקבים אחרי כאשר המשתמש הצטרף אתר האינטרנט שלנו,
ואז אולי אנחנו רוצים יש טור זה
זמן תאריך או חותמת ש מציין כאשר המשתמש למעשה
נרשם.
אנחנו יכולים לעשות את הגיאומטריות וLineStrings.
זהו למעשה די מגניב.
אנו יכולים למפות את אזור גיאוגרפי באמצעות
GIS מרכז לתכנן את אזור.
אז בעצם יכול לאחסן סוג ש מידע בעמודת SQL.
>> טקסט הוא רק כתמים ענקיים של טקסט, אולי.
Enums הן סוג מעניינת של.
הם קיימים בפועל בג אנחנו לא לדבר עליהם, כי הם לא
נורא נפוץ, לפחות CS50.
אבל זה סוג נתוני הנחקר, ש הוא מסוגל להחזיק ערכים מוגבלים.
>> דוגמא ממש טובה כאן תהיה כדי ליצור enum בי שבע
ערכים אפשריים הם יום ראשון, יום שני, יום שלישי, יום רביעי, יום חמישי, יום שישי,
יום שבת, נכון?
שיום סוג נתונים של שבוע לא קיים,
אבל אנחנו יכולים ליצור סוג הנתונים מנויים כגון
שטור שרק אי פעם יכול להחזיק אחד משבעת ערכים האפשריים אלה.
אנחנו כבר מנויים כל של הערכים האפשריים.
>> אז יש לנו CHAR וvarchar, ויש לי הצבע ירוק אלה
בגלל שאנחנו בעצם הולך לקחת שני
לדבר על ההבדל בין שני הדברים האלה.
אז CHAR, שלא כמו C שבי CHAR היה דמות אחת,
ב- SQL CHAR מתייחס ל מחרוזת באורך קבועה.
וכאשר אנו יוצרים זה טור, שאנחנו באמת
ניתן לציין את האורך של המחרוזת.
>> אז בדוגמא זו, אפשר לומר CHAR (10).
זה אומר שכל אלמנט של עמודה ש
יכלול 10 בתים של מידע.
לא יותר, לא פחות.
אז אם אנחנו מנסים ולהכניס ל15 קצת או אלמנט 15 תווים
או ערך לטור זה, אנחנו מקבלים רק 10 הראשונים.
אם אנחנו שמים בשני ערך ארוך אופי,
אנחנו הולכים יש שני דמויות, ולאחר מכן שמונה עקיצות null.
אנחנו אף פעם לא נהיה יותר יעילים מזה.
>> Varchar הוא כמו סוג של הרעיון של מחרוזת שלנו
שאנחנו מכירים עם מC או מPHP.
זה מחרוזת באורך משתנה.
וכשאתה יוצר טור זה, אתה פשוט
לציין את האורכים המרביים אפשריים.
אז אולי 99, או בכינוי 255.
זה יהיה האורך המרבי.
ולכן אם אנחנו אחסון 15 מחרוזת תווים,
היינו להשתמש 15 בתים, אולי 16 בתים עבור שליחות קטלנית null.
אם היינו אחסון שלוש מחרוזת תווים,
היינו להשתמש בשלוש או ארבעה בתים.
אבל אנחנו לא נשתמש 99 מלאים.
>> אז למה יש לנו את שניהם?
ובכן, אם אנחנו צריכים להבין איך משהו ארוך הוא עם varchar,
יש לנו לסוג של לחזר על פנים זה בדיוק כמו שעשינו בC
ולהבין היכן שייעצר.
לעומת זאת, אם אנחנו יודעים שכל מה ש בטור זה הוא 10 בתים, אולי
אנחנו יודעים את המידע הזה, אנחנו יכולים לקפוץ 10 בתים, 10 בתים, 10 בתים, 10 בתים,
ותמיד למצוא את החל מהמחרוזת.
>> אז אולי יש לנו כמה שטח מבוזבז עם CHAR,
אבל אולי יש מסחר את שיש מהירות טובה יותר
בניווט במסד הנתונים.
אבל אולי אנחנו רוצים גמישות של varchar
במקום having-- אם CHAR שלנו היה 255, אבל רוב המשתמשים שלנו
היו המזינים רק שלושה או ארבעה בתים בשווי של מידע או שלושה או ארבעה
תווים בשווי של מידע.
>> אבל חלק מהמשתמשים משתמשים 255 שלמים, אולי
Varchar יהיה מתאים יותר לשם.
זה סוג של סחר מ, ו בדרך כלל למטרות של CS50,
אתה לא צריך לדאוג יותר מדי על אם אתה משתמש בCHAR או varchar.
אבל בעולם האמיתי, הדברים האלה אל משנה כי כל עמודות אלה
תופס שטח פיזי ממשי.
ומרחב פיזי, ב עולם אמיתי, מגיע בפרמיה.
>> אז שיקול אחד אחר כאשר אתה בונה שולחן
הוא לבחור עמודה אחת להיות מה שנקרא מפתח ראשי.
ומפתח ראשי הוא טור שבו כל אחד ערך הוא ייחודי.
וזה אומר שאתה יכול בקלות לבחור שורה אחת רק מלהסתכל
במפתח הראשי של שורה ש.
כך למשל, אתה בדרך כלל, עם משתמשים,
לא רוצה שני משתמשים ש יש את אותו מספר זיהוי המשתמש.
ואז אולי יש לך המון מידע,
ואולי שני משתמשים יכולים יש את אותו name--
יש לך ג'ון סמית וג'ון סמית '.
זה לא בהכרח בעיה, בגלל שיש מספר רב של אנשים
בעולם בשם ג'ון סמית '.
אבל יש לנו מספר זיהוי משתמש אחד בלבד 10, משתמש אחד זיהוי מספר 11, 12, 13.
אין לנו שני משתמשים עם אותו המספר,
ואז אולי מספרי זיהוי המשתמש יהיה מפתח ראשי טוב.
>> אין לנו כל שכפול, ואנחנו יכולים עכשיו באופן ייחודי
לזהות כל שורה רק ע"י הסתכלות בטור זה.
בחירת מפתחות ראשיים יכול למעשה לעשות פעולות שולחן הבאות
הרבה יותר קל, כי אתה יכול למנף העובדה ששורות מסוימות
להיות ייחודי, או עמודה מסוימת של מסד נתונים או השולחן שלך
יהיה ייחודי להרים שורות מסוימות החוצה.
>> גם אתה יכול לקבל עיקרי משותף מפתח, שבו אתה עלול למצוא את האירוע
לשימוש, שהוא רק שילוב של שתי עמודות ש
הוא מתיימר להיות ייחודי.
אז אולי יש לך אחד טור זה וכארוחת בוקר,
עמודה אחת זה אחד, שתיים, ושלושה, אבל אתה היחיד שאי פעם
יש לי A1 בודד, בודד A2, וכן הלאה וכן הלאה.
אבל אולי יש לך B2, C2, או A1, A2, A3, A4.
אז ייתכן שיש לי כמרובה, מרובה ארוחת בוקר, אלה מרובים, זוגות רבים,
אבל אתה יכול רק פעם יש לי A1 היחיד, B2, C3, וכן הלאה.
אז כמו שאמרתי, SQL הוא שפת תכנות,
אבל יש לו אוצר מילים מוגבלות למדי.
זה לא ממש רחב כמו C ו- PHP ושפות אחרות
כי אנחנו מדברים בקורס.
זה מפורט יותר שפה ממה שאנחנו
הולך לדבר על זה ב וידאו, כי בסרט הזה
אנחנו הולכים לדבר על ארבע פעולות ש
ניתן לבצע על שולחן.
>> יש יותר מזה.
אנחנו יכולים לעשות יותר מזה, אבל למטרות שלנו,
אנחנו בדרך כלל הולכים להיות באמצעות רק ארבעה להוסיף operations--,
בחר, לעדכן, ולמחוק.
וכנראה שאתה יכול באופן אינטואיטיבי מניח מה כל ארבעת הדברים האלה לעשות.
אבל נלך לקצת פירוט על כל אחד ואחד.
>> אז למטרות של זה וידאו, נניח
יש לנו שתי הבאים שולחנות באתר אחד.
יש לנו משתמשי שולחן נקרא שיש ארבעה columns-- מספר תעודת זהות, שם משתמש,
סיסמא, ושמו מלא.
ויש לנו שני שולחן באותו מסד נתונים
בשם אמהות שרק מאחסנת מידע על שם משתמש ואמא.
אז לכל דוגמאות בסרטון הזה, אנחנו
להיות באמצעות מסד נתונים זה ו עדכונים לאחר אותו.
אז בואו נגיד שאנחנו רוצים להוסיף מידע לשולחן.
זה מה שעושה פעולת ההוספה.
בלהסביר את כל פקודות אלה, אני הולך
כדי לתת לך שלד כללי לשימוש.
כי בעצם, השאילתות הולכים מבט די דומה,
אנחנו פשוט הולכים להיות שינוי פיסות מידע שונות במקצת
לעשות דברים שונים עם השולחן.
>> אז לINSERT, השלד נראה כמו סוג של זה.
אנחנו רוצים להכניס לתוך שולחן מסוים.
אז יש לנו סוגריים פתוחים ורשימה של עמודות
כי אנחנו רוצים לשים ערכים ל.
סוגריים קרובים, הבא ערכים, ולאחר מכן
שוב, אנו מוסיפים את הערכים אנחנו רוצים לשים בטבלה.
>> אז דוגמא לכך יהיה הבא.
אני רוצה להכניס לטבלה משתמשי columns-- הבא
שם משתמש, סיסמא, ושם מלא.
אז שורה חדשה שבו אני שם את בשלושת טורים אלה ואנחנו
הולך לשים בערכים ניומן, USMAIL, וניומן.
אז במקרה הזה, אני לשים ניומן האותיות הקטנות
לעמודת שם המשתמש, הסיסמה USMAIL, ושמו המלא ההון N
ניומן לעמודה שם המלאה.
>> אז הנה מה בסיס הנתונים נראה כמו לפני.
הנה מה ששולחן המשתמשים ב עליון נראה כמו לפני שעשינו את זה.
לאחר שנבצע את זה שאילתא, אנחנו מקבלים את זה.
הוספנו שורה חדשה לטבלה.
אבל שם לב זה דבר אחד שלא לציין,
אבל איכשהו יש לי ערך ל, שהוא 12 זה ממש כאן.
אני לא אמרתי שאני רוצה לשים את מספר תעודת זהות לשם.
אני רוצה לשים את שם המשתמש, סיסמא, שם מלא.
ואני עשיתי את זה, זה בסדר גמור.
>> אבל יש לי גם 12 זה.
מדוע אני מקבל 12 זה?
ובכן, מתברר ש כאשר אתה מגדיר
טור שהולך להיות שלך מפתח ראשי, שהיא בדרך כלל,
כמו שאמרתי, מספר תעודת זהות.
זה לא תמיד בהכרח הולך להיות מספר תעודת זהות,
אבל זה בדרך כלל רעיון טוב להיות איזשהו ערך מספר שלם.
יש לך אפשרות בphpMyAdmin כשאתה יוצר מסד הנתונים שלך
או השולחן שלך להגדיר ש טור כהגדלה אוטומטי.
>> וזה רעיון ממש טוב כש אתה עובד עם מפתח ראשי,
בגלל שאתה רוצה כל ערך בטור שלהיות ייחודי.
ואם אתה שוכח לציין זה ליותר מאדם אחד,
עכשיו יש לך מצב שבו טור זה כבר לא ייחודי.
יש לך שני כדורי סרק, ולכן אין אתה יכול כבר לזהות באופן ייחודי column--
או שאתה כבר לא יכול באופן ייחודי לזהות שורה מבוססת על טור ש.
זה איבד את כולה ערך כמפתח ראשי.
>> וכך, ככל הנראה, מה שעשיתי כאן מוגדר זיהוי המשתמש
טור לתוספת אוטומטית, כך שכל זמן אני מוסיף מידע לשולחן,
זה יהיה באופן אוטומטי לתת לי ערך עבור המפתח הראשי.
אז אני לא יכול לשכוח לעשות את זה כי מסד הנתונים יעשו את זה בשבילי.
אז זה סוג של נחמד.
ואז בגלל זה אנחנו מקבלים 12 שם, כי יש לי
נקבע שטור עד תוספת אוטומטית.
אם הוספתי מישהו אחר זה יהיה 13, אם אני הוספתי
מישהו אחר שזה יהיה 14, וכן הלאה.
>> אז בואו פשוט לעשות הכנסה נוספת.
אנחנו להכניס לטבלת האמהות, ב בפרט, שם המשתמש ואמא
טור, הערכים קרמר ואבס קרמר.
ואז היה לנו לפני זה.
לאחר שנבצע ש שאילתא SQL, יש לנו את זה.
הוספנו קרמר ואבס קרמר לשולחן האמהות.
>> אז זה הכנסה.
SELECT הוא מה שאנחנו משתמשים כדי לחלץ מידע מהשולחן.
אז ככה אנחנו מקבלים מידע מתוך מסד הנתונים.
ופקודות כך SELECT הולכים להיות לעתים קרובות מאוד בשימוש בתכנות.
הכללי framework-- שלד כללי נראה כך.
בחר קבוצה של עמודות מ שולחן, ולאחר מכן אופציונלי
אתה יכול לציין condition-- או מה שאנחנו קוראים בדרך כלל נשוא,
בדרך כלל אנו משתמשים במונח ב- SQL.
>> אבל זה בעצם מה ש שורות מסוימות שאתה רוצה להגיע.
אם אתה רוצה, במקום לקבל הכל, לצמצם אותו,
זה המקום שבו אתה הייתי עושה את זה.
ואז אופציונלי, אתה יכול גם להורות על ידי עמודה מסוימת.
אז אולי אתה רוצה להיות דברים מסודרים בסדר אלפביתי המבוסס על טור אחד
או המבוסס על סדר אלפביתי אחר.
>> שוב, איפה וORDER BY הם אופציונליים.
אבל הם כנראה נהיה useful-- במיוחד
איפה יהיה שימושי ל לצמצם כדי שלא
לקבל מסד נתונים השלם שלך בחזרה ו צריך לעבד אותו, אתה פשוט מקבל
בחלקים ממנה שאכפת לך.
כך למשל, אולי אני רוצה לבחור מספר תעודת זהות ושם מלא ממשתמשים.
אז מה יכול זה נראה?
אז הנה טבלת המשתמשים שלי.
אני רוצה לבחור idnum וFULLNAME ממשתמשים.
מה אני הולך לקבל?
אני הולך לקבל את זה.
אני לא לצמצם אותה, ולכן אני מקבל מספר תעודת זהות לכל שורה
ואני מקבל מלא שם מכל שורה.
>> אוקיי.
מה אם אני רוצה לבחור סיסמא ממשתמשי WHERE-- אז עכשיו
אני מוסיף מצב, predicate-- שם idnum הוא פחות מ -12.
אז הנה האתר שלי שוב, השולחן שלי משתמשים העליון.
מה אני הולך לקבל אם אני רוצה בחר מידע ש, הסיסמה,
שבו זיהוי משתמש או idnum הוא פחות מ 12?
אני הולך לקבל את זה מידע בחזרה, נכון?
זה קורה כי idnum הוא 10, פחות מ -12, מספר תעודת זהות 11 פחות מ -12.
אני מקבל את הסיסמה לשורות אלה.
זה מה שבקשתי.
מה לגבי זה?
מה אם אני רוצה לבחור כוכב מ שולחן אמהות שבו שם משתמש שווה ג'רי?
אישור, כוכב נבחרים הוא מיוחד סוג של כרטיס פראי שנקרא
שאנו משתמשים כדי לקבל את הכל.
אז הם אומרים בחרו שם משתמש אם פסיק, ש
קרה להיות רק שתי עמודות של טבלה זו,
אני רק יכול לבחור כוכב ולקבל הכל
שם המשתמש שווה ג'רי.
ואז זה מה שאני אקבל אם אני עשיתי את שאילתא מסוימת.
>> עכשיו, מסדי נתונים הם גדול משום שהם מאפשרים
שלנו לארגן את המידע אולי קצת יותר ביעילות מאשר אנחנו
אחרת אולי.
אנחנו לא בהכרח לאחסון כל פיסת המידע רלוונטית
על משתמש באותו השולחן.
היו לנו שני שולחנות שם.
>> אנחנו צריכים לאחסן שמה של האמא של כולם,
ואולי אין לנו ביטחון חברתי מספר, יש לנו תאריך לידה שלהם.
זה לא תמיד צריך להיות באותו השולחן.
כל עוד אנחנו יכולים להגדיר יחסים בין tables--
וזה המקום שבי יחסי ש טווח מסד סוג של מגיע
ללנגן-- כל עוד אנו יכולים להגדיר יחסים בין השולחנות,
אנחנו יכולים סוג של למדר או דברים מופשטים דרך,
שבו יש לנו רק מידע חשוב באמת
אכפת לנו בשולחן של המשתמש.
ואז יש לנו מידע נלווה או מידע נוסף בשולחנות אחרים
שאנו יכולים להתחבר בחזרה לעיקריים שולחן משתמשים בדרך מסוימת.
>> אז הנה יש לנו שני השולחנות האלה, אבל יש קשר ביניהם,
יָמִינָה?
זה נראה כמו שם משתמש יכול להיות משהו
שקיים במשותף בין שני שולחנות שונים אלה.
אז מה אם יש לנו עכשיו מצב שבו אנחנו
רוצה לקבל את השם המלא של משתמש מ השולחן של המשתמש, ואמם של
שם משולחן האמא?
אין לנו דרך להגיע כי כפי שהיא עומדת, נכון?
אין שולחן אחד שמכיל שני שם מלא ואת שמה של האם.
אין לנו האפשרות ש ממה שראינו עד כה.
>> ולכן אנחנו צריכים להציג הרעיון של הצטרפות.
ומצטרף כנראה רוב complex--
זה המבצע המורכב ביותר באמת אנחנו הולכים לדבר על בווידאו.
הם קצת מסובכים, אבל ברגע שאתה מקבל את העניין שלו,
הם בעצם לא רע.
זה רק מקרה מיוחד של SELECT.
אנחנו הולכים לבחור קבוצה של עמודות מטבלת הצטרפות
בשולחן שני בכמה נשוא.
>> במקרה זה, יחשוב על זה ככה זה-- שולחן אחד הוא מעגל אחד לכאן,
שולחן שני הוא מעגל נוסף כאן.
ושחלק הנשוא באמצע, זה
קצת כמו אם אתה חושב על כדיאגרמת ון, מה
יש להם במשותף?
אנחנו רוצים לקשר את שני השולחנות האלה המבוסס על מה שיש להם במשותף
וליצור שולחן היפותטית זו שהוא המיזוג של שני יחד.
אז אנחנו תראו את זה ב דוגמא ואולי זה יעזור לי
לנקות אותו קצת.
אז אולי אתה רוצה לבחור USER.FULLNAME וmoms.mother
ממשתמשים שהצטרפו ב שולחן אמהות בכל מצב
שם עמודת שם המשתמש הוא אותו ביניהם.
וזה חדש תחביר כאן, משתמש זה.
ואמהות ..
אם אני עושה מספר רב של שולחנות יחד, אני יכול לציין בטבלה.
אני יכול להבחין בבפרט שעל בתחתית מאוד שם.
אני יכול להבחין שם המשתמש עמודה של טבלת המשתמשים
מעמודת שם המשתמש של שולחן אמהות, שהם otherwise--
אם אנחנו רק אמרתי את שם המשתמש שווה שם משתמש, שלא ממש
אומר שום דבר.
אנחנו רוצים לעשות את זה שבו הם תואמים.
>> אז אני יכול לציין את השולחן ו שם עמודה במקרה של מצב
שבו זה יהיה ברור על מה אני מדבר.
כך שכל מה שאני עושה שם הוא אני אומר הטור הזה מהשולחן הזה,
ולהיות מאוד מפורש.
אז שוב, אני בחירה שמו מלא ושם אמו
משולחן המשתמשים מקושר יחד עם שולחן אמהות בכל מצב
שבו הם חולקים column-- ש הם חולקים כי רעיון שם משתמש.
>> אז הנה השולחנות שהיו לנו בעבר.
זהו המצב שלנו מסד הנתונים כפי שהיא קיימת עכשיו.
המידע שאנחנו חילוץ זה להתחיל עם.
הלוח זה הוא חדש אנחנו הולכים כדי ליצור שילוב אלה יחד.
ושים לב שאנחנו לא הדגשה השורה של ניומן בשולחן של המשתמש,
ואנחנו לא הדגשה השורה של קרמר בטבלת האמהות
כי אף אחד קיים ב שני sets-- בשני השולחנות.
>> המידע היחיד שהוא במשותף ביניהם הוא ג'רי הוא בשני השולחנות
וgcostanza הוא בשני השולחנות.
ולכן כאשר אנחנו עושים SQL הצטרפות, מה ש get-- ואנחנו עושים בעצם לקבל את זה.
זה סוג של משתנה זמני.
זה כמו היפותטי מיזוג של שני שולחנות.
אנחנו בעצם מקבלים משהו כמו זה, שבו
אנחנו כבר התמזגו יחד את הקערה על הפיה מידע שיש להם במשותף.
>> אז שם לב שusers.username וטור moms.username,
זה בדיוק אותו הדבר.
זה היה המידע ש היה עקבי מהמשתמשים
שולחן ושולחן האמהות.
וכך אנו מיזגנו אותם יחד.
אנו מושלכים קרמר כי הוא לא היה קיים בטבלת המשתמשים,
ואנחנו מושלכים ניומן, כי הוא לא היה קיים בטבלת האמהות.
אז זה המיזוג היפותטי באמצעות פעולת JOIN של SELECT.
>> ואז אנחנו מחפשים שמו של המשתמש המלא ואמו של המשתמש,
ואז זה המידע ש היינו מקבל מהשאילתה הכללית
שעשינו עם SELECT.
אז אנחנו הצטרפתי לשולחנות יחד וחלצנו שתי עמודות אלה,
ואז זה מה שהיינו מקבל.
אבל SQL מצטרף סוג של מסובך.
אתה כנראה לא עושה אותם יותר מדי, אבל רק לקבל קצת מושג של השלד
כי אתה יכול להשתמש כדי למזג שתי שולחנות יחד אם אתה צריך.
שני האחרונים הם קצת פשוט אני מבטיח.
אז עדכון, אנו יכולים להשתמש בעדכון כדי לשנות מידע בטבלה.
הפורמט הכללי הוא עדכון מסוים שולחן, להגדיר כמה עמודת ערך כלשהו
שבו כמה נשוא הוא מרוצה.
כך למשל, אנו עשויים רוצים כדי לעדכן את שולחן המשתמשים
ולהגדיר את הסיסמה לבלה בלה, שבו מספר תעודת הזהות הוא 10.
>> אז במקרה הזה, אנחנו עדכון שולחן המשתמשים.
מספר תעודת הזהות הוא 10 ל שהשורה ראשונה שם,
ואנחנו רוצים לעדכן סיסמא לבלה בלה.
וכדי שזה מה שיקרה.
זה די פשוט, נכון?
זה פשוט מאוד פשוט שינוי לשולחן.
>> DELETE הוא הפעולה שנהגנו להסיר את המידע משולחן.
DELETE משולחן שבו כמה נשוא הוא מרוצה.
אנחנו רוצים למחוק מ שולחן משתמשים לדוגמא
שבו שם המשתמש הוא ניומן.
אתה יכול לנחש מה קורה ל יקרה כאן אחרי שביצוע SQL ש
שאילתא, ניומן הוא נעלם מהשולחן.
>> אז כל הפעולות הללו, כפי שאמרתי, מאוד קל לעשות בphpMyAdmin.
זה ממשק מאוד ידידותי למשתמש.
אבל זה דורש מאמץ ידני.
אנחנו לא רוצים להעסיק מאמץ ידני.
אנחנו רוצים התוכניות שלנו ל לעשות את זה בשבילנו, נכון?
אז אולי רוצים לעשות תכנותי זה.
אנחנו רוצים לשלב SQL ויש לי משהו אחר לעשות את זה בשבילנו.
>> אבל מה שראינו, המאפשר לנו לעשות משהו תכנותי?
ראינו PHP, נכון?
זה מציג כמה הדינמיות בתוכניות שלנו.
וכך, למרבה המזל, SQL ו PHP לשחק יפה מאוד יחד.
יש פונקציה ב PHP שאילתא נקראת, אשר ניתן להשתמש בי.
ואתה יכול לעבור כ פרמטר או הטיעון
שאילתת שאילתא SQL ש אתה רוצה לבצע.
ו- PHP יעשה את זה בשמך.
>> אז אחרי שחברת למסד הנתונים שלך עם PHP,
יש שני פריימריס אתה עושה את זה.
יש משהו שנקרא MySQLi ומשהו שנקרא PDO.
אנחנו לא אכנס ענק פירוט סכום שם.
בCS50 אנו משתמשים PDO.
לאחר שמחובר למסד הנתונים שלך, אתה
אז יכול לעשות שאילתות מסד הנתונים שלך על ידי העברת השאילתות כטיעונים
לפונקציות PHP.
וכאשר אתה עושה את זה, אתה מאחסן התוצאה להגדיר במערך אסוציאטיבי.
>> ואנחנו יודעים איך לעבוד עם מערכים אסוציאטיביים ב- PHP.
אז אני יכול להגיד משהו כמו זה-- $ results--
זה בPHP-- שווה שאילתא.
ואז בתוך פונקצית שאילתא שטיעון
שאני עובר לשאילתא שנראה כמו SQL.
ובעובדה שהוא SQL.
זה מחרוזת השאילתה שהייתי רוצה לבצע על מסד הנתונים שלי.
>> וכך באדום, זה PHP.
זה SQL שאני השתלבות PHP על ידי ביצוע
זה הטיעון לפונקצית השאילתה.
אני רוצה לבחור fullname מ משתמשים בי מספר תעודת זהות שווה 10.
ואז אולי אחרי שאני עשיתי את זה, אני יכול להגיד משהו כזה.
אני רוצה להדפיס את תודה הודעה לכניסה.
>> ואני רוצה את זה אני רוצה interpolate-- לשרבב fullname תוצאות $.
ואז זה איך אני עובד עם ש מערך אסוציאטיבי שחזרתי.
$ Fullname התוצאות היית בעצם בסופו של הדפסה החוצה,
תודה על כניסה, ג'רי סיינפלד.
זה היה שמו המלא שם idnum שווה 10.
>> וכך כל מה שאני עושה הוא אני now-- אני מאוחסן
השאילתה שלי, את התוצאות של השאילתה שלי ותוצאות במערך אסוציאטיבי,
וfullname הוא שמו של הטור שאני מקבל ל.
אז זה המפתח שלי לתוצאות מערך אסוציאטיבי שאני רוצה.
אז תודה על כניסה, תוצאות $, fullname יהיה להדפיס, ידבק
ממש בין מתולתל אלה פלטה, ג'רי סיינפלד.
ואני רוצה להדפיס את ההודעה תודה על כניסת ג'רי סיינפלד.
>> עכשיו, אנחנו כנראה לא רוצים קשים דברים כמו קוד שב, נכון?
אנחנו אולי רוצים לעשות משהו כמו הדפסה ו, שבו אנחנו יכולים להחליף ואולי
לאסוף מידע שונה, או אולי יש לי תהליך השאילתה
מידע שונה.
וכך שאילתא, יש את פונקצית השאילתה רעיון זה מסוג של החלפות
דומה מאוד להדפסת F אחוזים של ואחוזים ג, הוא סימני שאלה.
>> ואנחנו יכולים להשתמש בשאלה סימנים באנלוגיה מאוד
להדפיס F למשתני תחליף.
אז אולי המשתמש שלך מחובר קודם לכן, ואתה הצלת את מספר תעודת הזהות של המשתמש שלהם
ב_session $ של סופר PHP עולמי בזיהוי המפתח.
אז אולי אחרי שהם מחוברים, אתה מגדיר _session $ מספר שווה 10,
אקסטרפולציה מהדוגמא ראינו רק לפני שנייה.
>> ולכן כאשר אנו למעשה לבצע זה שאילתת תוצאות החברה,
זה היה חבר 10, או מה ש הערך מזהה _session $ הוא.
וכך המאפשר לנו להיות קצת יותר דינמי.
אנחנו לא קשים קידוד דברים בעוד.
אנחנו שמירת מידע איפשהו ולאחר מכן
אנחנו יכולים להשתמש במידע זה שוב ל סוג של להכליל את מה שאנחנו רוצים לעשות,
ורק התוספת ושינוי ההתנהגות של הדף שלנו
על סמך מה מספר תעודת הזהות של המשתמש למעשה הוא אחרי שהם מחוברים.
למרות שזה גם אפשרי,, שהתוצאות שלך להגדיר
יכול להיות מורכב ממספר השורות.
במקרה כזה, יש לך מערך של arrays--
מערך של מערכים אסוציאטיביים.
ואתה רק צריך לחזר דרכו.
ואנחנו יודעים איך לחזר באמצעות מערך ב PHP, נכון?
אז הנה הוא כנראה ביותר דבר מורכב שראינו עד כה.
זה למעשה משלב שלוש שפות יחד.
>> כאן באדום, זה קצת HTML.
אני כנראה אני starting-- זה קטע של כמה HTML שיש לי.
אני מתחיל פסקה חדשה ש אומר אמהות של סיינפלד של הטלוויזיה.
ומייד לאחר מכן אני מתחיל שולחן.
ואז אחרי זה, אני יש לי כמה PHP, נכון?
יש לי את כל קוד PHP זה שם.
אני כנראה הולך לעשות שאילתא.
וכדי להפוך את השאילתה, אני הולך להיות באמצעות אמהות SELECT מאמהות.
>> אז זה getting-- זה SQL.
אז הכחול הוא SQL.
האדום שראינו לפני שנייה היה HTML.
וכאן הוא הירוק PHP.
אז אני עושה את שאילתא למסד הנתונים שלי, אני
בחירה כל אמהות בטבלת האמהות.
לא רק לצמצם את זה למיוחד שורה, אני מבקש עבור כולם.
>> אז אני בודק אם תוצאה היא לא שווים שווה שווא.
זוהי רק הדרך של בדיקת סוג שלי אם תוצאות שלו לא שווה ל null,
שהיינו רואה ג למשל.
בעיקרון זה רק בודק לעשות בטוח שזה באמת יש נתונים בחזרה.
כי אני לא רוצה להתחיל בהדפסה נתונים אם אני לא מקבל את כל נתוני.
אז לכל תוצאות כתוצאה תחביר foreach מPHP, כל מה שאני עושה
מדפיס את תוצאת אימהות $.
ואז אני הולך לקבל קבוצה של כל האמהות של each--
זה מערך של אסוציאטיבי arrays-- ואני מדפיס את
כל אחד כשורה של שולחן משלו.
וזה ממש יפה הרבה כל מה שיש לה.
אני יודע שיש קצת קצת קורה כאן
בדוגמא האחרונה זו עם מערכים של arrays-- מערכים של מערכים אסוציאטיביים.
אבל זה באמת רק להרתיח למטה בSQL לביצוע שאילתא,
בדרך כלל בחירה לאחר שכבר לשים מידע לשולחן,
ואז פשוט מושך אותו החוצה.
>> וזה היינו למשוך אותו במקרה הספציפי הזה.
היינו לחלץ את כל הפרט אמהות משולחן האמהות.
יש לנו סט שלם שלהם, ואנחנו רוצה לחזר דרך ולהדפיס את
כל אחד.
אז שוב, זה כנראה הדוגמא המורכבת ביותר
שראינו כי אנחנו ערבוב שלוש שפות שונות יחד, נכון?
>> שוב, יש לנו כאן ב- HTML אדום, מעורבב עם כמה SQL כאן בכחול,
מעורבב עם כמה PHP בירוק.
אבל כל אלה משחקים יפה ביחד, זה
רק עניין של פיתוח הרגלים טובים, כך שאתה יכול לקבל
להם לעבוד יחד באופן רצוי.
והדרך היחידה לעשות את זה באמת הוא להתאמן, להתאמן, להתאמן.
אני דאג לויד, זה CS50.