קשרים בין טבלאות מתקדם

עבודה עם שתי טבלאות

לצורך דוגמה בואו ניצור טבלה Orders עם עמודות

OrderID, CustomerID, ShipCity

CREATE TABLE Orders 
(
OrderID int,
CustomerID int,
ShipCity varchar(255)  
);

ונוסיף נתונים

INSERT INTO Orders 
( OrderID, CustomerID, ShipCity ) 
VALUES 
('1','8','Tel Aviv'),
('2','12','Netanya'),
('3','15','Jerusalem');

ואז נקבל:

בנוסף ניצור עוד טבלה Customers עם עמודות CustomerID, Name

CREATE TABLE Customers 
(
CustomerID int,
Name varchar(255)  
);

ונוסיף נתונים

INSERT INTO Customers 
( CustomerID, Name) 
VALUES 
('8','Shalom'),
('2','Daniel'),
('18','Wulf');

ואז נקבל:

שיטה א)

  1. קודם כל נגדיר שמות לשתי טבלאות: Customers AS SecondTable, Orders AS FirstTable
    כלומר: טבלה Orders מעכשיו זה FirstTable וטבלה Customers מעכשיו זה SecondTable
  2. עכשיו נבחר עמודות מהטבלאות:
    SecondTable.OrderID, SecondTable.ShipCity, FirstTable.Name
  3. נגדיר תנאי: FirstTable.CustomerID=SecondTable.CustomerID
SELECT 
SecondTable.OrderID, SecondTable.ShipCity, FirstTable.Name 
FROM Customers 
AS FirstTable, Orders AS SecondTable 
WHERE FirstTable.CustomerID=SecondTable.CustomerID;

ואז נקבל

שיטה ב – מומלץ)

לצורך דוגמה ניצור טבלה Customers עם עמודות CustomerID, Name
ורק מפתח ראשי.
PK: מפתח ראשי CustomerID

CREATE TABLE Customers 
(
CustomerID int NOT NULL PRIMARY KEY,
Name varchar(255)  
);

ונוסיף נתונים

INSERT INTO Customers 
(CustomerID,Name) 
VALUES 
('2','Daniel'),
('8','Shalom'),
('18','Wulf');

ואז נקבל:

 

בנוסף בואו ניצור עוד טבלה Orders עם עמודות
PK: מפתח ראשי OrderID
FK: מפתח זר CustomerID

OrderID, CustomerID, ShipCity

CREATE TABLE Orders 
(
OrderID int NOT NULL PRIMARY KEY,
CustomerID int FOREIGN KEY REFERENCES Customers (CustomerID),
ShipCity varchar(255)  
);

ונוסיף נתונים

INSERT INTO Orders 
( OrderID, CustomerID, ShipCity ) 
VALUES 
('1','8','Tel Aviv'),
('2','12','Netanya'),
('3','15','Jerusalem');

יש לשים לב שמכיוון שיש קשר בין מפתח זר CustomerID  בטבלה Orders למפתח ראשי
בטבלה Customers אז ערכים של CustomerID  אמורים להיות בהתאם.

ואז נקבל:

בחירת נתונים משתי טבלאות

חשוב ש-FK (מפתח זר) של טבלה שמאלית יהיה קשור ל-PK (מפתח ראשי) של טבלה ימנית.

במקרה שלנו מכיוון שבצד השמאל (לפני ON) יש טבלת "Orders"
אז יש לבחור מפתח זר מטבלה הזאת ובצד הימין (לאחר ON) יש לבחור
מפתח ראשי מטבלה Customers.

 

SELECT Orders.OrderID, Orders.ShipCity, Customers.Name
FROM Orders
INNER JOIN 
Customers ON Orders.CustomerID=Customers.CustomerID;

ואז נקבל תוצאה משתי טבלאות:

בחירת נתונים משלושה טבלאות

ניצור טבלה חדשה בשם Shippers
כך ש-ShipperID יהיה מפתח ראשי – PK

CREATE TABLE Shippers
(
ShipperID int NOT NULL PRIMARY KEY,
CompanyName varchar(255), 
Phone nvarchar(24)
);

ונוסיף נתונים

INSERT INTO Shippers
( ShipperID , CompanyName, Phone) 
VALUES 
('5','Speedy Express','(503) 050000000003'),
('12','United Package','(503) 050000000004'),
('24','Federal Shipping','(503) 050000000005');

 

נמחק נתונים ישנים בטבלה Customers

DELETE FROM Customers;

ונוסיף עוד עמודה אחד בשם ShipViaID לטבלה Customers
* למעשה זה יהיה מפתח זר אשר מקשר לטבלה Shippers

ALTER TABLE Customers
ADD ShipViaID 
int FOREIGN KEY REFERENCES Shippers(ShipperID);

 

נוסיף נתונים לטבלה Customers

INSERT INTO Customers (CustomerID, Name, ShipViaID) 
VALUES 
('8','Shalom','5'), 
('2','Daniel','12'), 
('18','Wulf','24');

