Isang may larawang SQL tutorial para sa mga nagsisimula. Mga Archive ng Kategorya: SQL Books Ang SQL Programming Language para sa mga Dummies

Mula sa may-akda: tinawag ka nilang teapot? Well, ito ay maaaring ayusin! Ang bawat samovar ay dating isang tsarera! O ang bawat propesyonal ay isang samovar? Hindi, may mali na naman! Sa pangkalahatan, ang MySQL para sa mga nagsisimula.

Bakit kailangan ng mga dummies ang MySQL

Kung sineseryoso mong ikonekta ang iyong buhay sa Internet, pagkatapos ay sa pinakaunang mga hakbang sa "web" ay makakatagpo ka ng DBMS na ito. Ang MySQL ay maaaring ligtas na tinatawag na "buong internet" na sistema ng pamamahala ng database. Walang isa o mas seryosong mapagkukunan ang magagawa kung wala ito, naroroon ito sa admin panel ng bawat pagho-host. At higit sa lahat ng sikat na CMS at maging ang mga "self-made" na makina ay binuo kasama ang kanyang pakikilahok.

Sa pangkalahatan, hindi mo magagawa nang wala ang platform na ito. Ngunit para pag-aralan ito, kakailanganin mo rin ang tamang diskarte, tamang tool, at higit sa lahat, pagnanais at pasensya. Umaasa ako na mayroon kang sapat na mga huling bahagi. At maging handa para sa katotohanan na ang iyong utak ay kumukulo, at ang singaw ay bubuhos mula sa iyong ulo, tulad ng mula sa isang tunay na takure.

Ngunit ang MySQL ay napakahirap para sa mga dummies lamang kung sinimulan mo itong pag-aralan nang mali. Hindi kami gagawa ng ganoong pagkakamali, at sisimulan namin ang aming pagkakakilala sa teknolohiyang ito mula pa sa simula.

Pangunahing konsepto

Una, suriin natin ang mga pangunahing konsepto na babanggitin natin sa publikasyong ito:

Ang Database (DB) ay ang pangunahing bumubuo ng yunit ng DBMS. Kasama sa database ang mga talahanayan, na binubuo ng mga hanay at talaan (mga hilera). Ang mga cell na nabuo sa intersection ay naglalaman ng structured data ng isang partikular na uri.

DBMS (database management system) - isang set ng lahat ng software modules para sa database administration.

Ang SQL ay isang structured query language kung saan "nakikipag-ugnayan" ang developer sa core (server) ng DBMS. Tulad ng anumang programming language, ang SQL ay may sarili nitong syntax, set ng mga command at operator, at mga sinusuportahang uri ng data.

Sa tingin ko sapat na ang teoretikal na kaalaman para makapagsimula tayo. "Ipinta" natin ang mga nawawalang gaps sa teorya na may kasanayan. Ngayon ay nananatiling pumili ng tamang tool ng software.

Pagpili ng Tamang Tool

Medyo "paghuhukay" sa buong hanay ng MySQL shell para sa mga nagsisimula, napagtanto ko na ang mga ito ay hindi umiiral. Ang lahat ng mga produkto ng software ng pangangasiwa ng DBMS ay nangangailangan ng naka-install na database server. Sa pangkalahatan, nagpasya akong muli na huwag mag-imbento ng "scooter", at nag-opt para sa domestic Denwer package. Maaari mong i-download ito sa opisyal na website.

Kasama na nito ang lahat ng mga bahagi ng DBMS, na nagpapahintulot sa isang baguhan na magsimula ng praktikal na kakilala sa MySQL kaagad pagkatapos ng isang simple at naiintindihan na pag-install. Bilang karagdagan, ang Denwer ay nagsasama ng ilang higit pang mga tool na kinakailangan para sa isang baguhan na developer: isang lokal na server, PHP.

Mga unang hakbang

Hindi ko ilalarawan ang proseso ng pag-install ng set ng "gentleman", dahil ang lahat ay awtomatikong nangyayari doon. Pagkatapos simulan ang pag-install, magkaroon lamang ng oras upang pindutin ang mga kinakailangang key. Kung ano lang ang kailangan mo sa variant ng MySQL para sa mga dummies.

Kapag natapos na ang proseso ng pag-install, simulan ang lokal na server, maghintay ng ilang segundo. Pagkatapos nito, i-type ang localhost sa address bar ng iyong browser.

Sa page na "Hurrah, it worked!" sundan ang isa sa mga link sa larawan. Pagkatapos nito, dadalhin ka sa phpMyAdmin - isang shell para sa pangangasiwa ng mga database.

Sa pamamagitan ng pag-click sa link na http://downloads.mysql.com/docs/world.sql.zip, magda-download ka ng halimbawa ng database ng pagsubok mula sa opisyal na website ng MySQL. Muli, pumunta sa phpMyAdmin, sa pangunahing menu sa itaas, pumunta sa tab na "Import". Sa window na "Import to Current", sa unang seksyon ("File to import"), itakda ang value sa "Pangkalahatang-ideya ng iyong computer".

Sa window ng explorer, piliin ang archive na may na-download na sample na database. Huwag kalimutang i-click ang OK sa ibaba ng pangunahing window.

Ipinapayo ko sa iyo na huwag baguhin ang tinukoy na mga halaga ng parameter. Ito ay maaaring humantong sa maling pagpapakita ng na-import na source data. Kung ang phpMyAdmin system ay nagbigay ng error na hindi nito nakikilala ang database compression algorithm, pagkatapos ay i-unzip ito at ulitin ang buong proseso ng pag-import mula sa simula.

Kung naging maayos ang lahat, lilitaw ang isang mensahe ng programa sa tuktok na matagumpay ang pag-import, at sa kaliwa sa listahan ng mga database ay may isa pa (salita).

Tingnan natin ang istraktura nito mula sa loob upang mas malinaw mong maisip kung ano ang iyong haharapin.

Mag-click sa pangalan ng MySQL database para sa mga nagsisimula. Sa ilalim nito, ipapakita ang isang listahan ng mga talahanayan kung saan ito binubuo. Mag-click sa isa sa kanila. Pagkatapos ay pumunta sa tuktok na item ng menu na "Istruktura". Ipinapakita ng pangunahing lugar ng trabaho ang istraktura ng talahanayan: lahat ng pangalan ng column, uri ng data, at lahat ng attribute.

Ang tutorial na ito ay parang isang "stamp ng aking memorya" sa wikang SQL (DDL, DML), i.e. ito ay impormasyon na naipon sa kurso ng aking mga propesyonal na aktibidad at patuloy na nakaimbak sa aking isipan. Ito ay isang sapat na minimum para sa akin, na kadalasang ginagamit kapag nagtatrabaho sa mga database. Kung kailangan mong gumamit ng mas kumpletong mga konstruksyon ng SQL, kadalasan ay bumaling ako sa library ng MSDN na matatagpuan sa Internet para sa tulong. Sa palagay ko, ang pagpapanatiling lahat sa iyong ulo ay napakahirap, at walang partikular na pangangailangan para dito. Ngunit ang pag-alam sa mga pangunahing konstruksyon ay lubhang kapaki-pakinabang, dahil. naaangkop ang mga ito halos sa parehong anyo sa maraming relational database tulad ng Oracle, MySQL, Firebird. Ang mga pagkakaiba ay pangunahin sa mga uri ng data, na maaaring magkaiba sa mga detalye. Walang napakaraming mga pangunahing konstruksyon ng wikang SQL, at sa patuloy na pagsasanay ay mabilis silang naaalala. Halimbawa, upang lumikha ng mga bagay (mga talahanayan, mga hadlang, mga index, atbp.) sapat na magkaroon ng isang text editor ng kapaligiran (IDE) sa kamay para sa pagtatrabaho sa isang database, at hindi na kailangang matuto ng isang visual toolkit na hinahasa para sa nagtatrabaho sa isang partikular na uri ng database (MS SQL , Oracle, MySQL, Firebird, ...). Maginhawa rin ito dahil ang buong teksto ay nasa harap ng iyong mga mata, at hindi mo kailangang tumakbo sa maraming tab upang lumikha, halimbawa, isang index o isang paghihigpit. Kapag patuloy na nagtatrabaho sa database, ang paglikha, pagbabago, at lalo na ang muling paglikha ng isang bagay gamit ang mga script ay maraming beses na mas mabilis kaysa kung ito ay ginagawa sa visual mode. Gayundin sa script mode (ayon sa pagkakabanggit, na may angkop na pangangalaga), mas madaling itakda at kontrolin ang mga patakaran para sa pagbibigay ng pangalan sa mga bagay (ang aking subjective na opinyon). Bilang karagdagan, ang mga script ay maginhawang gamitin kapag ang mga pagbabagong ginawa sa isang database (halimbawa, isang pagsubok) ay kailangang ilipat sa parehong form sa isa pang database (produktibo).

Ang wikang SQL ay nahahati sa ilang bahagi, dito ko isasaalang-alang ang 2 pinakamahalagang bahagi nito:

• DML - Data Manipulation Language (data manipulation language), na naglalaman ng mga sumusunod na construct:
  • PUMILI - pagpili ng data
  • INSERT - pagpasok ng bagong data
  • I-UPDATE - pag-update ng data
  • DELETE - pagtanggal ng data
  • MERGE - pagsasama ng data

