MySQL ja PHP -opas
Mureakuha
Sisällysluettelo |
MySQL
Oppaassa käydään ensin läpi MySQL:n perusteita ja tämän jälkeen käyttöä PHP:llä.
MySQL:ään yhdistäminen
Jos haluamme jotain tietokannalla tehdä, pitää siihen ensin yhdistää tavalla tai toisella. Aluksi käytämme tekstipohjaista asiakasohjelmaa ja myöhemmin kannan kanssa löpiseminen käy PHP:llä.
Jos sinulla on MySQL-kanta asennettu omalle koneellesi, olet siinä onnellisessa asemassa, että yhdistäminen on "piisofkeik". Windowsissa näin (jos mysql on kansiossa C:\MySQL):
Käynnistä -> Suorita "cmd" [enter] C:\>cd mysql\bin [enter] C:\mysql\bin> mysql -u[käyttäjänimi] -p [enter] Enter password: [salasana] [enter]
Tässä tietenkin [salasana]:n paikalle tulee salasanasi, [käyttäjänimi] korvataan käyttäjänimelläsi ja [enter]:in kohdalla painellaan sitä kuuluisaa enteriä. Jos kaikki menee oikein ja on oikein asennettu, pitäisi eteesi syöksyä tämäntapainen ruutu:
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 6 to server version: 3.23.36 Type 'help;' or '\h' for help. Type '\c' to clear the buffer mysql>
Unixeilla homma toimii lähes samalla tavalla. Yleensä asiakasohjelma löytyy mysql-client ja serveri mysql-server -nimisessä paketissa. Sorsista en ole mysql:ää kääntänyt, joten siinä en osaa opastaa.
Jos taas satut olemaan siinä ikävässä tilanteessa, että tietokanta ei olekaan omalla koneellasi, sinun täytyy haalia jostain käsiisi mysql(.exe) ohjelma (tai vaikka koko palvelinsofta, jossa se tulee mukana) ja tehdä seuraava:
C:\mysql\bin> mysql -h[minun.hostini] -u[käyttäjänimi] -p [enter] Enter password: [salasana] [enter]
Tuloksen pitäisi olla sama kuin edellisessä yhdistämisesimerkissä.
MySQL:n käyttäminen
Tietokantoja ohjataan ja hallitaan yleensä SQL (Structured Query Language) -kielellä, joka saattaa aluksi vaikuttaa hämäävän helpolta, mutta juuri kun kylvet osaamisen tunteessa huomaat, ettet osaakaan sitä juuri ollenkaan. Rohkaisevaa?
Edessäsi on siis seuraavanlainen kehote:
mysql>
Tämä hyväksyy mysql-käskyjä, joita alammekin heti käyttää. Kirjoita kehotteeseen:
SHOW DATABASES;
Tämä näyttää tietokannat palvelimella. Jos tietokanta ei ole omalla koneellasi, sinulla ei luultavasti ole oikeuksia luoda uusia kantoja, joten sinulla pitäisi jo olla tietokanta valmiina. Jos tietokanta on koneellasi, sinulla on luultavasti root -oikeudet, eli saat tehdä kannalla mitä ikinä haluat. Tällöin sinulla ei välttämättä olekaan tietokantoja valmiina. Kerron hetken päästä, miten voit tehdä itsellesi uuden tietokannan.
MySQL-käsky oli siis "SHOW DATABASES", ja puolipiste (;) päättää käskyn. Jos unohdit puolipisteen, näyttää ruutu todennäköisesti tältä:
mysql> SHOW DATABASES
->
Tämä siis tarkoittaa, että voit jatkaa käskyäsi seuraavalle riville, ja päättää sen halutessasi puolipisteellä ja enterin painalluksella. Jos tulet katumapäälle, etkä haluakaan suorittaa kirjoittamaasi käskyä, voit kirjoittaa \c ja painaa enteriä, jolloin mysql ei suorita käskyä, vaan palaa takaisin tavalliseen tilaan.
Jos sinulla ei ollut valmista kantaa ja loggasit sisään tunnuksilla, joilla voi luoda uusia kantoja, voit luoda itsellesi sellaisen kirjoittamalla:
CREATE DATABASE mureakuha;
Tämän tulisi palauttaa jotain tämän suuntaista:
Query OK, 1 row affected (0.00 sec)
Jos saat virheen MySQL:ssä, ei hätää. Mitään osaa käskystä ei suoriteta ja voit kokeilla uudestaan tarkistettuasi käskyn.
Nyt siis kaikilla pitäisi olla tietokanta, jonka nimi tässä tutoriaalissa on "mureakuha". Sinulla voi myös olla muun niminen tietokanta, jolloin sinun tulee muuttaa sen nimi oikeaksi, jotta esimerkit toimisivat.
Seuraavaksi luonnollisesti haluamme käyttää tuota tietokantaa, joten kirjoita:
USE mureakuha;
USE -käskyn kanssa ei tarvitse puolipistettä, mutta siitä ei ole haittaakaan, ja se kannattaa laittaa perään, jotta sen käyttö tulisi rutiiniksi muissakin käskyissä.
MySQL (kuten yleensä kaikki tietokannat) rakentuu tietokannoista ja tauluista (joista saatan myös käyttää nimitystä table). Taulut sijaitsevat tietokannoissa ja taulut taas koostuvat sarakkeista (joista saatetaan käyttää sanaa column) ja riveistä. Sarakkeet ja rivit selitetään hieman myöhemmin.
ASCII-diagrammi tietokannoista ja tauluista:
Mysql
/ \
/ \
/ \
Tietokanta Tietokanta
/ \ / \
Taulu Taulu Taulu Taulu
Jos olet noudattanut ohjeita, pitäisi sinulla olla nyt tyhjä tietokanta, minkä voi testata seuraavalla komennolla:
SHOW TABLES;
Tuloksen tulisi olla seuraavansuuntainen:
Empty set (0.00 sec)
Tietojen lisääminen
Seuraavaksi tyhjään tietokantaan lisätään taulu:
CREATE TABLE kalat (id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, kala VARCHAR(10));
Tämä kaipaakin jo hieman enemmän selitystä. 'CREATE TABLE' luo uuden taulun ja 'kalat' on taulun nimi. Suluissa oleva rimpsu kertoo, minkälaisia sarakkeita taulussa tulisi olla. Ensin tulee sarakkeen nimi, jonka jälkeen sarakkeen tyyppi. id:n tyyppi on INT, joka tulee englanninkielen sanasta integer, joka tarkoittaa kokonaislukua. Tyypin määritelmään kuuluu myös määre 'UNSIGNED', joka kertoo, että sarakkeeseen menee vain positiivisia lukuja (tai nolla).
Tyypin jälkeen voi tulla erillaisia lisämäärityksiä. Tässä esimerkissä käytetyt määritteet ovat 'NOT NULL', 'AUTO_INCREMENT' ja 'PRIMARY KEY'. Tässä esimerkissä ei 'NOT NULL':ia oikeasti tarvita, mutta se on mukana esimerkin vuoksi. Huomaa, että määritteiden järjestykselläkin on merkitystä! Nämä lisämääritteet tekevät seuraavaa:
NOT NULL - solun arvo ei voi olla NULL, joka on oletus, jos DEFAULT-määritystä ei ole käytössä. AUTO_INCREMENT - asettaa ensimmäisen rivin kyseisen solun arvoksi yksi ja seuraaviin aina yhden enemmän kuin edelliseen (2, 3, 4 jne.). PRIMARY KEY - määrittää solun avaimeksi, joka ei voi olla NULL. Jotkin ohjelmat saattavat pyytää primary key:tä.
Toinen sarake on nimeltään kala ja jonka sen tyyppi on VARCHAR. VARCHARiin voi tallettaa kirjaimia sisältävää tietoa (jos tarvitset pitkän tekstin, käytä TEXT-tyyppiä).
Suluissa oleva numero taas kertoo, kuinka monta kirjainta sarake voi sisältää. Jos int-tyyppisen sarakkeen perässä on sulut ja niissä luku, se määrää montako numeroa sarakkeeseen tuleva luku voi sisältää. DECIMAL-tyypissä on kaksi lukua (esim. DECIMAL(5,2)) jotka tarkoittavat montako desimaalipilkun vasemman- ja oikeanpuolista numeroa sarakkeeseen voi laittaa.
Kirjoita nyt kehotteeseen 'SHOW TABLES;' (ilman heittomerkkejä (')) ja paina enteriä. Tulostuksen pitäisi olla jotakuinkin seuraavanlainen:
+---------------------+ | Tables_in_mureakuha | +---------------------+ | kalat | +---------------------+ 1 row in set (0.04 sec)
DESCRIBE-komennolla voidaan tarkastella luotujen taulujen rakennetta.
'DESCRIBE kalat;'
+-------+------------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------+------------------+------+-----+---------+----------------+ | id | int(10) unsigned | | PRI | NULL | auto_increment | | kala | varchar(10) | YES | | NULL | | +-------+------------------+------+-----+---------+----------------+ 2 rows in set (0.11 sec)
Nyt on tietokannat, taulut, pelit ja vehkeet, mutta mitäs me niillä teemme? Laitamme sinne jotakin turhanpäiväistä tietoa, tässä tapauksessa vaikka pari kalaa. Tauluihin tallennus tapahtuu INSERT-komennolla, jota käytämme seuraavaksi, joten kirjoita kehotteeseen:
INSERT INTO kalat SET kala = 'kuha';
Eli INSERT käskee laittamaan tietoa kantaan, ja 'INTO kalat' määrää mihin tauluun (tässä kalat) tieto laitetaan. SETin jälkeen kerrotaan mikä tieto halutaan mihinkin sarakkeeseen. Jos laitat tietoa moneen eri sarakkeeseen, eri sarakkeet ja niiden tiedot erotetaan pilkulla (,), esim. 'INSERT INTO taulu SET tieto1 = 'yksi', tieto2 = 'kaksi' jne. INSERTissä voi käyttää muitakin tapoja solun tietojen määrittämiseen, mutta SET-komennon käyttäminen on mielestäni selkeintä ja helpointa, joten käytämme sitä tässä tutoriaalissa. Teksti laitetaan MySQL:ssä aina heitto- (') tai lainausmerkkeihin ("). Laitetaan vielä toinenkin kala tauluun:
INSERT INTO kalat SET kala = 'ahven';
No nyt on kaloja taulussa, mutta mitäs hyötyä niistä siellä on? Siitä pääsemmekin sopivasti seuraavaan aiheeseen.
Tietojen hakeminen
Tietokantoihin tallennettua tietoa voi joskus alkaa kaivata, joten sitä pitäisi saada jotenkin näytettyä. Tähän tarkoitukseen on SELECT-komento, joka onkin koko kielen vaikein ja monipuolisin komento. Pelottavan näköinen koodinpätkä, joka sinun tulisi suorittaa näyttää seuraavalta:
SELECT * FROM kalat;
Ja tulostus:
+----+-------+ | id | kala | +----+-------+ | 1 | kuha | | 2 | ahven | +----+-------+ 2 rows in set (0.00 sec)
No olipas vaikeata. Eli SELECT kertoo tietokannalle, että jotakin pitäisi hakea kannasta. * tässä kertoo, mitä sarakkeita taulusta pitäisi saada. Kokeile vaikka 'SELECT id FROM kalat' tai 'SELECT kala FROM kalat' (luonnollisesti ilman heittomerkkejä). FROM ja taulun nimi (tässä kalat) kertovat, mistä taulusta tietoa kaivataan.
Vaikuttaa aika tylsältä, vai? No, meitä huvittamaan saapuu WHERE. WHERE on yksi MySQL:n hyödyllisimmistä sanoista. Lisätään pari riviä lisää, jotta WHERE olisi havainnollisempi. Eli:
INSERT INTO kalat SET kala = 'silli'; INSERT INTO kalat SET kala = 'kampela';
Edellisestä voi huomata, että samalle riville voi kirjoittaa useampia käskyjä erottamalla ne puolipisteillä.
Mutta koitetaan nyt sitä WHEREä. Jos haluamme vaikka kuhan kannasta, voimme käskyttää MySQL:ää seuraavanlaisesti:
SELECT * FROM kalat WHERE kala = 'kuha';
Tulostus:
+----+------+ | id | kala | +----+------+ | 1 | kuha | +----+------+ 1 row in set (0.09 sec)
Esimerkki on aika itsestäänselvä, mutta kerrataan silti sen toiminta. WHERE on suomeksi missä (kuten kaikki varmaan tiesivätkin), ja jo itse sana selittää sen aika hyvin. Itseasiassa, jos suomentaisin SQL-käskyjä, käyttäisin mielummin jossa-sanaa WHEREstä, koska se mielestäni kuvaa sen toimintaa hiukan paremmin. Ajattele äskeistä käskyä suomen kielellä, ja se voisi mennä jotenkin näin: "Valitse kaikki (sarakkeet) (taulusta) kalat joissa kalan arvo on kuha". Vähän kökkö suomennos, mutta se kuvaa mielestäni lauseen toimintaa hyvin. Valitse valitsee SQL:ssä aina rivejä, joten sitä en laittanut mukaan suomennokseen.
Koitan korvata huonot selittäjän kykyni esimerkeillä, joten kirjoittelepa seuraava lause MySQL-kehotteeseen:
SELECT * FROM kalat WHERE kala LIKE '%a%' ORDER BY kala DESC;
Tulostus:
+----+---------+ | id | kala | +----+---------+ | 1 | kuha | | 4 | kampela | | 2 | ahven | +----+---------+ 3 rows in set (0.00 sec)
Huomasit varmaan, että lause valitsi kaikki rivit, joiden kala-solussa on kirjain 'a'. Prosenttimerkki (%) siis toimii jokerina, eli prosenttimerkin paikalla voi olla yksi tai useampi kirjain tai ei mitään. 'SELECT * FROM kalat WHERE kala LIKE '%a' ORDER BY kala DESC' taas valitsee kaikki rivit, joissa kala solun teksti loppuu kirjaimeen a (kuha ja kampela). On yhtä suuri kuin (=) merkillä ja LIKE sanalla (tässä yhteydessä) ei tietääkseni ole muuta eroa kuin, että = -merkin kanssa ei voi käyttää jokerimerkkejä, vaan se hakee konkreettisesti prosenttimerkkiä.
Kerrotaan vielä tässä yhteydessä, että jos haluat esim. etsiä prosentti- tai heittomerkillä varustettuja sarakkeita, voit kirjoittaa \ -merkin sen eteen. Eli esim. '\%', '\'' tai '\"' (ilman heittomerkkejä, kuten varmaan jo hoksasit itsekin). Sama pätee myös itse \ -merkkiin, eli '\' on itse asiassa ainoastaan yksi \ -merkki.
Mukana oli myös yksi uusi määre, ORDER BY. Kuten jotkut englanninkielentaitoiset saattoivatkin jo arvata, se määrää järjestyksen, jossa rivit palautetaan. Tässä tapauksessa rivit järjestetään kala-sarakkeen mukaan ja vielä käänteisessä aakkosjärjestyksessä. Kun tulos järjestetään solun mukaan, joka on teksti-tyyppinen, rivit palautetaan aakosten mukaan. Kun määre DESC (lyhenne sanasta descending, laskeva) on mukana, rivit palautetaan käänteisessä järjestyksessä. DESC on ASC-määreen (lyhenne sanasta ascending, nouseva) vastakohta, mutta ASC on oletus (eli on voimassa, jos määrettä ei erikseen kirjoiteta), joten sitä ei yleensä tarvitse kirjoittaa. Numerotyyppisten solujen mukaan järjestettäessä ASC palauttaa pienimmän ja DESC suurimman ensin.
Kerrotaan vielä tulevaisuuden varalle pieni jippo, eli '... ORDER BY RAND()' määritys palauttaa rivit satunnaisessa järjestyksessä.
Jos (ja kun) joskus tarvitset monta ehtoa WHEREen, voit yhdistellä niitä loogisilla operaattoreilla (AND, OR, XOR jne.), mutta näistä tulee myöhemmin.
Koska innostuin nyt tästä kirjoittamaan, ja SELECTiä käytetään aika usein, kerron vielä pari muuta SELECTiin liittyvää määrettä:
LIMIT Rajoittaa palautettavien rivien määrää. Eli esim. 'SELECT * FROM kalat WHERE kala LIKE '%a%' LIMIT 2' palauttaa vain kaksi ensimmäistä (tässä tapauksessa id:n mukaan lajiteltuna) riviä, jotka täyttävät WHEREn ehdon, vaikka WHEREn ehdon täyttäviä rivejä olikin kolme. 'SELECT * FROM kalat WHERE kala LIKE '%a%' LIMIT 1,2' palauttaakin ahvenen ja kampelan. Ensimmäinen numero tuossa siis määrää, mistä kohdasta nuo kaksi riviä otetaan. Koska tietokone laskee aina nollasta eteenpäin, yksi (1) tässä tarkoittaakin toista riviä, kaksi (2) kolmatta jne. Jos et erikseen määritä tuota ensimmäistä numeroa (kuten LIMITin ensimmäisessä esimerkissä), oletuksena on 0, eli LIMIT 0,2 on sama kuin LIMIT 2 ja vice versa. Vinkki: saat yhden satunnaisen rivin lausella 'SELECT * FROM kalat WHERE kala LIKE '%a%' ORDER BY RAND() LIMIT 1'. Tämä voi kuitenkin olla hidas suurilla kannoilla, koska MySQL valitsee aluksi kaikki rivit (joissa WHEREn ehto/ehdot täyttyvät), ja sitten vasta niistä karsitaan kaikki paitsi ensimmäinen pois. Näin ainakin omasta kokemuksesta.
DISTINCT Tämän havainnollisestamiseksi lisäämme tauluun toisen kuhan, koska se on niin maittavaa. Eli 'INSERT INTO kalat SET kala = 'kuha (taas ilman (uloimpia) heittomerkkejä). Nyt taulu on tämän näköinen:
+----+---------+ | id | kala | +----+---------+ | 1 | kuha | | 2 | ahven | | 3 | silli | | 4 | kampela | | 5 | kuha | +----+---------+ 4 rows in set (0.00 sec)
Nyt meillä on kaksi maukasta kuhaa. Entäs, jos haluammekin vain yhden kappaleen jokaista kalaa? Silloin käytämme DISTINCTiä, joten kirjoita MySQLään:
SELECT DISTINCT kala FROM kalat;
Tulostus:
+---------+ | kala | +---------+ | kuha | | ahven | | silli | | kampela | +---------+ 4 rows in set (0.00 sec)
Nyt kuha on tulostettu vain kerran. Distinct siis jättää samanlaiset rivit pois.
Tietojen muuttaminen
Kun vaikka teemme jotain idioottimaista, kuten lisäämme kaksi samannimistä kalaa kalatauluun, pitää tilanne korjata jotenkin. Rivin voisi tietenkin poistaa, mutta se on seuraavan luvun asia, joten tyydymme muuttamaan vanhaa tietoa.
Jos haluamme muuttaa rivin dataa, käytämme UPDATE komentoa. Se onkin niin simppeli, että siirrymme heti esimerkkiin:
UPDATE kalat SET kala = 'hauki' WHERE kala = 'kuha' AND id = 5 LIMIT 1;
Tässä tulikin lähestulkoon kaikki UPDATEn määreet. UPDATE kertoo, että kannan tietoja tulisi päivittää, eli muuttaa. Seuraavaksi tulee taulun nimi (tässä kalat) ja sen jälkeen SET, joka toimii samalla tavalla kuin INSERTissä. WHERE taasen toimii samalla tavalla kuin SELECTissä, eli sillä määritetään minkä rivin/rivien tietoja on muutettava. LIMIT rajoittaa muutettavien rivien lukumäärää. Siinä ei voi määrittää alkamiskohtaa kuten SELECTissä.
HUOM! Käytä aina WHEREä tai ainakin LIMITiä muuttaessasi taulun tietoja, koska muuten kaikki taulun rivit muuttuvat. Tietenkin voit jättää ne pois, jos olet muuttamassa taulun kaikkia rivejä.
Operaattorit
Saatoit huomata, että väliin oli ympätty myös AND. AND on yksi loogisista operaattoreista, joista lupasinkin jo kertoa. Selitän loogiset operaattorit aika lyhyesti, koska muuten tämä alkaisi vaikuttamaan enemmänkin logiikan tai boolen algebran oppaalta.
Ajattele WHEREn ehtoja ykkösinä (1) ja nollina (0), jossa vastaus on yksi, jos ehto on voimassa ja nolla, jos ei. Eli esim. WHERE kala='kuha'. Wheren kala-arvo on 0 aina paitsi, kun kala on kuha, jolloin se on yksi. Lauseessa 'WHERE id > 3' on voimassa, eli yksi, kun id on suurempi kuin kolme, meidän esimerkissämme siis rivit 4 ja 5. Jos > merkki ei ole tuttu, pysyttele mukana, selitän sen, ja muut vertailuoperaattorit hieman myöhemmin.
Nyt kun ajattelet kaikkia ykkösinä ja nollina, voimmekin helposti selittää loogiset operaattorit. Niitä on mysql:ssä AND, OR, ja NOT ja voit käyttää niiden tilalta myös symbooleja (samassa järjestyksessä) &&, ||, !. Ja nyt operaattoreiden toiminta:
AND - Eli 'ja'. Palauttaa arvon yksi (tosi), kun sen molemmat operandit (vasemmalla ja oikealla olevat ehdot) ovat tosia (1). otetaan ensin pari numeerista esimerkkiä, ja sitten MySQL ehdoilla:
+-----------------+ | Lause | Tulos | +-----------------+ | 0 AND 0 | 0 | | 1 AND 0 | 0 | | 0 AND 1 | 0 | | 1 AND 1 | 1 | +-----------------+
Tätä kutsutaan myös totuustaulukoksi ja siinä on kaikki mahdolliset arvot, mitä AND voi ottaa (ja palauttaa). Otetaan pari esimerkkiä MySQL käskyillä:
SELECT * FROM kalat WHERE id = 1 AND kala = 'kuha';
Tämä siis palauttaa kaikki rivit joiden id on 1 ja kala kuha ja meidän taulussamme yksi rivi täyttää nuo ehdot. Toinen:
SELECT * FROM kalat WHERE id = 2 && kala = 'kuha';
Tämä ei palautakkaan yhtään riviä, koska yksikään rivi ei täytä molempia ehtoja. Toisin sanoen kannassa ei ole yhtään riviä, jossa kala on kuha ja id on 2. Huomaa, että && on sama kuin AND.
OR - Eli tai. ORin totuustaulukko:
+-----------------+ | Lause | Tulos | +-----------------+ | 0 OR 0 | 0 | | 1 OR 0 | 1 | | 0 OR 1 | 1 | | 1 OR 1 | 1 | +-----------------+
OR siis palauttaa 1 (tosi), kun jompi kumpi tai molemmat ehdoista on voimassa. Tämä on ns. inklusiivinen OR, eksklusiivinen(?) tai on taas XOR, jonka olet saattanut nähdä esim. muissa ohjelmointikielissä. XOR on muuten sama kuin OR, mutta se on tosi vain jos jompi kumpi (ei molemmat) ehdoista on voimassa (tosi). XORia ei ole MySQLssä, koska se ei kuulu "perus-loogisiin operaattoreihin", eli se voidaan toteuttaa käyttämällä ANDia, ORia ja NOTia. XORin toteutus (a ja b voivat saada arvot 1 tai 0, siis 1 XOR 0 ;):
(a OR b) AND NOT(a AND b)
Kuten varmaan huomasit, loogisia operaattoreita voidaan yhdistellä. Tällöin NOT tulee ensin, sitten AND ja OR vasemmalta oikealle (tasa-arvoisia) ja suluissa olevat suoritetaan tietenkin ensin (sisältä ulospäin, jos monet sulut). XORin totuustaulukko:
+-----------------+ | Lause | Tulos | +-----------------+ | 0 XOR 0 | 0 | | 1 XOR 0 | 1 | | 0 XOR 1 | 1 | | 1 XOR 1 | 0 | +-----------------+
NOT - Eli ei. NOT on yksinkertaisin loogisista operaattoreista ja se ei teekkään enempää eikä vähempää kuin muuttaa arvon käänteiseksi. Eli NOT 0 = 1 ja NOT 1 on 0. Tästä johtuen se ottaa vain yhden operandin. NOTin totuustaulukko:
+-----------------+ | Lause | Tulos | +-----------------+ | NOT 1 | 0 | | NOT 0 | 1 | +-----------------+
Lupasin myös kertoa vertailuoperaattoreista, joten tässä tulee. Jätän pari vähemmän käytettyä vertailuoperaattoria pois, koska pitäähän sinullekin jäädä jotain löytämisen riemua ;)
Vertailuoperaattorit selityksineen:
= - Yhtä suuri kuin. Voidaan myös ajatella sama kuin, eli on tosi, jos molemmat operandit ovat samoja. < - Pienempi kuin. Tosi, jos vasen operandi on pienempi (mutta ei yhtä suuri) kuin oikean puoleinen. Tekstimuotoisissa aakkosjärjestys määrää "suuruuden". > - Suurempi kuin. Sama kuin = Tästä kohtaa puuttuu ilmeisesti tekstiä!!! 4.2.0) voit myös käyttää new_link-parametria, joka määrittelee, avataanko uusi yhteys, jos samoilla parametreilla on jo yhdistetty kantaan. Tiesithän, että vapaaehtoisissa parametreissa pitää antaa kaikki parametria edeltävät parametrit. Jos esimerkiksi haluat antaa salasana-parametrin (kuten luultavasti haluat), sinun pitää antaa myös osoite ja käyttäjänimi parametrit. Mistä tietokone muuten tietäisi, mikä parametri on kyseessä? Oletusparametri osoitteelle on "localhost:3306" (3306 on mysql:n oletusportti), käyttäjänimelle PHP-prosessin omistajan nimi ja salasanalle tyhjä. Funktio mysql_connect palauttaa "resurssi id:n", jonka avulla PHP tietää, mikä yhteys on kyseessä. Tämä id kannattaa yleensä tallentaa muuttujaan, mutta se ei ole aivan välttämätön, sillä sitä käyttävät funktiot käyttävät yleensä oletusparametrina viimeisintä avattua yhteyttä. Luo tiedosto mysql.php ja kirjoita seuraava koodi sinne:
MySQL:n käyttö PHP:llä
Tietokantaan yhdistäminen
Käytä yhdistettäessä samoja tietoja kuin luvussa 1.1, porttia ei luultavasti tarvitse määrittää. Jos mysql-palvelin on omalla koneellasi, käytä osoitteena localhost:ia tai numeerista 127.0.0.1-osoitetta. mysql_select_db funktio valitsee käytettävän tietokannan. Se siis ajaa saman asian kuin aikaisemmin oppimasi USE mureakuha. mysql_select_db ottaa parametrina tietokannan nimen ja vapaaehtoisen resurssi id:n. Oletus-id on sama kuin muissakin mysql-funktioissa, eli viimeisin avattu yhteys. mysql_close funktio sulkee yhteyden tietokantaan. Parametrina se ottaa suljettavan yhteyden resurssi-id:n ja oletuksena on viimeksi avattu yhteys. Yhteydet suljetaan myös itsestään skriptin päätyttyä (paitsi, jos kyseessä on "pysyvä yhteys", jota en kuitenkaan käy läpi tässä oppaassa), mutta on hyvä tapa silti sulkea yhteydet itse. Koodiin en laittanut vielä virheentarkistusta, koska halusin pitää sen mahdollisimman yksinkertaisena. Virheentarkistus kuitenkin kannattaa aina, vaikkapa seuraavalla tavalla:
$yhteys = mysql_connect("localhost", "root") or die ("Ei yhteyttä");
Voit ajaa koodin testataksesi, että yhteyden avaaminen varmasti toimii. Jos saat virheilmoituksia, varmista, että olet antanut tiedot oikein.
Komentojen antaminen
Yhteyden avaamisen jälkeen tietokannalle annetaan yleensä käskyjä. MySQL-asiakasohjelmaa käyttäessäsi kirjoitit komennon ja painoit enteriä. PHP:llä tämä tapahtuu mysql_query() -funktiolla. mysql_query ottaa parametrina käytettävän SQL-lauseen ja vapaaehtoisen resurssiiid:n. Resurssi-id:n oletus on, yllätys yllätys, viimeisin avattu yhteys. Huom! mysql_query():lle annettussa SQL-lauseessa ei laiteta puolipistettä loppuun. Jos käsky olisi "INSERT INTO kalat SET kala = 'made'" ja resurssi id $mysql_yhteys-muuttujassa, käsky annettaisiin MySQL:lle seuraavalla tavalla:
mysql_query("INSERT INTO kalat SET kala = 'made'", $mysql_yhteys)
or die("SQL-komennossa virhe: " . mysql_error($mysql_yhteys));
mysql_query():n palautusarvo ei ole aivan yhtä yksinkertainen kuin muiden esiteltyjen funktioiden. Jos kyseessä on haku, jolla ei haeta dataa tietokannasta (esim. INSERT, DELETE, DROP yms.), funktio palauttaa onnistuessaan TRUE (1) ja epäonnistuessaan FALSE (0). Kun taas haetaan tietoa (esim. SELECT), funktio palauttaa onnistuessaan resurssi-id:n, jonka avulla voidaan lukea haettu tieto, ja epäonnistuessaan FALSE (0). Tiesithän, että PHP:ssä kaikki nollasta (FALSE) eroavat arvot ovat totuusarvoltaan tosia.
Huom! Jos laitat mysql-hakuun tietoa, jonka saat käyttäjältä, varmista, että käyttäjä ei pysty jatkamaan hakua. Tämän voi tehdä, jos käyttäjä laittaa lainausmerkin haettavaan sanaan ja sen jälkeen jatkaa komentoa. PHP:n voi myös konfiguroida poistamaan tämän mahdollisuuden käyttämällä "Magic quotes" -ominaisuutta, mutta asia kannattaa varmistaa itse esim. addslashes()-funktiota, joka lisää lainaus- ja heittomerkkien eteen \-merkin, joka poistaa niiden "erikoisominaisuudet", kuten varmasti tiesitkin. ;) Jos "magic quotes" on käytössä ja käytät addslashes()-funktiota, on mahdollista, että ilmestyy ylimääräisiä \-merkkejä (kuten esim. Mureakuhassa vielä vähän aikaa sitten :P). Tämän voit tarkistaa get_magic_quotes_gpc()-funktiolla. Tämä hieman karkasi käsistä, joten älä ole kovin huolissasi jos et täysin ymmärtänyt, mutta palaa asiaan, kun aiot tehdä mysql:ää käyttävän PHP-sovelluksen, joka ottaa tietoa käyttäjältä.
Tietojen hakeminen
Kun olet hakenut tietoa mysql:stä mysql_query()-komennolla, se kaivetaan esiin käyttäen mysql_fetch_*-funktiota, joista käytämme mysql_fetch_array():ta. mysql_fetch_*-funktioilla saadaan myös kerättyä tietoa hausta, mutta se jää sinulle itse opeteltavaksi. mysql_fetch_array():n toimintatapa saattaa aluksi vaikuttaa hieman omituiselta, mutta pienen selityksen jälkeen huomaat kuinka yksinkertainen, helppokäyttöinen ja näppärä se on. mysql_fetch_array() ottaa parametriksi mysql_query():stä saadun resurssi-id:n ja vapaaehtoisen parametrin, joka määrää minkälaisen tuloksen mysql_fetch_array palauttaa. Parametri voi olla MYSQL_NUM, MYSQL_ASSOC tai MYSQL_BOTH. Tämä taas tarkoittaa, että funktio palauttaa joko numeeriset indeksit sisältävän taulukon, tai ns. "associative arrayn", jonka indeksit ovat haettujen sarakkeiden nimet tai molemmat. Oletus on MYSQL_BOTH PHP sisältää myös mysql_fetch_row ja mysql_fetch_assoc, jotka toimivat samalla tavalla kuin mysql_fetch_array parametreilla MYSQL_NUM ja MYSQL_ASSOC. Kun kutsut mysql_fetch_array()-funktiota ensimmäisen kerran, se palauttaa taulukon, joka sisältää haun ensimmäisen rivin solut, toisella toisen rivin solut jne., kunnes kaikki rivit on luettu, jolloin se palauttaa arvon FALSE (0). Tämän toimintatavan ansiosta voimme käyttää mysql_fetch_array():ta kätevästi loopissa, jossa teemme haetulle datalle mitä haluamme. Yleensä looppi on tämän näköinen while($mysql_tiedot = mysql_fetch_array($mysql_haun_tulos)), mutta paremmin näet sen toiminnan, kun se kirjoitetaan hieman pidemmin:
while(($mysql_tiedot = mysql_fetch_array($mysql_haun_tulos)) != FALSE)
$mysql_tiedot sisältävät joka kierroksella kyseisen rivin solut ja niiden arvot. Kun sinun ei tarvitse enää hakea tietoja mysql_fetch_*-funktioilla, vapauta tuloksiin käytetty muisti funktiolla mysql_free_result(), joka ottaa parametrikseen MySQL linkin (sen resurssin, joka saatiin mysql_query()-funktiolla)