יש לשים לב שמפתח זר ShipViaID בטבלה Customers אמור להיות שווה למפתח ראשי ShipperID  בטבלה Shippers

נמחק נתונים ישנים בטבלה Orders

DELETE FROM Orders;

נוסיף נתונים חדשים לטבלה Orders

INSERT INTO Orders 
( OrderID, CustomerID, ShipCity ) 
VALUES 
('1','8','Tel Aviv'), 
('2','2','Netanya'), 
('3','18','Jerusalem');

יש לשים לב שמפתח זר CustomerID בטבלה Orders אמור להיות שווה למפתח ראשי CustomerID בטבלה Customers

כפי שניתן לראות שכאן באופן דומה לדוגמה קודמת יש קישור בין מפתחות ראשים למפתחות זרים.

*CustomerID – מפתח זר של טבלה Orders שווה למפתח ראשי של טבלה Customers
* ShipViaID מפתח זר של טבלה Customers שווה למפתח ראשי של טבלה Shippers

זאת אומרת: בהתחלה בונים טבלה מטבלאות: Orders ו-Customers
ולאחר מכן בונים טבלה מטבלאות (Orders ו-Customers) ו-Shippers

SELECT Orders.OrderID, Customers.Name, Shippers.CompanyName
FROM (
(Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID)
INNER JOIN Shippers ON Customers.ShipViaID = Shippers.ShipperID
);

ואז נקבל:


 

LEFT JOIN

לצורך דוגמאות הבאות ניצור בסיס נתונים חדש QAdb

CREATE DATABASE QAdb;

בנוסף ניצור טבלה Orders

CREATE TABLE Orders 
(
OrderID int,
CustomerID int,
ShipCity varchar(255)  
);

ונוסיף נתונים

INSERT INTO Orders 
( OrderID, CustomerID, ShipCity ) 
VALUES 
('1','8','Tel Aviv'),
('2','12','Netanya'),
('3','43','Tel Aviv'), 
('4','23','Netanya'),
('6','11','Netanya'),
('5','17','Jerusalem');

ואז נקבל:

ניצור עוד טבלה Customers עם עמודות CustomerID, Name

CREATE TABLE Customers 
(
CustomerID int,
Name varchar(255)  
);

ונוסיף נתונים

INSERT INTO Customers 
( CustomerID, Name) 
VALUES 
('12','Shalom'),
('23','Daniel'),
('17','Wulf');

ואז נקבל:

 

בחירה נתונים משתי טבלאות לפי פרמטר השוואה CustomerID בין טבלה שמאלית Orders
לטבלה ימנית Customers.
אם אין פרמטר הזה בטבלה ימנית אז יהיה ערך NULL בטבלה שמאלית.

*השוואה נעשית לפי טבלה שמאלית- Orders

SELECT Customers.Name, Orders.OrderID 
FROM Orders  
LEFT JOIN Customers ON Orders.CustomerID = Customers.CustomerID 
ORDER BY Customers.Name;

ואז נקבל:

RIGHT JOIN

בחירה נתונים משתי טבלאות לפי פרמטר השוואה CustomerID בין טבלה שמאלית Orders
לטבלה ימנית Customers.
אם אין פרמטר הזה בטבלה שמאלית אז יהיה ערך NULL בטבלה ימנית.

*השוואה נעשית לפי טבלה ימנית – Employees

SELECT Customers.Name, Orders.OrderID
FROM Orders
RIGHT JOIN Customers ON Orders.CustomerID = Customers.CustomerID
ORDER BY Customers.Name;

ואז נקבל:

איחוד שתי טבלאות

לצורך דוגמה ניצור שתי טבלאות City1 ו-City2

יצירת טבלה City1

CREATE TABLE City1 
(
id INT NOT NULL PRIMARY KEY,
CustomerName varchar(255), 
CityName varchar(255)
);

ונוסיף נתונים

INSERT INTO City1 ( id , CustomerName, CityName) 
VALUES 
('5','Daniel','Tel-Aviv'), 
('12','Moshe','Jerusalem'), 
('24','Rachel','Netanya');

נקבל:

כנ"ל ניצור טבלה City2

CREATE TABLE City2 
(
id INT NOT NULL PRIMARY KEY,
CustomerName varchar(255), 
CityName varchar(255)
);

ונוסיף נתונים

INSERT INTO City2 (id , CustomerName, CityName) 
VALUES 
('1','Nathan','Tel-Aviv'), 
('2','Hannah','Jerusalem'), 
('3','Esther','Jerusalem');

נקבל:

בחירת שם של הלקוח ועיר משתי טבלאות

SELECT CustomerName, CityName 
FROM City1 
UNION
SELECT CustomerName, CityName FROM City2 
ORDER BY CityName;

התוצאה תהיה:

כל הכבוד לכם, אם הגעתם עד לכאן : )