kasi Ako ay isang practitioner, dahil magkakaroon ng kaunting teorya sa aklat-aralin na ito, at ang lahat ng mga konstruksyon ay ipapaliwanag na may mga praktikal na halimbawa. Bilang karagdagan, naniniwala ako na ang isang programming language, at lalo na ang SQL, ay maaari lamang maging mastered sa pagsasanay, sa pamamagitan ng pagpindot dito sa iyong sarili at pag-unawa kung ano ang mangyayari kapag naisagawa mo ito o ang konstruksiyon na iyon.

Ang tutorial na ito ay nilikha sa prinsipyo ng Hakbang sa Hakbang, i.e. kinakailangang basahin ito nang sunud-sunod at mas mabuti na agad na sundin ang mga halimbawa. Ngunit kung sa kahabaan ng paraan kailangan mong malaman ang tungkol sa isang utos nang mas detalyado, pagkatapos ay gumamit ng isang tiyak na paghahanap sa Internet, halimbawa, sa library ng MSDN.

Sa pagsulat ng tutorial na ito, gumamit ako ng MS SQL Server version 2014 database, at ginamit ko ang MS SQL Server Management Studio (SSMS) para patakbuhin ang mga script.

Maikling tungkol sa MS SQL Server Management Studio (SSMS)

Ang SQL Server Management Studio (SSMS) ay isang utility para sa Microsoft SQL Server para sa pag-configure, pamamahala at pangangasiwa ng mga bahagi ng database. Ang utility na ito ay naglalaman ng isang script editor (na pangunahing gagamitin namin) at isang graphical na programa na gumagana sa mga bagay at mga setting ng server. Ang pangunahing tool ng SQL Server Management Studio ay ang Object Explorer, na nagpapahintulot sa user na tingnan, kunin, at pamahalaan ang mga object ng server. Ang tekstong ito ay bahagyang hiniram mula sa Wikipedia.

Upang lumikha ng bagong editor ng script, gamitin ang pindutan ng Bagong Query:

Upang baguhin ang kasalukuyang database, maaari mong gamitin ang drop-down na listahan:

Upang magsagawa ng isang partikular na command (o grupo ng mga command), piliin ito at pindutin ang "Execute" na buton o pindutin ang "F5" key. Kung mayroon lamang isang utos sa editor sa ngayon, o kung kailangan mong isagawa ang lahat ng mga utos, kung gayon hindi mo kailangang pumili ng anuman.

Pagkatapos magsagawa ng mga script, lalo na ang mga lumilikha ng mga bagay (mga talahanayan, mga column, mga index), upang makita ang mga pagbabago, gamitin ang I-refresh mula sa menu ng konteksto, na i-highlight ang naaangkop na grupo (halimbawa, Mga Talahanayan), ang talahanayan mismo, o ang pangkat na Mga Column sa loob nito .

Sa totoo lang, ito lang ang kailangan nating malaman para makumpleto ang mga halimbawang ibinigay dito. Ang natitirang utility ng SSMS ay madaling matutunan nang mag-isa.

Medyo teorya

Ang isang relational database (RDB, o higit pa sa konteksto ng isang database lamang) ay isang koleksyon ng mga talahanayan na magkakaugnay. Sa halos pagsasalita, ang database ay isang file kung saan ang data ay nakaimbak sa isang structured na form.

DBMS - ang System para sa Pamamahala ng mga Database na ito, i.e. ito ay isang set ng mga tool para sa pagtatrabaho sa isang partikular na uri ng database (MS SQL, Oracle, MySQL, Firebird, ...).

Tandaan
kasi sa buhay, sa kolokyal na pananalita, kadalasang sinasabi natin: "Oracle DB", o kahit na "Oracle" lang, ibig sabihin ay "Oracle DBMS", at sa konteksto ng tutorial na ito minsan ay gagamitin ang terminong DB. Mula sa konteksto, sa tingin ko ay magiging malinaw kung ano ang eksaktong nakataya.

Ang talahanayan ay isang koleksyon ng mga column. Ang mga haligi ay maaari ding tawaging mga patlang o mga haligi, ang lahat ng mga salitang ito ay gagamitin bilang mga kasingkahulugan, na nagpapahayag ng parehong bagay.

Ang talahanayan ay ang pangunahing bagay ng RDB, ang lahat ng data ng RDB ay naka-imbak sa bawat linya sa mga haligi ng talahanayan. Ang mga linya, mga tala ay kasingkahulugan din.

Para sa bawat talahanayan, pati na rin ang mga haligi nito, ang mga pangalan ay ibinibigay, kung saan sila ay kasunod na tinutukoy.
Ang pangalan ng bagay (pangalan ng talahanayan, pangalan ng column, pangalan ng index, atbp.) sa MS SQL ay maaaring magkaroon ng maximum na haba na 128 character.

Para sa sanggunian– sa database ng ORACLE, maaaring magkaroon ng maximum na haba na 30 character ang mga pangalan ng object. Samakatuwid, para sa isang partikular na database, kailangan mong bumuo ng iyong sariling mga panuntunan para sa pagbibigay ng pangalan sa mga bagay upang matugunan ang limitasyon sa bilang ng mga character.

Ang SQL ay isang wika na nagbibigay-daan sa iyong i-query ang database sa pamamagitan ng DBMS. Sa isang partikular na DBMS, ang wikang SQL ay maaaring may partikular na pagpapatupad (sariling diyalekto).

Ang DDL at DML ay isang subset ng wikang SQL:

• Ang wika ng DDL ay ginagamit upang lumikha at baguhin ang istraktura ng database, i.e. upang lumikha/magbago/magtanggal ng mga talahanayan at mga relasyon.
• Ang wika ng DML ay nagpapahintulot sa iyo na manipulahin ang data ng talahanayan, i.e. kasama ang mga linya niya. Pinapayagan ka nitong pumili ng data mula sa mga talahanayan, magdagdag ng bagong data sa mga talahanayan, at mag-update at magtanggal ng umiiral na data.

Sa wikang SQL, maaari kang gumamit ng 2 uri ng komento (single-line at multi-line):

Isang linyang komento
at

/* multiline na komento */

Sa totoo lang, magiging sapat na ang lahat para sa teorya nito.

DDL - Data Definition Language (wika para sa paglalarawan ng data)

Halimbawa, isaalang-alang ang isang talahanayan na may data tungkol sa mga empleyado, sa anyo na pamilyar sa isang tao na hindi isang programmer:

Sa kasong ito, ang mga column ng talahanayan ay may mga sumusunod na pangalan: Numero ng tauhan, Buong pangalan, Petsa ng kapanganakan, E-mail, Posisyon, Departamento.

Ang bawat isa sa mga column na ito ay maaaring mailalarawan sa pamamagitan ng uri ng data na nilalaman nito:

• Numero ng tauhan - integer
• buong pangalan - string
• Petsa ng kapanganakan - petsa
• Email - string
• Posisyon - string
• departamento - string

Ang uri ng column ay isang katangian na nagsasaad kung anong uri ng data ang maiimbak ng column na ito.

Upang magsimula, sapat na na tandaan lamang ang mga sumusunod na pangunahing uri ng data na ginamit sa MS SQL:

Ibig sabihin	Notasyon sa MS SQL	Paglalarawan
Variable ang haba ng string	varchar(N) at nvarchar(N)	Gamit ang numerong N, maaari naming tukuyin ang maximum na posibleng haba ng string para sa kaukulang column. Halimbawa, kung gusto nating sabihin na ang halaga ng column na "Pangalan" ay maaaring maglaman ng maximum na 30 character, kailangan nating itakda ang uri nito sa nvarchar (30). Ang pagkakaiba sa pagitan ng varchar at nvarchar ay ang varchar ay nagpapahintulot sa iyo na mag-imbak ng mga string sa ASCII na format, kung saan ang isang character ay sumasakop ng 1 byte, habang ang nvarchar ay nag-iimbak ng mga string sa Unicode na format, kung saan ang bawat karakter ay sumasakop ng 2 byte. Ang uri ng varchar ay dapat lamang gamitin kung ikaw ay 100% sigurado na ang field ay hindi na kailangang mag-imbak ng mga Unicode na character. Halimbawa, maaaring gamitin ang varchar upang mag-imbak ng mga email address dahil kadalasan ay naglalaman lamang sila ng mga ASCII na character.
Nakapirming haba ng string	char(N) at nchar(N)	Ang uri na ito ay naiiba sa isang variable na haba ng string na kung ang haba ng string ay mas mababa sa N na mga character, pagkatapos ay ito ay palaging may palaman sa kanan sa haba ng N mga puwang at naka-imbak sa database sa form na ito, i.e. sa database ito ay sumasakop ng eksaktong N character (kung saan ang isang character ay sumasakop ng 1 byte para sa char at 2 bytes para sa nchar). Sa aking pagsasanay, ang ganitong uri ay napakabihirang ginagamit, at kung ito ay ginagamit, kung gayon ito ay pangunahing ginagamit sa char (1) na format, i.e. kapag ang field ay tinukoy ng isang character.
Integer	int	Ang ganitong uri ay nagbibigay-daan sa amin na gumamit lamang ng mga integer, parehong positibo at negatibo, sa column. Para sa sanggunian (ito ay hindi gaanong nauugnay para sa amin ngayon) - ang hanay ng mga numero na pinapayagan ng uri ng int mula -2 147 483 648 hanggang 2 147 483 647. Karaniwang ito ang pangunahing uri na ginagamit upang magtakda ng mga identifier.
Totoo o totoong numero	lumutang	Sa madaling salita, ito ay mga numero kung saan maaaring mayroong decimal point (kuwit).
petsa	petsa	Kung kinakailangan na mag-imbak lamang ng Petsa sa column, na binubuo ng tatlong bahagi: Numero, Buwan at Taon. Halimbawa, 02/15/2014 (Pebrero 15, 2014). Maaaring gamitin ang ganitong uri para sa column na "Petsa ng pagpasok", "Petsa ng kapanganakan", atbp., i.e. sa mga kaso kung saan mahalaga para sa amin na ayusin lamang ang petsa, o kapag ang bahagi ng oras ay hindi mahalaga sa amin at maaaring itapon o kung hindi ito alam.
Oras	oras	Maaaring gamitin ang ganitong uri kung ang column ay kailangang mag-imbak lamang ng data ng oras, i.e. Mga Oras, Minuto, Segundo at Milisecond. Halimbawa, 17:38:31.3231603 Halimbawa, ang pang-araw-araw na "Flight Departure Time".
petsa at oras	datetime	Ang ganitong uri ay nagbibigay-daan sa iyo na mag-imbak ng parehong Petsa at Oras sa parehong oras. Halimbawa, 02/15/2014 5:38:31.323 PM Halimbawa, maaaring ito ang petsa at oras ng isang kaganapan.
Bandila	bit	Ang uri na ito ay kapaki-pakinabang para sa pag-iimbak ng mga halaga ng Oo/Hindi, kung saan ang Oo ay maiimbak bilang 1 at Hindi ay maiimbak bilang 0.