כל כבוד לכם!!!

בזה נגמר הקורס מבוא ל-SQL, אני מקווה שהקורס הזה נתן לכם רקע התחלתי בבסיס נתונים וכתיבת שאילתות ב-SQL.

עבודה עם מחרוזות

בשיעור הזה אנו נעבוד עם חיפוש לפי תווים במחרוזות.

לצורך דוגמאות נעבוד עם הטבלה HumanResources.Department
בבסיס נתונים AdventureWorks2019

SELECT TOP (200) DepartmentID, Name, GroupName, ModifiedDate
FROM HumanResources.Department;

 

חיפוש שורות בטבלה כך שהתו אחרון בעמודה Name הוא תו 'g'

*כל מספר של התווים  '%' במילה (יכול להיות 0,1,2,3 ויותר…)
– העיקר שבסוף יהיה תו 'g' בעמודה NAME

SELECT * FROM HumanResources.Department
WHERE Name LIKE '%g';


חיפוש שורות בטבלה כך שהן מתחילות בעמודה Name בכל תו אבל תו השני הוא  'r'
בעזרת "_"

SELECT * FROM HumanResources.Department
WHERE Name LIKE '_r%';


חיפוש שורות בטבלה כך שהן מתחילות  בעמודה Name מאותיות m או a או r.

SELECT * FROM HumanResources.Department
WHERE Name LIKE '[mar]%';


חיפוש שורות בטבלה כך שהן לא מתחילות בעמודה Name מאותיות או m או a או r.

SELECT * FROM HumanResources.Department 
WHERE Name NOT LIKE '[mar]%';


חיפוש שורות בטבלה כך שבעמודה Name יש
"Quality Assurance" או "Engineering"

SELECT * FROM HumanResources.Department
WHERE Name IN ('Quality Assurance', 'Engineering');


חיפוש שורות בטבלה כך שבעמודה DepartmentID בין 3 ל-14
וגם בעמודה NAME אין: "Quality Assurance" או "Engineering"

SELECT * FROM HumanResources.Department
WHERE (DepartmentID BETWEENAND 14)
AND NOT NAME IN ('Quality Assurance', 'Engineering');


חיפוש שורות בטבלה כך שבעמודה ModifiedDate יהיה תאריך
בין '2006-04-30 00:00:00.000' ל-2007-08-30 00:00:00.000

SELECT * FROM HumanResources.Department 
WHERE ModifiedDate 
BETWEEN '2006-04-30 00:00:00.000'
AND '2007-08-30 00:00:00.000';


בחירת כינוי להדפסה עבור העמודות:
במקום DepartmentID היה ID
ובמקום Name יהיה FirstName

SELECT DepartmentID AS ID, Name AS FirstName
FROM HumanResources.Department;

טבלה לפני שינוי שמות של העמודות:

טבלה לאחר שינוי שמות של העמודות:


איחוד עמודות תחת השם אחת

לצורך דומה בואו נפתח בסיס נתונים AdventureWorks2019
ונבחר טבלה Person.Address ונריץ SQL QUERY

SELECT TOP (3) AddressID, AddressLine1, City
FROM Person.Address

אז נקבל:

עכשיו נאחד את שתי העמודות AddressLine1, City
לעמודה אחד ונקרא לה בשם Address

SELECT TOP (3) 
AddressID, + AddressLine1+ ',' + City + '.' 
AS Address
FROM Person.Address;

 

ואז נקבל תוצאה:

שאילתות SQL

בחירת כל עמודות

נניח יש לנו טבלה HumanResources.Department בבסיס נתונים AdventureWorks2019

ואנחנו רוצים להציג את כל עמודות הקיימות בטבלה ורק 200 שורות הראשונות.

SELECT TOP (200) *
FROM HumanResources.Department

תוצאה:

בחירת רק לפי עמודות ספציפיות

נניח אנחנו רוצים להציג שורות אשר בטבלה רק לפי העמודות DepartmentID ו-GroupName.

SELECT DepartmentID, GroupName
FROM HumanResources.Department

תוצאה:

בחירת רק שורות שונות זו מזו

ניתן לראות בצילום מסך שיש לנו כמה שורות זהות  – יש להם אותו ערך בעמודה GroupName:

ניתן לבחור שורות שונות זו מזו תוך שימוש במילת מפתח – DISTINCT

SELECT DISTINCT GroupName
FROM HumanResources.Department;

חישוב מספר שורות

COUNT – חישוב מספר שורות שונות זו מזו

בנוסף אנחנו רוצים להציג את המספר שורות בעמודה בשם TOTAL

SELECT COUNT(DISTINCT GroupName) AS TOTAL
FROM HumanResources.Department

נקבל

בחירת שורות ספציפיות מהטבלה

לפני הכל, אני מזכיר מה יש לנו בטלה HumanResources.Department

SELECT * 

FROM HumanResources.Department

תוצאה:

נניח אנחנו רוצים לבחור מתוך הטבלה רק את השורה, אשר ערך העמודה של DepartmentID יהיה 13 וערך עמודה של GroupName יהיה Quality Assurance.

SELECT DepartmentID, GroupName 
FROM HumanResources.Department
WHERE DepartmentID='13' AND GroupName ='Quality Assurance';

נקבל:

OR

בחירת רק GroupName  שווה ל- Quality Assurance או ל- Sales and Marketing

SELECT DepartmentID, GroupName 
FROM HumanResources.Department
WHERE GroupName ='Sales and Marketing' OR GroupName ='Quality Assurance';

NOT

בחירת כל שורות חוץ משורות שבהן עמודה GroupName שווה ל- Quality Assurance

SELECT * FROM HumanResources.Department
WHERE NOT GroupName ='Quality Assurance';

SORT

נניח אנחנו רוצים קודם כל לעשות מיון לפי GroupName בסדר עולה – ASC.

לאחר זה צרכים לעשות מיון משני לפי Name בסדר יורד – DESC.

SELECT * FROM HumanResources.Department 
ORDER BY GroupName DESC, Name ASC;

UPDATE

עדכון מידע בשורה אחת מסוימת.

לדוגמה אנחנו רוצים לשנות בשורה שבה GroupName  שווה ל- Quality Assurance
לערך חדש GroupName  שווה ל- Quality Assurance NEW

UPDATE HumanResources.Department 
SET GroupName = 'Quality Assurance NEW'
WHERE GroupName = 'Quality Assurance';

נקבל:

SELECT * 

FROM HumanResources.Department

מחיקה שורה מטבלה

לצורך דוגמה בואו ניצור טבלה Cities עם המודות PersonID , FirstName, City

CREATE TABLE Persons 
(
PersonID int,
FirstName varchar(255),
City varchar(255)  
);

ונוסיף נתונים

INSERT INTO Persons 
( PersonID, FirstName, City ) 
VALUES 
('1','Shalom','Tel Aviv'),
('2','Wulf','Netanya'),
('3','Moshe','Jerusalem');

ואז נקבל:

נניח אנחנו רוצים למחוק שורה 2 בטבלה איפה ש City=Netanya

DELETE FROM dbo.Persons 
WHERE 
City='Netanya';

ואז קבלנו טבלה ללא שורה איפה ש City=Netanya

TOP

בחירה רק שלושה שורות הראשונות בטבלה

SELECT TOP 3 * FROM Customers;

 PERCENT

בחירה רק של 50% ממספר שורות מטבלת הלקוחות

SELECT TOP 50 PERCENT * FROM Customers;

MAX

לצורך דוגמה בואו ניצור טבלה ShopProducts עם המודות ProductID , ProductName, UnitPrice

CREATE TABLE ShopProducts
(
ProductID int,
ProductName varchar(255),
UnitPrice DECIMAL(13, 2) NOT NULL);

ונוסיף נתונים

INSERT INTO ShopProducts
( ProductID, ProductName, UnitPrice) 
VALUES 
('1','Ice Cream','3'),
('2','Coffee','4.26'),
('3','Yogurt','2');

ואז נקבל:

נמצא מחיר מקסימלי לפי עמודה UnitPrice וניתן שם לתוצאה LargestPrice

SELECT MAX(UnitPrice) AS LargestPrice
FROM ShopProducts;

כנ"ל ניתן למצוא ממוצע של כל שורות לפי עמודה:
SELECT 
AVG(UnitPrice) AS Average 
FROM ShopProducts;

כנ"ל ניתן למצוא סכום של כל שורות לפי עמדה:
SELECT 
SUM(UnitPrice) AS TotalPrice 
FROM ShopProducts;

קשרים בין טבלאות

PRIMARY KEY

PK – מפתח ראשי:
– חייב להיות שונה ערך
– בטבלה הוא יכול להיות רק יחיד ובעזרתו ניתן לזהות את הרשומה בטבלה באופן חד-חד-ערכית.
– אסור שיהיה ערך NULL

דוגמה של מפתח אשר מורכב רק מעמודה אחת:

CREATE TABLE Persons (
ID int NOT NULL PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int
);

דוגמה של מפתח אשר מורכב משתי עמודות
כלומר יכול להיות אותו id אבל LastName חייב להיות שונה:

CREATE TABLE Persons (
ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CONSTRAINT PK_Person PRIMARY KEY (ID,LastName)
);


FOREIGN KEY

FK – מפתח זר, מקשר למפתח ראשי של טבלאות אחרות.

לצורך דוגמה, ניצור טבלה Products עם מפתח ראשי ProductID

* UnitPrice  מסוג DECIMAL כאשר 13 זה מספר ספרות שלמות ו-2 זה מספר ספרות לאחר נקודה.

CREATE TABLE Products (
ProductID int NOT NULL PRIMARY KEY,
ProductName varchar(255) NOT NULL,
UnitPrice DECIMAL(13, 2) NOT NULL
);