Gayundin, ang halaga ng field, kung sakaling hindi ito ipinagbabawal, ay maaaring hindi tukuyin, para sa layuning ito ang NULL na keyword ay ginagamit.

Upang patakbuhin ang mga halimbawa, gumawa tayo ng isang database ng pagsubok na tinatawag na Pagsubok.

Ang isang simpleng database (nang walang pagtukoy ng mga karagdagang parameter) ay maaaring malikha sa pamamagitan ng pagpapatakbo ng sumusunod na command:

GUMAWA NG DATABASE Test
Maaari mong tanggalin ang database gamit ang utos (dapat kang maging maingat sa utos na ito):

DROP DATABASE Test
Upang lumipat sa aming database, maaari mong patakbuhin ang command:

Pagsusulit sa US
Bilang kahalili, piliin ang Test database mula sa drop-down na listahan sa SSMS menu area. Sa trabaho, madalas kong ginagamit ang pamamaraang ito ng paglipat sa pagitan ng mga database.

Ngayon sa aming database maaari kaming lumikha ng isang talahanayan gamit ang mga paglalarawan kung paano sila, gamit ang mga puwang at mga Cyrillic na character:

GUMAWA NG TABLE [Mga Empleyado]([Personnel Number] int, [Pangalan] nvarchar(30), [Petsa ng Kapanganakan] petsa, nvarchar(30), [Posisyon] nvarchar(30), [Department] nvarchar(30))
Sa kasong ito, kakailanganin naming ilakip ang mga pangalan sa mga square bracket […].

Ngunit sa database, para sa higit na kaginhawahan, mas mahusay na tukuyin ang lahat ng mga pangalan ng mga bagay sa Latin at huwag gumamit ng mga puwang sa mga pangalan. Sa MS SQL, kadalasan sa kasong ito, ang bawat salita ay nagsisimula sa isang malaking titik, halimbawa, para sa field na "Personnel number", maaari naming itakda ang pangalang PersonnelNumber. Maaari ka ring gumamit ng mga numero sa pangalan, halimbawa, PhoneNumber1.

Sa isang tala
Sa ilang DBMS, ang sumusunod na format ng mga pangalan na "PHONE_NUMBER" ay maaaring mas gusto, halimbawa, ang format na ito ay kadalasang ginagamit sa ORACLE database. Naturally, kapag nagtatakda ng pangalan ng field, kanais-nais na hindi ito tumutugma sa mga keyword na ginamit sa DBMS.

Para sa kadahilanang ito, maaari mong kalimutan ang tungkol sa square bracket syntax at tanggalin ang talahanayan ng [Mga Empleyado]:

DROP TABLE [Mga Empleyado]
Halimbawa, ang isang talahanayan na may mga empleyado ay maaaring pangalanan na "Mga Empleyado" at ang mga field nito ay maaaring bigyan ng mga sumusunod na pangalan:

• ID - Numero ng Tauhan (Employee ID)
• Pangalan - buong pangalan
• Kaarawan - Petsa ng kapanganakan
• Email
• Posisyon
• Departamento - Departamento

Kadalasan, ginagamit ang salitang ID upang pangalanan ang field ng identifier.

Ngayon likhain natin ang aming talahanayan:

GUMAWA NG TABLE Mga Empleyado(ID int, Pangalan nvarchar(30), Petsa ng kaarawan, Email nvarchar(30), Posisyon nvarchar(30), Departamento nvarchar(30))
Maaari mong gamitin ang NOT NULL na opsyon upang tukuyin ang mga kinakailangang column.

Para sa isang umiiral nang talahanayan, ang mga patlang ay maaaring muling tukuyin gamit ang mga sumusunod na command:

I-update ang field ng ID ALTER TABLE Mga empleyado ALTER COLUMN ID int NOT NULL -- update Name field ALTER TABLE Mga empleyado ALTER COLUMN Name nvarchar(30) NOT NULL

Sa isang tala
Ang pangkalahatang konsepto ng wikang SQL para sa karamihan ng DBMS ay nananatiling pareho (hindi bababa sa, maaari kong hatulan ito mula sa mga DBMS kung saan ako nagkaroon ng pagkakataong magtrabaho). Ang pagkakaiba sa pagitan ng DDL sa iba't ibang mga DBMS ay pangunahin sa mga uri ng data (hindi lamang ang kanilang mga pangalan ay maaaring magkaiba dito, kundi pati na rin ang mga detalye ng kanilang pagpapatupad), ang mismong mga detalye ng pagpapatupad ng wikang SQL ay maaari ding bahagyang naiiba (ibig sabihin, ang kakanyahan ng ang mga utos ay pareho, ngunit maaaring may kaunting pagkakaiba sa diyalekto, sayang, ngunit walang isang pamantayan). Alam ang mga pangunahing kaalaman ng SQL, madali kang lumipat mula sa isang DBMS patungo sa isa pa. sa kasong ito, kakailanganin mo lamang na maunawaan ang mga detalye ng pagpapatupad ng mga utos sa bagong DBMS, i.e. sa karamihan ng mga kaso, ito ay sapat lamang upang gumuhit ng isang pagkakatulad.