וניצור טבלה בשם Orders עם מפתח ראשי OrderID ומפתח זר ProductID.

כאשר ProductID  זה מפתח ראשי עבור טבלה Products

CREATE TABLE Orders (
OrderID int NOT NULL PRIMARY KEY,
OrderDate DATE,
ProductID int FOREIGN KEY REFERENCES Products(ProductID)
);

דרך אגב, ניתן לראות את המפתחות תוך בחירת טבלה newDB -> מפתחות 

 

להשלמת הדוגמה שלנו, בואו נוסיף נתונים לטבלאות:

עבור טבלה Products

INSERT INTO Products ( ProductID, ProductName, UnitPrice) 
VALUES ( '1', 'Coffee', '12.30');

וגם

INSERT INTO Products ( ProductID, ProductName, UnitPrice) 
VALUES ( '3', 'Ice Cream', '15.45');

עבור טבלה Orders

INSERT INTO Orders ( OrderID, OrderDate, ProductID) 
VALUES ( '1', '23-JUN-20', '1');

וגם

INSERT INTO Orders ( OrderID, OrderDate, ProductID) 
VALUES ( '2', '25-JUN-20', '3');

ואז קבלנו קשר בין הטבלאות:

הזמנה עם OrderID=1 מטבלה Orders מקושרת לטבלה Products  דרך ProductID=1

וגם הזמנה עם OrderID=2 מטבלה Orders מקושרת לטבלה Products  דרך ProductID=3

CHECK

בדיקה שתנאי מתקיים, כאשר נתונים נכנסים לטבלה.

לדוגמה:
כל פעם כאשר יוכנס מידע לטבלה
אז תתבצע בדיקה אם הגיל הוא יותר או שווה ל-18.

CREATE TABLE PersonsTable (
ID int NOT NULL,
FirstName varchar(255),
Age int,
CHECK (Age>=18)
);

ננסה להכניס לטבלה PersonsTable  גיל פחות מ-18

INSERT INTO PersonsTable (ID, FirstName,Age) 
VALUES ( '1', 'Daniel', '17');

נקבל

המשך עבודה עם טבלאות

UNIQUE Constraint

נבחר בסיס נתונים שלנו newDB ונעשה לחיצה ימנית בעכבר תוך בחירה New Query

וניצור שוב את הטבלה:

CREATE TABLE Persons 
(
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)  
);

כידוע זאת הדרך להוספת נתונים לטבלה:

INSERT INTO Persons 
(
PersonID,
LastName,
FirstName, 
Address, 
City
) 
VALUES 
(
'23',
'Israeli',
'Shalom', 
'Israel 22',
'Jerusalem'
);

נריץ שוב את הפקודה עם אותו PersonID=23 וערך ריק עבור FirstName

INSERT INTO Persons ( PersonID, LastName, FirstName, Address, City ) VALUES ( '23', 'Israeli', '', 'Israel 22', 'Jerusalem' );

ואז נקבל:

אבל נניח שיש לנו הרבה אנשים וחשוב שלכל אחד יהיה PersonID ייחודי, לצורך הזה יש ליצור טבלה תוך שימוש בפקודה UNIQUE.

יש למחוק טבלה קודמת

DROP TABLE Persons;

וליצור טבלה חדשה

CREATE TABLE Persons 
( 
PersonID int UNIQUE, 
LastName varchar(255), 
FirstName varchar(255), 
Address varchar(255), 
City varchar(255)  
);

נריץ Execute

נכניס נתונים בפעם ראשונה לטבלה

INSERT INTO Persons 
(
PersonID,
LastName,
FirstName, 
Address, 
City
) 
VALUES 
(
'23',
'Israeli',
'Shalom', 
'Israel 22',
'Jerusalem'
);

נריץ שוב את הפקודה עם אותו PersonID=23 וערך ריק עבור FirstName

INSERT INTO Persons ( PersonID, LastName, FirstName, Address, City ) VALUES ( '23', 'Israeli', '', 'Israel 22', 'Jerusalem' );

ואז נקבל שאסור שיהיה אותו PersonID:

 

דרך אגב, תמיד ניתן לשנות את עמודה שבטלה לסטטוס "הכנסת ערכים אף ורק שונים זה מזה"

לדוגמה עיר מגורים חייבת להיות שונה מבן אדם לאדם.

ALTER TABLE Persons 
ADD UNIQUE (City);

טבלאות ב-SQL

מה זה בסיס נתונים?
בסיס נתונים זה אוסף של הטבלאות, לדוגמה בואו ניצור טבלה בבסיס נתונים חדש שלנו.

הוספת טבלה חדשה

יצירת טבלה חדשה בבסיס נתונים newDB

CREATE TABLE newDB.dbo.Persons 
(
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)  
);

כאשר:

newDB.dbo.Persons זאת הפניה איפה אנחנו רוצים ליצור טבלה:
זאת אומרת – אנחנו רוצים ליצור טבלה חדשה בבסיס נתונים newDB בשם Persons
ו-dbo זאת schema – (קידומת לפני הטבלה כגון dbo.Persons).
* קידומת dbo זה ערך ברירת מחדל וזה קשור להרשאות שיש למשתמש בעבודה עם בסיס נתונים…
פשוט יש להשאיר את קידומת dbo כמו שזה!

בנוסף בטבלה שלנו יהיו 5 עמודות:
1) עמודה PersonID  מסוג int(מספרים שלמים) – בעמודה הזאת נשמור ID של אנשים.

2) LastName מסוג varchar – בעמודה הזאת נשמור שם משפחה של אנשים.

3) FirstName מסוג varchar – בעמודה הזאת נשמור שם פרטי של אנשים.

4) Address מסוג varchar – בעמודה הזאת נשמור כתובת של אנשים.

5) City מסוג varchar – בעמודה הזאת נשמור עיר של אנשים.

 

ניתן לראות את הטבלה Persons עם קידומת dbo בבסיס נתונים newDB לאחר REFRESH:

הוספת נתונים לטבלה – INSERT

נבחר בסיס נתונים שלנו newDB ונבחר New Query תוך לחיצה ימנית בעכבר

לכל עמודה בטבלה יש הגדרה מה הסוג של נתונים שאפשר להכניס, לדוגמה

INSERT INTO Persons 
(
PersonID,
LastName,
FirstName, 
Address, 
City
) 
VALUES 
(
'23',
'Israeli',
'Shalom', 
'Israel 22',
'Jerusalem'
);

INSERT INTO – להוסיף לטבלה..
PersonID = 23
LastName = Israeli
FirstName = Israeli
Address = Israel 22
City = Jerusalem

כנ"ל בואו נוסיף עוד נתונים לטבלה Persons

INSERT INTO Persons 
(
PersonID,
LastName,
FirstName, 
Address, 
City
) 
VALUES 
(
'24',
'Israeli',
'Shalom', 
'Israel 24',
'Tel Aviv'
);

הצגת נתונים מטבלה – SELECT

עכשיו זה הזמן להציג את הנתונים אשר הוספנו:

SELECT 
PersonID,
LastName,
FirstName,
Address,
City 
FROM Persons;

בעזרת SELECT – בחירה ניתן לבחור עמודות אשר רוצים להציג:

אפשר להציג רק עמודה אחת, לדוגמה FirstName

SELECT 
FirstName
FROM Persons;

SQL ALTER TABLE

הוספה/מחיקה/עריכה העמודות בטבלה קיימת.

דוגמה להוספת עמודה DateOfBirth מסוג date לטבלה Customers:

ALTER TABLE Persons
ADD DateOfBirth date;

שינוי סוג – type של עמודה בטבלה:
בדוגמה הזאת העמודה DateOfBirth תהיה מהסוג varchar במקום Date

ALTER TABLE Persons
ALTER COLUMN DateOfBirth varchar(255);

מחיקת עמודה בטבלה:
בדוגמה הזאת העמודה DateOfBirth תמחק מטבלת Employees

ALTER TABLE Persons
DROP COLUMN DateOfBirth;

SQL – התקנת תוכנה

שלום ברוכים הבאים לקורס מבוא לבסיס נתונים – SQL.

מה נלמד כאן:

יצירת/עריכה בסיס נתונים SQL והוספה/מחיקה/עריכה העמודות בטבלה קיימת (כולל הסבר על מפתח ראשי וזר אשר מקשר בין הטבלאות).

שלב א) התקנת תוכנה, דרכה אנו נעבוד עם SQL

אז קודם כל יש להוריד תוכנה לעבודה עם בסיס נתונים,
קישור להורדת SQL Server Management Studio אני ממליץ להוריד גרסה SSMS 18.6 ומעלה.

יש לחפש בעמוד הורדה:
"Download SQL Server Management Studio SSMS"

שלב ב) התקנת שרת SQL

יש להוריד גרסה חינמית SQL Server 2019 Express  ובהתקנה יש לבחור חבילה BASIC.

יש לחפש בעמוד הורדה: "Express"

שלב ג)לאחר התקנת SQL Server Management Studio ושרת SQL

יש ללחוץ על הכפתור Connect בתוכנה  SQL Server Management Studio
על מנת להתחבר לשרת SQL

לאחר זה יש להוריד בסיס נתונים לדוגמה בקישור AdventureWorks2019.bak

לאחר זה, יש לעשות לחיצה בצד ימין של עכבר על Databases ולחבור Restore Database

עכשיו יש לבחור Device ולאחר זה ללחוץ על שלושה נקודות בריבוע (כמו בצילום מסך).

עכשיו יש ללחוץ על הכפתור Add