Paglikha ng talahanayan GUMAWA NG TABLE Employees(ID int, -- sa uri ng ORACLE int ay ang katumbas (wrapper) para sa numero(38) Pangalan nvarchar2(30), -- nvarchar2 sa ORACLE ay katumbas ng nvarchar sa MS SQL Petsa ng kaarawan, Email nvarchar2( 30) , Posisyon nvarchar2(30), Departamento nvarchar2(30)); -- ang pag-update ng mga field ng ID at Pangalan (dito ang MODIFY(…) ay ginagamit sa halip na ALTER COLUMN ALTER TABLE Employees MODIFY(ID int NOT NULL,Name nvarchar2(30) NOT NULL); -- pagdaragdag ng PK (sa kasong ito, ang konstruksyon ay mukhang sa MS SQL, ito ay ipapakita sa ibaba) ALTER TABLE Employees ADD CONSTRAINT PK_Employees PRIMARY KEY(ID);
Para sa ORACLE, may mga pagkakaiba sa mga tuntunin ng pagpapatupad ng uri ng varchar2, ang pag-encode nito ay nakasalalay sa mga setting ng database at ang teksto ay maaaring i-save, halimbawa, sa pag-encode ng UTF-8. Bilang karagdagan, ang haba ng field sa ORACLE ay maaaring itakda pareho sa mga byte at sa mga character, para dito, ginagamit ang mga karagdagang opsyon na BYTE at CHAR, na tinukoy pagkatapos ng haba ng field, halimbawa:

NAME varchar2(30 BYTE) -- magiging 30 bytes ang kapasidad ng field NAME varchar2(30 CHAR) -- magiging 30 character ang kapasidad ng field
Aling opsyon ang gagamitin bilang default na BYTE o CHAR, sa kaso ng isang simpleng detalye ng uri ng varchar2(30) sa ORACLE, depende sa mga setting ng database, maaari rin itong itakda minsan sa mga setting ng IDE. Sa pangkalahatan, kung minsan madali kang malito, kaya sa kaso ng ORACLE, kung ang uri ng varchar2 ay ginagamit (at kung minsan ito ay nabibigyang katwiran dito, halimbawa, kapag gumagamit ng pag-encode ng UTF-8), mas gusto kong tahasang isulat ang CHAR (dahil kadalasang mas maginhawang basahin ang haba ng isang string sa mga character ).

Ngunit sa kasong ito, kung mayroon nang ilang data sa talahanayan, kung gayon para sa matagumpay na pagpapatupad ng mga utos, kinakailangan na ang mga patlang ng ID at Pangalan sa lahat ng mga hilera ng talahanayan ay dapat punan. Ipakita natin ito sa isang halimbawa, ipasok ang data sa talahanayan sa mga patlang ng ID, Posisyon at Departamento, maaari itong gawin gamit ang sumusunod na script:

INSERT Employees(ID,Position,Department) VALUES (1000,N"Director",N"Administration"), (1001,N"Programmer",N"IT"), (1002,N"Accountant",N"Accounting" ), (1003,N"Senior programmer",N"IT")
Sa kasong ito, ang INSERT command ay magtapon din ng error, dahil kapag nagpasok, hindi namin tinukoy ang halaga ng kinakailangang field ng Pangalan.
Kung mayroon na kaming data na ito sa orihinal na talahanayan, kung gayon ang utos na "ALTER TABLE Employees ALTER COLUMN ID int NOT NULL" ay matagumpay na naisakatuparan, at ang command na "ALTER TABLE Employees ALTER COLUMN Name int NOT NULL" ay maglalabas ng isang error mensahe, na mayroong NULL (hindi tinukoy) na mga halaga sa field na Pangalan.

Magdagdag tayo ng mga halaga para sa field na Pangalan at punan muli ang data:

Gayundin, ang NOT NULL na opsyon ay maaaring gamitin nang direkta kapag lumilikha ng bagong talahanayan, i.e. sa konteksto ng CREATE TABLE command.

Una, tanggalin ang talahanayan na may utos:

DROP TABLE Mga empleyado
Ngayon, gumawa tayo ng table na may mandatoryong ID at Name na column:

CREATE TABLE Employees(ID int NOT NULL, Name nvarchar(30) NOT NULL, Birthday date, Email nvarchar(30), Position nvarchar(30), Department nvarchar(30))
Maaari mo ring isulat ang NULL pagkatapos ng pangalan ng column, na nangangahulugang ang mga NULL na halaga (hindi tinukoy) ay papayagan dito, ngunit hindi ito kinakailangan, dahil ang katangiang ito ay ipinahiwatig bilang default.

Kung, sa kabaligtaran, gusto mong gawing opsyonal ang umiiral na column, pagkatapos ay gamitin ang sumusunod na command syntax:

ALTER TABLE Empleyado ALTER COLUMN Pangalan nvarchar(30) NULL
O kaya lang:

ALTER TABLE Mga Empleyado ALTER COLUMN Pangalan nvarchar(30)
Sa utos na ito, maaari rin nating baguhin ang uri ng field sa isa pang katugmang uri, o baguhin ang haba nito. Halimbawa, palawakin natin ang field ng Pangalan sa 50 character:

ALTER TABLE Mga Empleyado ALTER COLUMN Pangalan nvarchar(50)

pangunahing susi

Kapag gumagawa ng isang talahanayan, ito ay kanais-nais na ito ay may isang natatanging hanay o isang hanay ng mga hanay na natatangi para sa bawat isa sa mga hilera nito - isang talaan ay maaaring natatanging makilala sa pamamagitan ng natatanging halaga. Ang halagang ito ay tinatawag na pangunahing susi ng talahanayan. Para sa aming talahanayan ng Mga Empleyado, maaaring ang natatanging value na ito ay ang column ng ID (na naglalaman ng "Numero ng Tauhan ng Empleyado" - kahit na sa aming kaso ay natatangi ang value na ito para sa bawat empleyado at hindi na mauulit).

Maaari kang lumikha ng pangunahing susi sa isang umiiral na talahanayan gamit ang utos:

ALTER TABLE Employees ADD CONSTRAINT PK_Employees PRIMARY KEY(ID)
Kung saan ang "PK_Employees" ay ang pangalan ng constraint na responsable para sa primary key. Karaniwan, ang pangunahing key ay pinangalanan na may prefix na "PK_" na sinusundan ng pangalan ng talahanayan.

Kung ang pangunahing key ay binubuo ng ilang mga field, ang mga field na ito ay dapat na nakalista sa mga bracket na pinaghihiwalay ng mga kuwit:

ALTER TABLE table_name ADD CONSTRAINT constraint_name PRIMARY KEY(field1,field2,…)
Ito ay nagkakahalaga ng noting na sa MS SQL lahat ng mga patlang na kasama sa pangunahing susi ay dapat magkaroon ng NOT NULL na katangian.

Gayundin, ang pangunahing susi ay maaaring direktang tukuyin kapag lumilikha ng isang talahanayan, i.e. sa konteksto ng CREATE TABLE command. Tanggalin natin ang talahanayan:

DROP TABLE Mga empleyado
At pagkatapos ay likhain ito gamit ang sumusunod na syntax:

CREATE TABLE Employees(ID int NOT NULL, Name nvarchar(30) NOT NULL, Birthday date, Email nvarchar(30), Position nvarchar(30), Department nvarchar(30), CONSTRAINT PK_Employees PRIMARY KEY(ID) -- ilarawan ang PK pagkatapos lahat ng mga patlang bilang isang hadlang)
Pagkatapos ng paggawa, punan ang data ng talahanayan:

INSERT Employees(ID, Position, Department, Name) VALUES (1000,N"Director",N"Administration",N"Ivanov II.), (1001,N"Programmer",N"IT",N" Petrov PP" ), (1002,N"Accountant",N"Accounting",N"Sidorov SS"), (1003,N"Senior Programmer",N"IT",N"Andreev A. A.")
Kung ang pangunahing susi sa talahanayan ay binubuo lamang ng mga halaga ng isang hanay, kung gayon ang sumusunod na syntax ay maaaring gamitin:

CREATE TABLE Employees(ID int NOT NULL CONSTRAINT PK_Employees PRIMARY KEY, -- tukuyin ang Pangalan nvarchar(30) NOT NULL, Petsa ng kaarawan, Email nvarchar(30), Posisyon nvarchar(30), Department nvarchar(30))
Sa katunayan, maaaring tanggalin ang pangalan ng hadlang, kung saan bibigyan ito ng pangalan ng system (tulad ng "PK__Employee__3214EC278DA42077"):

CREATE TABLE Employees(ID int NOT NULL, Name nvarchar(30) NOT NULL, Birthday date, Email nvarchar(30), Position nvarchar(30), Department nvarchar(30), PRIMARY KEY(ID))
O kaya:

GUMAWA NG TABLE Employees(ID int NOT NULL PRIMARY KEY, Name nvarchar(30) NOT NULL, Birthday date, Email nvarchar(30), Position nvarchar(30), Department nvarchar(30))
Ngunit inirerekumenda ko na palagi mong tahasang itakda ang pangalan ng pagpilit para sa mga permanenteng talahanayan, dahil sa pamamagitan ng isang tahasang ibinigay at nauunawaan na pangalan, pagkatapos ay magiging mas madaling manipulahin ito, halimbawa, maaari mo itong tanggalin:

ALTER TABLE Employees DROP CONSTRAINT PK_Employees
Ngunit ang gayong maikling syntax, nang hindi tinukoy ang mga pangalan ng mga paghihigpit, ay maginhawang gamitin kapag lumilikha ng mga pansamantalang talahanayan ng database (ang pangalan ng pansamantalang talahanayan ay nagsisimula sa # o ##), na tatanggalin pagkatapos gamitin.

I-summarize natin

Sa ngayon ay sakop namin ang mga sumusunod na utos:

• GUMAWA NG TALAAN table_name (enumeration ng mga patlang at ang kanilang mga uri, mga paghihigpit) - ginagamit upang lumikha ng isang bagong talahanayan sa kasalukuyang database;
• DROP TABLE table_name - ginagamit upang tanggalin ang isang talahanayan mula sa kasalukuyang database;
• ALTER TABLE table_name ALTER COLUMN column_name … – ginagamit para i-update ang uri ng column o para baguhin ang mga setting nito (halimbawa, para itakda ang NULL o NOT NULL na katangian);
• ALTER TABLE table_name MAGDAGDAG NG PAGPILITAN constraint_name PANGUNAHING SUSI(field1, field2,…) – pagdaragdag ng pangunahing key sa isang umiiral na talahanayan;
• ALTER TABLE table_name DROP CONSTRAINT constraint_name - alisin ang pagpilit mula sa talahanayan.

Kaunti tungkol sa mga pansamantalang talahanayan

Pag-clip mula sa MSDN. Mayroong dalawang uri ng mga pansamantalang talahanayan sa MS SQL Server: lokal (#) at global (##). Ang mga lokal na pansamantalang talahanayan ay makikita lamang ng kanilang mga tagalikha hanggang sa ang session ng koneksyon sa instance ng SQL Server ay winakasan kapag sila ay unang ginawa. Awtomatikong tinatanggal ang mga lokal na pansamantalang talahanayan pagkatapos magdiskonekta ang isang user mula sa isang halimbawa ng SQL Server. Ang mga pandaigdigang pansamantalang talahanayan ay makikita ng lahat ng mga gumagamit sa panahon ng anumang mga sesyon ng koneksyon pagkatapos gawin ang mga talahanayang ito, at tatanggalin kapag ang lahat ng mga gumagamit na tumutukoy sa mga talahanayang ito ay nadiskonekta mula sa halimbawa ng SQL Server.

Ang mga pansamantalang talahanayan ay nilikha sa database ng tempdb system, i.e. paglikha ng mga ito, hindi namin barado ang pangunahing database, kung hindi man ang mga pansamantalang talahanayan ay ganap na magkapareho sa mga regular na talahanayan, maaari din silang tanggalin gamit ang DROP TABLE na utos. Mas karaniwang ginagamit ang lokal (#) na mga pansamantalang talahanayan.

Upang lumikha ng pansamantalang talahanayan, maaari mong gamitin ang command na CREATE TABLE:

GUMAWA NG TALAAN #Temp(ID int, Pangalan nvarchar(30))
Dahil ang isang pansamantalang talahanayan sa MS SQL ay katulad ng isang regular na talahanayan, maaari mo ring tanggalin ito nang naaayon sa utos na DROP TABLE:

DROP TABLE #Temp

Maaari ka ring lumikha ng isang pansamantalang talahanayan (pati na rin ang isang regular na talahanayan) at agad na punan ito ng data na ibinalik ng query gamit ang SELECT ... INTO syntax:

PUMILI NG ID, Pangalan SA #Temp MULA SA Mga Empleyado

Sa isang tala
Sa iba't ibang DBMS, maaaring magkaiba ang pagpapatupad ng mga pansamantalang talahanayan. Halimbawa, sa ORACLE at Firebird DBMS, ang istraktura ng mga pansamantalang talahanayan ay dapat na matukoy nang maaga sa pamamagitan ng CREATE GLOBAL TEMPORARY TABLE na utos, na nagpapahiwatig ng mga detalye ng pag-iimbak ng data dito, pagkatapos ay makikita ito ng user sa mga pangunahing talahanayan at gumagana kasama nito tulad ng sa isang regular na mesa.

Normalization ng database - paghahati sa mga sub-table (mga direktoryo) at pagtukoy ng mga relasyon

Ang aming kasalukuyang talahanayan ng Mga Empleyado ay may kawalan na ang user ay maaaring magpasok ng anumang teksto sa mga patlang ng Posisyon at Departamento, na pangunahing puno ng mga error, dahil para sa isang empleyado maaari niyang ipahiwatig lamang ang "IT" bilang departamento, at para sa pangalawang empleyado, para sa halimbawa , ilagay ang "IT department", magkaroon ng pangatlong "IT". Bilang resulta, hindi magiging malinaw kung ano ang ibig sabihin ng user, i.e. Ang mga empleyado ba ay mga empleyado ng parehong departamento, o inilarawan ba ng gumagamit ang kanyang sarili at ito ay 3 magkaibang departamento? At higit pa rito, sa kasong ito, hindi namin magagawang igrupo nang tama ang data para sa ilang ulat, kung saan maaaring kailanganing ipakita ang bilang ng mga empleyado sa konteksto ng bawat departamento.

Ang pangalawang disbentaha ay ang dami ng imbakan ng impormasyong ito at ang pagdoble nito, i.e. para sa bawat empleyado, ang buong pangalan ng departamento ay ipinahiwatig, na nangangailangan ng isang lugar sa database upang iimbak ang bawat karakter mula sa pangalan ng departamento.

Ang pangatlong disbentaha ay ang kahirapan sa pag-update ng mga field na ito kung nagbabago ang pangalan ng isang posisyon, halimbawa, kung kailangan mong palitan ang pangalan ng posisyon na "Programmer" sa "Junior programmer". Sa kasong ito, kailangan nating gumawa ng mga pagbabago sa bawat linya ng talahanayan, kung saan ang Posisyon ay katumbas ng "Programmer".

Upang maiwasan ang mga pagkukulang na ito, ginagamit ang tinatawag na normalisasyon ng database - paghahati nito sa mga sub-table, mga reference table. Hindi kinakailangang umakyat sa gubat ng teorya at pag-aralan kung ano ang mga normal na anyo, sapat na upang maunawaan ang kakanyahan ng normalisasyon.

Gumawa tayo ng 2 reference na talahanayan na "Mga Posisyon" at "Mga Kagawaran", ang una ay tatawaging Mga Posisyon, at ang pangalawa, ayon sa pagkakabanggit, Mga Departamento:

GUMAWA NG TALAHANAYAN Mga Posisyon(ID int IDENTITY(1,1) NOT NULL CONSTRAINT PK_Positions PRIMARY KEY, Pangalan nvarchar(30) NOT NULL) GUMAWA NG TALAAN Mga Departamento(ID int IDENTITY(1,1) NOT NULL CONSTRAINT PK_Departments PRIMARY KEY, Pangalan nvarchar(30 ) HINDI NULL)
Tandaan na dito ginamit namin ang bagong opsyon sa IDENTITY, na nangangahulugang awtomatikong mabibilang ang data sa column ng ID, simula sa 1, na may hakbang na 1, i.e. kapag nagdagdag ng mga bagong tala, sila ay magkakasunod na itatalaga ang mga halaga 1, 2, 3, at iba pa. Ang ganitong mga field ay karaniwang tinatawag na auto-incrementing. Isang field lang na may IDENTITY property ang maaaring tukuyin sa isang table, at kadalasan, ngunit hindi kinakailangan, ang naturang field ang pangunahing key para sa table na iyon.

Sa isang tala
Sa iba't ibang DBMS, ang pagpapatupad ng mga patlang na may isang counter ay maaaring gawin sa ibang paraan. Sa MySQL, halimbawa, ang naturang field ay tinukoy gamit ang AUTO_INCREMENT na opsyon. Sa ORACLE at Firebird, ang functionality na ito ay dati nang maaaring tularan gamit ang SEQUENCEs. Pero sa pagkakaalam ko, idinagdag na ngayon ng ORACLE ang GENERATED AS IDENTITY na opsyon.

Awtomatiko nating punan ang mga talahanayang ito, batay sa kasalukuyang data na naitala sa mga patlang ng Posisyon at Departamento ng talahanayan ng Mga Empleyado:

Punan ang patlang ng Pangalan ng talahanayan ng Mga Posisyon na may mga natatanging halaga mula sa patlang ng Posisyon ng talahanayan ng Mga Empleyado INSERT Positions(Pangalan) SELECT DISTINCT Position FROM Employees WHERE Position IS NOT NULL -- itapon ang mga record na walang tinukoy na posisyon
Gayon din ang gagawin namin para sa talahanayan ng mga Departamento:

INSERT Departamento(Pangalan) PUMILI NG DISTINCT na Departamento MULA SA Mga Empleyado KUNG SAAN ANG Departamento AY HINDI NULL
Kung bubuksan natin ngayon ang mga talahanayan ng Mga Posisyon at Departamento, makakakita tayo ng may bilang na hanay ng mga halaga ayon sa field ng ID:

PUMILI * MULA SA Mga Posisyon

PUMILI * MULA SA Mga Departamento

Gagampanan na ng mga talahanayang ito ang papel ng mga direktoryo para sa pagtatakda ng mga posisyon at departamento. Magre-refer kami ngayon sa mga job at department ID. Una sa lahat, gumawa tayo ng mga bagong field sa Employees table para iimbak ang ID data:

Magdagdag ng field para sa position ID ALTER TABLE Mga Empleyado ADD PositionID int -- magdagdag ng field para sa department ID ALTER TABLE Mga Empleyado ADD DepartmentID int
Ang uri ng mga patlang ng sanggunian ay dapat na kapareho ng sa mga direktoryo, sa kasong ito ito ay int.

Maaari ka ring magdagdag ng ilang mga patlang sa talahanayan nang sabay-sabay gamit ang isang utos, na naglilista ng mga patlang na pinaghihiwalay ng mga kuwit:

ALTER TABLE Mga Empleyado ADD PositionID int, DepartmentID int
Ngayon magsulat tayo ng mga link (mga hadlang sa sanggunian - FOREIGN KEY) para sa mga patlang na ito, upang ang user ay hindi magkaroon ng pagkakataon na magsulat sa mga patlang na ito, mga halaga na hindi kabilang sa mga halaga ng ID sa mga direktoryo.

ALTER TABLE Mga Empleyado ADD CONSTRAINT FK_Employees_PositionID FOREIGN KEY(PositionID) REFERENCES Positions(ID)
At gagawin namin ang parehong para sa pangalawang field:

ALTER TABLE Employees ADD CONSTRAINT FK_Employees_DepartmentID FOREIGN KEY(DepartmentID) REFERENCES Departments(ID)
Ngayon ang user ay makakapagpasok lamang ng mga halaga ng ID mula sa kaukulang reference book sa mga field na ito. Alinsunod dito, upang makagamit ng bagong departamento o posisyon, kailangan muna niyang magdagdag ng bagong entry sa kaukulang direktoryo. kasi ang mga posisyon at departamento ay naka-imbak na ngayon sa mga direktoryo sa isang kopya, pagkatapos ay upang baguhin ang pangalan, sapat na upang baguhin lamang ito sa direktoryo.

Ang pangalan ng isang referential constraint ay karaniwang tambalan, ito ay binubuo ng prefix na "FK_", na sinusundan ng pangalan ng talahanayan, at pagkatapos ng underscore, ay ang pangalan ng field na tumutukoy sa identifier ng lookup table.

Ang identifier (ID) ay karaniwang isang panloob na halaga na ginagamit lamang para sa mga link at kung anong halaga ang nakaimbak doon, sa karamihan ng mga kaso, ito ay ganap na walang malasakit, kaya hindi na kailangang subukang alisin ang mga butas sa pagkakasunud-sunod ng mga numero na bumangon sa kurso ng pagtatrabaho sa isang talahanayan, halimbawa, pagkatapos tanggalin ang mga talaan mula sa handbook.

ALTER TABLE table ADD CONSTRAINT constraint_name FOREIGN KEY(field1,field2,…) REFERENCES lookup table(field1,field2,…)
Sa kasong ito, sa talahanayang "table_reference", ang pangunahing key ay kinakatawan ng isang kumbinasyon ng ilang mga field (field1, field2, ...).

Sa totoo lang, ngayon ay i-update natin ang mga field ng PositionID at DepartmentID kasama ang mga halaga ng ID mula sa mga direktoryo. Gamitin natin ang UPDATE DML command para sa layuning ito:

I-UPDATE at I-SET ang PositionID=(SELECT ID FROM Positions WHERE Name=e.Position), DepartmentID=(SELECT ID FROM Departments WHERE Name=e.Department) MULA sa Mga Empleyado e
Tingnan natin kung ano ang mangyayari sa pamamagitan ng pagpapatakbo ng query:

PUMILI * MULA SA Mga Empleyado

Iyon lang, ang mga patlang ng PositionID at DepartmentID ay puno ng mga kaukulang posisyon at departamento na may mga ID ng pangangailangan sa mga patlang ng Position at Departamento sa talahanayan ng Mga Empleyado ngayon, maaari mong tanggalin ang mga patlang na ito:

ALTER TABLE Empleyado DROP COLUMN Posisyon, Departamento
Ang talahanayan ngayon ay ganito ang hitsura:

PUMILI * MULA SA Mga Empleyado

ID	Pangalan	Birthday	Email	PositionID	DepartmentID
1000	Ivanov I.I.	WALA	WALA	2	1
1001	Petrov P.P.	WALA	WALA	3	3
1002	Sidorov S.S.	WALA	WALA	1	2
1003	Andreev A.A.	WALA	WALA	4	3

Yung. sa kalaunan ay inalis namin ang pag-iimbak ng labis na impormasyon. Ngayon, sa pamamagitan ng posisyon at mga numero ng departamento, maaari nating natatanging matukoy ang kanilang mga pangalan gamit ang mga halaga sa mga talahanayan ng paghahanap:

PUMILI ng e.ID,e.Pangalan,p.Pangalan PositionName,d.Pangalan ng Pangalan ng Kagawaran MULA sa Mga Empleyado e LEFT SUMALI Mga Departamento d ON d.ID=e.DepartmentID LEFT SUMALI Mga Posisyon p ON p.ID=e.PositionID

Sa Object Inspector, makikita natin ang lahat ng bagay na nilikha para sa isang ibinigay na talahanayan. Mula dito maaari ka ring magsagawa ng iba't ibang manipulasyon sa mga bagay na ito - halimbawa, palitan ang pangalan o tanggalin ang mga bagay.

Nararapat din na tandaan na ang isang talahanayan ay maaaring sumangguni sa sarili nito, i.e. maaari kang lumikha ng isang recursive link. Halimbawa, magdagdag tayo ng isa pang field na ManagerID sa ating talahanayan kasama ang mga empleyado, na magsasaad ng empleyado kung kanino nag-uulat ang empleyadong ito. Gumawa tayo ng field:

ALTER TABLE Employees ADD ManagerID int
Ang NULL na halaga ay pinapayagan sa patlang na ito, ang patlang ay walang laman kung, halimbawa, walang mga superyor sa empleyado.

Ngayon, gumawa tayo ng FOREIGN KEY sa Employees table:

ALTER TABLE Employees ADD CONSTRAINT FK_Employees_ManagerID FOREIGN KEY (ManagerID) REFERENCES Employees(ID)
Gumawa tayo ngayon ng isang diagram at tingnan kung ano ang hitsura ng mga ugnayan sa pagitan ng aming mga talahanayan:

Bilang resulta, dapat nating makita ang sumusunod na larawan (ang talahanayan ng Mga Empleyado ay nauugnay sa mga talahanayan ng Mga Posisyon at Depertment, at tumutukoy din sa sarili nito):

Sa wakas, ito ay nagkakahalaga ng pagbanggit na ang mga reference key ay maaaring magsama ng mga karagdagang opsyon ON DELETE CASCADE at ON UPDATE CASCADE, na nagsasabi kung paano kumilos kapag nagde-delete o nag-a-update ng record na naka-reference sa lookup table. Kung hindi tinukoy ang mga opsyong ito, hindi namin mababago ang ID sa talahanayan ng direktoryo ng entry na may mga link mula sa isa pang talahanayan, at hindi rin namin maaaring tanggalin ang naturang entry mula sa direktoryo hanggang sa tanggalin namin ang lahat ng mga row na tumutukoy sa entry na ito o, Let's i-update ang mga linyang ito ng mga sanggunian sa isa pang halaga.

Halimbawa, muli nating likhain ang talahanayan gamit ang opsyong ON DELETE CASCADE para sa FK_Employees_DepartmentID:

DROP TABLE Employees CREATE TABLE Employees(ID int NOT NULL, Name nvarchar(30), Birthday date, Email nvarchar(30), PositionID int, DepartmentID int, ManagerID int, CONSTRAINT PK_Employees PRIMARY KEY (ID), CONSTRAINT FK_EmployeesDepart_Employees FOR ) REFERENCES Departments(ID) ON DELETE CASCADE, CONSTRAINT FK_Employees_PositionID FOREIGN KEY(PositionID) REFERENCES Positions(ID), CONSTRAINT FK_Employees_ManagerID FOREIGN KEY (ManagerID) REFERENCES Employees(ID,PositionID)REFERENCES Employees(ID)DedayNagerID )VALUES (1000,N"Ivanov II","19550219",2,1,NULL), (1001,N"Petrov PP","19831203",3,3,1003), (1002 ,N"Sidorov SS" ,"19760607",1,2,1000), (1003,N"Andreev AA","19820417",4,3,1000)
Alisin natin ang departamentong may ID 3 mula sa talahanayan ng Mga Departamento:

I-delete ang Mga Departamento WHERE ID=3
Tingnan natin ang data sa talahanayan ng Mga Empleyado:

PUMILI * MULA SA Mga Empleyado

ID	Pangalan	Birthday	Email	PositionID	DepartmentID	ManagerID
1000	Ivanov I.I.	1955-02-19	WALA	2	1	WALA
1002	Sidorov S.S.	1976-06-07	WALA	1	2	1000

Gaya ng nakikita mo, ang data para sa departamento 3 ay tinanggal din mula sa talahanayan ng Mga Empleyado.

Ang opsyon na ON UPDATE CASCADE ay kumikilos nang katulad, ngunit ito ay magkakabisa kapag ina-update ang halaga ng ID sa direktoryo. Halimbawa, kung babaguhin namin ang position ID sa direktoryo ng mga posisyon, sa kasong ito, maa-update ang DepartmentID sa talahanayan ng Mga Empleyado sa bagong halaga ng ID na itinakda namin sa direktoryo. Ngunit sa kasong ito, hindi posible na ipakita ito, dahil. ang ID column sa talahanayan ng Mga Departamento ay may opsyon na IDENTITY, na hahadlang sa amin na isagawa ang sumusunod na query (baguhin ang department ID 3 hanggang 30):

I-UPDATE ang Mga Departamento SET ID=30 WHERE ID=3
Ang pangunahing bagay ay upang maunawaan ang kakanyahan ng 2 pagpipiliang ito ON DELETE CASCADE at ON UPDATE CASCADE. Ginagamit ko ang mga opsyong ito sa mga bihirang pagkakataon, at inirerekomenda ko na pag-isipan mong mabuti bago tukuyin ang mga ito sa isang referential constraint. kung hindi mo sinasadyang matanggal ang isang tala mula sa reference table, maaari itong humantong sa malalaking problema at lumikha ng isang chain reaction.

Ibalik natin ang departamento 3:

Bigyan ng pahintulot na magdagdag/magpalit ng IDENTITY values ​​SET IDENTITY_INSERT Departments ON INSERT Departments(ID,Pangalan) VALUES(3,N"IT") -- tanggihan ang pagdaragdag/pagpapalit ng IDENTITY values ​​SET IDENTITY_INSERT Departments OFF
Ganap na i-clear ang Employees table gamit ang TRUNCATE TABLE command:

TRUNCATE TABLE Mga empleyado
At muli, i-reload ang data dito gamit ang nakaraang INSERT command:

INSERT Employees (ID,Pangalan,Birthday,PositionID,DepartmentID,ManagerID)VALUES (1000,N"Ivanov II","19550219",2,1,NULL), (1001,N"Petrov P.P." ,"19831203",3 ,3,1003), (1002,N"Sidorov SS","19760607",1,2,1000), (1003,N"Andreev AA,"19820417" ,4,3,1000)

I-summarize natin

Sa ngayon, ilan pang DDL command ang naidagdag sa aming kaalaman:

• Ang pagdaragdag ng IDENTITY property sa field - nagbibigay-daan sa iyong gawing awtomatikong punan ang field na ito (counter field) para sa table;
• ALTER TABLE table_name ADD list_of_fields_with_characteristics – pinapayagan kang magdagdag ng mga bagong field sa talahanayan;
• ALTER TABLE table_name DROP COLUMN list_of_fields - nagbibigay-daan sa iyo na alisin ang mga patlang mula sa talahanayan;
• ALTER TABLE table_name MAGDAGDAG NG PAGPILITAN constraint_name DAYUHANG SUSI(mga patlang) MGA SANGGUNIAN lookup_table(fields) – nagbibigay-daan sa iyong tukuyin ang relasyon sa pagitan ng table at lookup table.

Iba pang mga paghihigpit - NATATANGI, DEFAULT, CHECK

Gamit ang UNIQUE constraint, maaari mong sabihin na ang value para sa bawat row sa isang partikular na field o set ng mga field ay dapat na natatangi. Sa kaso ng talahanayan ng Mga Empleyado, maaari naming ipataw ang gayong paghihigpit sa field ng Email. I-pre-populate lang ang Email ng mga value kung hindi pa natukoy ang mga ito:

I-UPDATE ang Employees SET Email=" [email protected]"WHERE ID=1000 UPDATE Employees SET Email=" [email protected]" WHERE ID=1001 UPDATE Employees SET Email=" [email protected]"WHERE ID=1002 UPDATE Employees SET Email=" [email protected]" WHERE ID=1003
At ngayon ay maaari kang magpataw ng isang natatanging-paghihigpit sa larangang ito:

ALTER TABLE Employees ADD CONSTRAINT UQ_Employees_Email UNIQUE(Email)
Ngayon ang user ay hindi na makakapagpasok ng parehong E-Mail para sa ilang empleyado.

Karaniwang pinangalanan ang uniqueness constraint bilang mga sumusunod - una ay ang prefix na "UQ_", pagkatapos ay ang pangalan ng talahanayan at pagkatapos ng underscore ay ang pangalan ng field kung saan ipinataw ang constraint na ito.

Alinsunod dito, kung ang isang kumbinasyon ng mga patlang ay dapat na natatangi sa konteksto ng mga hilera ng talahanayan, pagkatapos ay ilista namin ang mga ito na pinaghihiwalay ng mga kuwit:

ALTER TABLE table_name ADD CONSTRAINT constraint_name UNIQUE(field1,field2,...)
Sa pamamagitan ng pagdaragdag ng DEFAULT constraint sa isang field, maaari tayong magtakda ng default na value na papalitan kung ang field ay hindi nakalista sa listahan ng field ng INSERT command kapag may bagong record na ipinasok. Maaaring direktang itakda ang paghihigpit na ito kapag gumagawa ng talahanayan.

Magdagdag tayo ng bagong field na "Petsa ng Pagrerekrut" sa talahanayan ng Mga Empleyado at pangalanan itong HireDate at sabihin na ang default na halaga para sa field na ito ay ang kasalukuyang petsa:

ALTER TABLE Employees ADD HireDate date NOT NULL DEFAULT SYSDATETIME()
O kung mayroon nang HireDate column, maaaring gamitin ang sumusunod na syntax:

ALTER TABLE Employees ADD DEFAULT SYSDATETIME() FOR HireDate
Dito hindi ko tinukoy ang pangalan ng pagpilit, dahil sa kaso ng DEFAULT, ako ay nasa opinyon na ito ay hindi masyadong kritikal. Ngunit kung gagawin mo ito sa mabuting paraan, kung gayon, sa palagay ko, hindi mo kailangang maging tamad at dapat kang magtakda ng isang normal na pangalan. Ginagawa ito tulad ng sumusunod:

ALTER TABLE Employees ADD CONSTRAINT DF_Employees_HireDate DEFAULT SYSDATETIME() FOR HireDate
Dahil ang column na ito ay hindi pa umiiral noon, kapag ito ay idinagdag sa bawat tala, ang kasalukuyang halaga ng petsa ay ipapasok sa HireDate field.

Kapag nagdadagdag ng bagong entry, awtomatikong ilalagay din ang kasalukuyang petsa, siyempre, kung hindi namin ito tahasang itatakda, i.e. hindi tinukoy sa listahan ng mga column. Ipakita natin ito sa isang halimbawa nang hindi tinukoy ang field na HireDate sa listahan ng mga idinagdag na halaga:

INSERT Employees(ID,Pangalan,Email)VALUES(1004,N"Sergeev S.S."," [email protected]")
Tingnan natin kung ano ang nangyari:

PUMILI * MULA SA Mga Empleyado

ID	Pangalan	Birthday	Email	PositionID	DepartmentID	ManagerID	HireDate
1000	Ivanov I.I.	1955-02-19	[email protected]	2	1	WALA	2015-04-08
1001	Petrov P.P.	1983-12-03	[email protected]	3	4	1003	2015-04-08
1002	Sidorov S.S.	1976-06-07	[email protected]	1	2	1000	2015-04-08
1003	Andreev A.A.	1982-04-17	[email protected]	4	3	1000	2015-04-08
1004	Sergeev S.S.	WALA	[email protected]	WALA	WALA	WALA	2015-04-08

Ang check constraint CHECK ay ginagamit kapag ito ay kinakailangan upang suriin ang mga halaga na ipinasok sa field. Halimbawa, ipataw natin ang paghihigpit na ito sa field ng numero ng tauhan, na ating employee identifier (ID). Gamit ang hadlang na ito, sabihin natin na ang mga numero ng tauhan ay dapat may halaga mula 1000 hanggang 1999:

ALTER TABLE Employees ADD CONSTRAINT CK_Employees_ID CHECK(ID BETWEEN 1000 AND 1999)
Karaniwang pareho ang pangalan ng pagpilit, una sa prefix na "CK_", pagkatapos ay ang pangalan ng talahanayan at ang pangalan ng field kung saan inilalapat ang pagpilit.

Subukan nating magpasok ng di-wastong entry upang matiyak na gumagana ang paghihigpit (dapat nating makuha ang kaukulang error):

INSERT Employees(ID,Email) VALUES(2000," [email protected]")
Ngayon, baguhin natin ang halagang ilalagay sa 1500 at tiyaking naipasok ang talaan:

INSERT Employees(ID,Email) VALUES(1500," [email protected]")
Maaari ka ring lumikha ng NATATANGI at CHECK na mga hadlang nang hindi tinukoy ang isang pangalan:

ALTER TABLE Employees ADD UNIQUE(Email) ALTER TABLE Empleyes ADD CHECK(ID BETWEEN 1000 AND 1999)
Ngunit ito ay hindi isang magandang kasanayan at ito ay mas mahusay na tukuyin ang pangalan ng pagpilit nang tahasan, dahil upang malaman sa ibang pagkakataon kung ano ang magiging mas mahirap, kakailanganin mong buksan ang bagay at tingnan kung ano ang responsable nito.

Sa isang magandang pangalan, maraming impormasyon tungkol sa isang hadlang ang maaaring matutunan nang direkta mula sa pangalan nito.

At, nang naaayon, ang lahat ng mga paghihigpit na ito ay maaaring malikha kaagad kapag lumilikha ng isang talahanayan, kung hindi pa ito umiiral. Tanggalin natin ang talahanayan:

DROP TABLE Mga empleyado
At muling likhain ito kasama ang lahat ng nilikhang mga hadlang sa isang utos ng CREATE TABLE:

GUMAWA NG TABLE Employees(ID int NOT NULL, Name nvarchar(30), Birthday date, Email nvarchar(30), PositionID int, DepartmentID int, HireDate date NOT NULL DEFAULT SYSDATETIME(), -- for DEFAULT I will throw a CONSTRAINT PK_Employees PRIMARY KEY exception (ID), CONSTRAINT FK_Employees_DepartmentID FOREIGN KEY(DepartmentID) REFERENCES Mga Departamento(ID), CONSTRAINT FK_Employees_PositionID FOREIGN KEY(PositionID) REFERENCES Positions(ID), CONSTRAINT UQ_Employees (INT_Employees) (INT_Employees) (INT_EMPloyees) (INT_EMPloyees) WECK0Email CONSTRAINT

INSERT Employees (ID,Pangalan,Birthday,Email,PositionID,DepartmentID)VALUES (1000,N"Ivanov I.I.","19550219"," [email protected]",2,1), (1001,N"Petrov P.P.","19831203"," [email protected]",3,3), (1002,N"Sidorov S.S.","19760607"," [email protected]",1,2), (1003,N"Andreev A.A.","19820417"," [email protected]",4,3)

Kaunti tungkol sa mga index na ginawa kapag gumagawa ng PRIMARY KEY at NATATANGING mga hadlang

Gaya ng makikita mo sa screenshot sa itaas, kapag gumagawa ng PRIMARY KEY at NATATANGING mga hadlang, awtomatikong nalikha ang mga index na may parehong mga pangalan (PK_Employees at UQ_Employees_Email). Bilang default, ang index para sa pangunahing key ay ginawa bilang CLUSTERED, at para sa lahat ng iba pang mga index bilang NONCLUSTERED. Ito ay nagkakahalaga na sabihin na ang konsepto ng isang clustered index ay hindi magagamit sa lahat ng DBMS. Ang isang talahanayan ay maaari lamang magkaroon ng isang CLUSTERED index. CLUSTERED - nangangahulugan na ang mga talaan ng talahanayan ay pagbukud-bukurin ayon sa index na ito, maaari ding sabihin na ang index na ito ay may direktang access sa lahat ng data ng talahanayan. Ito upang sabihin ang pangunahing index ng talahanayan. Upang ilagay ito kahit na mas magaspang, ito ay isang index screwed sa talahanayan. Ang clustered index ay isang napakalakas na tool na makakatulong sa pag-optimize ng query, tandaan lamang iyon. Kung gusto nating sabihin na ang clustered index ay ginagamit hindi sa pangunahing key, ngunit para sa isa pang index, kung gayon kapag lumilikha ng pangunahing key, dapat nating tukuyin ang NONCLUSTERED na opsyon:

ALTER TABLE table_name ADD CONSTRAINT constraint_name PRIMARY KEY NONCLUSTERED(field1,field2,…)
Halimbawa, gawin nating hindi clustered ang constraint index na PK_Employees, at ang constraint index na UQ_Employees_Email ay clustered. Una sa lahat, alisin natin ang mga paghihigpit na ito:

ALTER TABLE Employees DROP CONSTRAINT PK_Employees ALTER TABLE Employees DROP CONSTRAINT UQ_Employees_Email
At ngayon gawin natin ang mga ito gamit ang CLUSTERED at NONCLUSTERED na mga opsyon:

ALTER TABLE Employees ADD CONSTRAINT PK_Employees PRIMARY KEY NONCLUSTERED (ID) ALTER TABLE Employees ADD CONSTRAINT UQ_Employees_Email UNIQUE CLUSTERED (Email)
Ngayon, kapag pumili kami mula sa talahanayan ng Mga Empleyado, makikita namin na ang mga tala ay pinagsunod-sunod ayon sa clustered index na UQ_Employees_Email:

PUMILI * MULA SA Mga Empleyado

ID	Pangalan	Birthday	Email	PositionID	DepartmentID	HireDate
1003	Andreev A.A.	1982-04-17	[email protected]	4	3	2015-04-08
1000	Ivanov I.I.	1955-02-19	[email protected]	2	1	2015-04-08
1001	Petrov P.P.	1983-12-03	[email protected]	3	3	2015-04-08
1002	Sidorov S.S.	1976-06-07	[email protected]	1	2	2015-04-08

Bago ito, kapag ang clustered index ay ang PK_Employees index, ang mga tala ay bilang default na pinagsunod-sunod ayon sa field ng ID.

Ngunit sa kasong ito, ito ay isang halimbawa lamang na nagpapakita ng kakanyahan ng clustered index, dahil. malamang, ang mga query ay gagawin sa talahanayan ng Mga Empleyado sa pamamagitan ng field ng ID, at sa ilang mga kaso, ito mismo ay maaaring kumilos bilang isang sanggunian.

Para sa mga direktoryo, karaniwang ipinapayong ang clustered index ay itayo sa pangunahing susi, dahil sa mga kahilingan, madalas kaming sumangguni sa directory identifier para makuha, halimbawa, ang pangalan (Posisyon, Departamento). Dito naaalala natin ang isinulat ko tungkol sa itaas, na ang clustered index ay may direktang access sa mga hilera ng talahanayan, at sumusunod na makukuha natin ang halaga ng anumang column nang walang karagdagang overhead.

Ang clustered index ay kapaki-pakinabang na ilapat sa mga field na pinakamadalas na pinipili.

Minsan ang mga talahanayan ay gumagawa ng isang susi sa pamamagitan ng isang kahalili na field, kung saan ito ay kapaki-pakinabang na panatilihin ang CLUSTERED index na opsyon para sa isang mas naaangkop na index at tukuyin ang NONCLUSTERED na opsyon kapag gumagawa ng isang kahalili na pangunahing key.

I-summarize natin

Sa yugtong ito, nakilala namin ang lahat ng uri ng mga paghihigpit, sa kanilang pinakasimpleng anyo, na nilikha ng isang utos tulad ng "ALTER TABLE table_name ADD CONSTRAINT constraint_name ...":

• PANGUNAHING SUSI- pangunahing susi;
• DAYUHANG SUSI- pagse-set up ng mga link at pagsubaybay sa referential integridad ng data;
• NATATANGING- nagpapahintulot sa iyo na lumikha ng pagiging natatangi;
• SURIIN- nagpapahintulot sa iyo na isagawa ang kawastuhan ng ipinasok na data;
• DEFAULT– nagpapahintulot sa iyo na itakda ang default na halaga;
• Dapat ding tandaan na ang lahat ng mga paghihigpit ay maaaring alisin gamit ang command na " ALTER TABLE table_name DROP CONSTRAINT constraint_name".

Bahagyang hinawakan din namin ang paksa ng mga indeks at sinuri ang konsepto ng cluster ( CLUSTERED) at hindi clustered ( HINDI NAKA-NCLUSTER) index.

Paglikha ng mga standalone na index

Ang self-sufficiency dito ay tumutukoy sa mga index na hindi ginawa para sa isang PANGUNAHING SUSI o NATATANGING hadlang.

Ang mga index sa isang field o field ay maaaring malikha gamit ang sumusunod na command:

GUMAWA NG INDEX IDX_Employees_Name SA Mga Empleyado(Pangalan)
Maaari mo ring tukuyin ang CLUSTERED, NONCLUSTERED, UNIQUE na mga opsyon dito, at maaari mo ring tukuyin ang direksyon ng pag-uuri para sa bawat indibidwal na field na ASC (default) o DESC:

GUMAWA NG NATATANGING NONCLUSTERED INDEX UQ_Employees_EmailDesc ON Employees(Email DESC)
Kapag gumagawa ng hindi naka-cluster na index, ang NONCLUSTERED na opsyon ay maaaring tanggalin, bilang ito ay ipinahiwatig bilang default, ito ay ipinapakita dito para lamang ipahiwatig ang posisyon ng CLUSTERED o NONCLUSTERED na opsyon sa command.

Maaari mong alisin ang index gamit ang sumusunod na command:

DROP INDEX IDX_Employees_Name ON Employees
Ang mga simpleng index, tulad ng mga hadlang, ay maaaring gawin sa konteksto ng command na CREATE TABLE.

Halimbawa, tanggalin natin muli ang talahanayan:

DROP TABLE Mga empleyado
At muling likhain ito kasama ang lahat ng nilikhang mga hadlang at index na may isang command na CREATE TABLE:

CREATE TABLE Employees(ID int NOT NULL, Name nvarchar(30), Birthday date, Email nvarchar(30), PositionID int, DepartmentID int, HireDate date NOT NULL CONSTRAINT DF_Employees_HireDate DEFAULT SYSDATETIME(), ManagerID int, CONSTRAloyyINTesPK ), Pagpilit fk_employees_departmentid banyagang susi (department) Mga kagawaran ng sanggunian (id), pagpilit fk_employees_positionid banyagang susi (positionID) Mga posisyon ng sanggunian (ID), pagpigil ng mga sanggunian ng mga empleyado (ID), pagpilit sa pagitan ng 1000 at 1999), INDEX IDX_Employees_Name(Pangalan))
Panghuli, ipasok sa talahanayan ng aming mga empleyado:

INSERT Employees (ID,Pangalan,Birthday,Email,PositionID,DepartmentID,ManagerID)VALUES (1000,N"Ivanov II","19550219"," [email protected]",2,1,NULL), (1001,N"Petrov P.P.","19831203"," [email protected]",3,3,1003), (1002,N"Sidorov S.S.","19760607"," [email protected]",1,2,1000), (1003,N"Andreev A.A.","19820417"," [email protected]",4,3,1000)
Bilang karagdagan, nararapat na tandaan na ang mga halaga ay maaaring isama sa isang hindi naka-cluster na index sa pamamagitan ng pagtukoy sa mga ito sa INCLUDE. Yung. sa kasong ito, ang INCLUDE index ay medyo kahawig ng isang clustered index, ngayon lamang ang index ay hindi naka-attach sa talahanayan, ngunit ang mga kinakailangang halaga ay naka-attach sa index. Alinsunod dito, ang mga naturang index ay maaaring lubos na mapabuti ang pagganap ng mga piling query (SELECT), kung ang lahat ng mga nakalistang field ay nasa index, kung gayon ito ay posible na hindi na kailangang i-access ang talahanayan sa lahat. Ngunit natural nitong pinapataas ang laki ng index, dahil ang mga halaga ng mga nakalistang field ay nadoble sa index.

Pag-clip mula sa MSDN. Pangkalahatang Command Syntax para sa Paglikha ng mga Index

GUMAWA ng [NATATANGI] [CLUSTERED | NONCLUSTERED ] INDEX index_name NAKA-ON