1 – יש לעשות הדק-הדבק של הקובץ AdventureWorks2019.bak לתיקיה
C:\Program Files\Microsoft SQL Server\MSSQL14.SQLEXPRESS\MSSQL\Backup
(ניתן לראות את הדרך לתיקיה) ובמחשב שלכם זה יכול להיות שונה!

2 – יש לבחור את הקובץ וללחוץ OK

לאחר זה יש ללחוץ שוב OK

ובסוף פעם אחרונה יש גם ללחוץ OK

מזל טוב, עכשיו התקנו בסיס נתונים לדוגמה AdventureWorks2019 זה יעזור לנו ללמוד SQL 🙂

 

יצירת בסיס נתונים חדש

דרך אגב ניתן ליצור בסיס נתונים DB חדש משלנו.
לצורך זה יש לבחור New Query

ולרשום את הפקודה הזאת:

CREATE DATABASE newDB;

CREATE זה ליצור משהו
DATABASE בסיס נתונים
newDB שם של לבסיס נתונים

לאחר יש ללחוץ על Execute

נעשה REFRESH לתיקיה Databases ונראה את הבסיס נתונים חדש שלנו:

 

 


מחיקת בסיס נתונים

ואם רוצים למחוק בסיס נתונים newDB אז קיימת פקודה הבאה:

DROP DATABASE newDB;

DROP זה למחוק

בשיעור הבא נדבר על טבלאות 🙂

שילוב של CSS ו-JS

הערות ל-CSS ו-JS כותבים כך /* COMMENT */

הערות ל-HTML כותבים כך <!– Write your comments here –>

קודם כל בואו נראה את הקובץ mystyle.css

יש לנו צבע רקע שחור לכל HTML עמוד.

בנוסך:

  • הגדרנו צבע טקסט לאלמנט-testID כצהוב.
  • צבע טקסט לאלמנט-testID2 כלבן.
  • רוחב של myDiv שווה ל-25% מרוחב העמוד HTML ועם קן צהוב מסביב.
    בנוסף הגדרנו צבע רקע פנימי ל-myDiv – ירוק.
  • באדום הגדרנו צבע של הטקסט בתג p בתוך ה-myDiv.
/* Black background */
body {
background-color: black;
}

/* yellow color for the selector #testID */
#testID {
color:yellow;
}

/* WHITE color for the CLASS .testID2 */
.testID2 {
color:white;
}

/* DIV */
.myDiv {
 width:25%; 

 /* outset yellow-line 5px*/
 border: 5px outset yellow;
 background-color: green;
 text-align: center;
}

/* tag p inside div will be red*/
.myDiv p {
 color:red;
}

בקובץ HTML הגדרנו תג p:
פעם כ-id selector שזה <p id="testID">Test 1 </p>
ופעם כ-CLASS NAME שזה <p class="testID2">Test 2 </p>

בנוסף הגדרנו DIV כ-CLASS NAME שזה <div class="myDiv">

ובתוך ה-DIV הגרנו כותרת <h2> וגם טקסט עם תג <p>

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">
<title>Java Script</title>
</head>
<body>
 <!-- Write your comments here -->

 <!-- Color defended by ID SELECTOR -->
 <p id="testID">Test 1 </p>

 <!-- Color defended by CLASS NAME -->
 <p class="testID2">Test 2 </p>

 <div class="myDiv">
   <h2>TITLE</h2>
   <p>Just text in DIV...</p>
 </div>

</body>
</html>

שינוי HTML Elements בעזרת JavaScript

בדוגמה קודמת נוסיף כפתור כך שבלחיצה על הכפתור
תרוץ פוטנציה ()changeColor אשר נמצת בקובץ MyJavaScript.js

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="C:\HTML-CSS-JS/mystyle.css">
 <script type="text/javascript" src="MyJavaScript.js"></script>
<title>Java Script</title>
</head>
<body>
 <!-- Write your comments here -->

 <!-- Color defended by ID SELECTOR -->
 <p id="testID">Test 1 </p>

 <!-- Color defended by CLASS NAME -->
 <p class="testID2">Test 2 </p>

 <div class="myDiv">
   <h2>TITLE</h2>
   <p>Just text in DIV...</p>
 </div>

 </br>
<button type="button" onclick="changeColor()"> Change color!</button>

</body>
</html>

תג <br/> מסמל ירידת שורה, כך שהטקסט הבא יתחיל בשורה הבאה.

נגדיר פוטנציה ()changeColor בקובץ JS
ואז נשנה את הצבעים:

  • דרך getElementById נשנה Test1 מצהוב לאדום
  • דרך getElementsByClassName נשנה Test2 מלבן לכחול.
    חשוב לציין שמכיוון שgetElementsByClassName מחזיר מערכך של כל אלמנטים
    לפי תג testID2 ואנחנו צריך רק את הראשון, לכן בחרנו [document.getElementsByClassName('testID2')[0
  • כנ"ל יהיה שינוי הצבע של רקע עבור myDiv לכחול.
function changeColor () {
document.getElementById('testID').style.color = 'red';
document.getElementsByClassName('testID2')[0].style.color = 'blue';
document.getElementsByClassName('myDiv')[0].style.backgroundColor = "blue";
}

תוצאה:

לפני לחיצת כפתור כפתור:

לאחר לחיצת כפתור כפתור:

כל כבוד לכם!!!

בזה נגמר הקורס מבוא לשפת JavaScript ו-HTML, אני מקווה שהקורס הזה נתן לכם רקע התחלתי בJS, HTML.

DOM – HTML

שפת JavaScript – הפעם נלמד על DOM.

Document Object Model of the HTML page.

Finding HTML Elements

מציאת אלמנט לפי id.

הגדרנו אלמנת בתג p עם id שווה ל-testID

ואז דרך JS מוצאים את אלמנת עם id שווה ל-testID ומדפיסים Founded

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
</head>
<body>

<p id="testID"></p>

<script>
document.getElementById("testID").innerHTML ="Founded";
</script>

</body>
</html>


מציאת אלמנט לפי Tag Name.

ניתן למצוא אלמנט לפי Tag Name שלו:

document.getElementsByTagName(name)

בדוגמה הזאת יש 4 שורות עם תג <p>

בתוך JS נגדיר משתמה X אשר מוצאת כל אלמנטים שיש להם תג <p>
כלומר יש לנו מערך:

X={<p>Test 1 </p>,<p>Test 2 </p>,<p>Test 3 </p>,<p id="testID">Selected: </p>}

לדוגמה: [x[1 זה <p>Test 2 </p>

בנוסף נגדיר משתנה Y אשר מוצא אלמנת לפי id ששווה ל-testID

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
</head>
<body>

<p>Test 1 </p>
<p>Test 2 </p>
<p>Test 3 </p>
<p id="testID">Selected: </p>

<script>
var x = document.getElementsByTagName("p");
var y = document.getElementById("testID");
y.innerHTML += x[1].innerHTML;
</script>

</body>
</html>

בצבע אדום מודגש y.innerHTML += x[1].innerHTML שזה אומר יש להוסיף ל-y את משהו כתוב ב-[x[1 שזה Selected: Test 2

לסיכום נקבל:


מציאת אלמנט לפי Class Name

document.getElementsByClassName(name)

בדוגמה הזאת, אנחנו מוצאים אלמנט לפי CLASS:
testIDclass2, testIDclass1
ומוצאים את התוכן רצוי מתוך המערך, כי יש שני מחלקות עם אותו שם – testIDclass2.

ב-JS הגדרנו משתנה X אשר מקבל מערך של המחלקה testIDclass2

X={<p class="testIDclass2">Test 2 </p>, <p class="testIDclass2">Test 3 </p>}

בנוסף הגדרנו משתנה Y שזה <p id="testID">Selected: </p> 

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
</head>
<body>

<p class="testIDclass1">Test 1 </p>
<p class="testIDclass2">Test 2 </p>
<p class="testIDclass2">Test 3 </p>
<p id="testID">Selected: </p>

<script>
var x = document.getElementsByClassName("testIDclass2");
var y = document.getElementById("testID");
y.innerHTML += x[0].innerHTML;
y.innerHTML += x[1].innerHTML;
</script>

</body>
</html>

בצע כחול מוגדר ב-JS

y.innerHTML += x[0].innerHTML;
y.innerHTML += x[1].innerHTML;

זה אומר שיש להוסיף לתוכן של-Y את ערכים שבמערך X שזה Test 2 ו-Test 3

ואז נקבל:

Events

שפת JavaScript – הפעם נלמד על events ו-button.

שינוי טקסט בקליק

בלחיצה על הטקסט Let's change it – click. יקרה event בשם onclick
ואז ישתנה הטקסט ל-Clicked!

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
</head>
<body>

<p onclick="this.innerHTML='Clicked!'">Let's change it - click.</p>
</body>
</html>


עוד דוגמה ל-Event

נגדיר פונקציה ב JS קובץ:

function funChange() {
document.getElementById("testID").innerHTML = "Added";
}

ואז בלחיצה על הכפתור יתאסף הטקסט Added לתג testID

*בעזרת תג button מוצג כפתור

<!DOCTYPE html>
<html>
<head>
<title>Java Script</title>
<script type="text/javascript" src="MyJavaScript.js"></script>
</head>
<body>


<button onclick="funChange()">Let's change it - click</button>

<p id="testID"></p>


</body>
</html>

זאת אומרת מקובץ HTML בלחיצה על על הכפתור התרחש event
אשר קרא לפונקציה ()funChange
ובעזרת פונקציה ()funChange  הוסף את הטקסט Added לתג testID

 


באופן דומה ניתן לתפוס EVENTS במקום onclick כגון:

onmouseover – כאשר עוברים עם העכבר מעל אלמנט.
onmouseout – משתמש עוזב אלמנט.
onload – כאשר עמוד HTML נטען.