PostgreSQL ismertető

1.  Bevezető

PostgreSQL bevezető

Ha több fejlesztő beszélget a különböző adatbázis megoldások használatáról általában kettő kerül szóba. Az egyik a MySQL, és a másik - amit ez a dokumentum mutat be a PostgreSQL. Ez egy örökös vita és már régóta tart de akárhogyan is van a PostgreSQL sokkal közelebb áll az eredeti relációs adatbázis elképzelésekhez. Az IDEGEN KULCSOK (FOREIGN KEYS) csak a MYSQL 5-ös verziójába kerültek bele. Akárhogyan is áll a dolog ez a dokumentum feltételezi, hogy te a PostgreSQL adatbázist akarod használni. Amivel kezdünk az a telepítés az emerge-vel. Az ezt követő részben az alap beállítás kerül bemutatásra az emerge segítségével.

PostgreSQL telepítése

Legelső lépésként az emerge paranccsal fel kell telepíteni a PostgreSQL csomagot. Futtasd le a következő kódrészletet, hogy megbizonyosodj a beállításokról:

# emerge -pv postgresql

These are the packages that I would merge, in order:

Calculating dependencies ...done!
[ebuild  N    ] dev-db/postgresql-8.0.4  -doc -kerberos +nls +pam +perl -pg-intdatetime +python +readline (-selinux) +ssl -tcl +xml +zlib 0 kB

Itt található, hogy melyik beállítás mit jelent:

Elsőként be kell állítani a PostgreSQL-t az igényeid szerint. Kezd az emerge paranccsal:

# emerge postgresql
(A kimenet rövidítve lett)
>>> /usr/lib/libecpg.so.5 -> libecpg.so.5.0
>>> /usr/bin/postmaster -> postgres
 * Make sure the postgres user in /etc/passwd has an account setup with /bin/bash as the shell
 *
 * Execute the following command
 * emerge --config =postgresql-8.0.4
 * to setup the initial database environment.
 *
>>> Regenerating /etc/ld.so.cache...
>>> dev-db/postgresql-8.0.4 merged.

A következő részben kerül bemutatásra a PostgreSQL beállítása.

2.  PostgreSQL beállítása

A kezdeti(alap) adatbázis környezet beállítása

Korábban már láthattad az emerge kimenetét ahol azt írta, hogy az alap környezetet létre kell hozni és be kell állítani. Az ebuild fájl létrehoz egy postgres felhasználót a rendszeren akinek nincsen jelszava. Szóval mielőtt elkezdjük, a jelszót a postgres felhasználónak meg kell adni:

# passwd postgres
New UNIX password:
Retype new UNIX password:
passwd: password updated successfully

Most jön az alap környezet beállítása:

# emerge --config =postgresql-8.0.4


Configuring pkg...

 * Creating the data directory ...
 * Initializing the database ...
The files belonging to this database system will be owned by user "postgres".
This user must also own the server process.

The database cluster will be initialized with locale C.

fixing permissions on existing directory /var/lib/postgresql/data ... ok
creating directory /var/lib/postgresql/data/global ... ok
creating directory /var/lib/postgresql/data/pg_xlog ... ok
creating directory /var/lib/postgresql/data/pg_xlog/archive_status ... ok
creating directory /var/lib/postgresql/data/pg_clog ... ok
creating directory /var/lib/postgresql/data/pg_subtrans ... ok
creating directory /var/lib/postgresql/data/base ... ok
creating directory /var/lib/postgresql/data/base/1 ... ok
creating directory /var/lib/postgresql/data/pg_tblspc ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 1000
creating configuration files ... ok
creating template1 database in /var/lib/postgresql/data/base/1 ... ok
initializing pg_shadow ... ok
enabling unlimited row size for system tables ... ok
initializing pg_depend ... ok
creating system views ... ok
loading pg_description ... ok
creating conversions ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok

WARNING: enabling "trust" authentication for local connections
You can change this by editing pg_hba.conf or using the -A option the
next time you run initdb.

Success. You can now start the database server using:

    /usr/bin/postmaster -D /var/lib/postgresql/data
or
    /usr/bin/pg_ctl -D /var/lib/postgresql/data -l logfile start

 *
 * You can use /etc/init.d/postgresql script to run PostgreSQL instead of pg_ctl.
 *

Az alap adatbázis környezet létrehozása megtörtént. A következő részben megnézzük a telepítés ellenőrzését és hogy miképpen állíthatunk be új felhasználói hozzáféréseket.

PostgreSQL adatbázis beállítása

Most, hogy a PostgreSQL adatbázis beállítása megtörtént érdemes ellenőrizni. Elsőként bizonyosodjunk meg arról, hogy a szolgáltatás (service) rendben elindul:

# /etc/init.d/postgresql start
* Starting PostgreSQL ...                                          [ ok ]

Ha rendben működik, akkor egy jó gondolat, hogy az alapértelmezett futási szinthez adjuk hozzá:

# rc-update add postgresql default
* postgresql added to runlevel default

Ha rendben megy, akkor itt az ideje, hogy kipróbáljunk egy teszt adatbázist. Kezdésként hozzunk létre egy test adatbázist és ehhez használjuk a createdb parancsot. A -U kapcsolóval megadható, hogy melyik felhasználóval csatlakozom (ha nem adsz meg semmit, akkor az aktuális felhasználó lesz), és a -W kapcsoló pedig a kérni fogja a jelszót. Végezetül add meg a létrehozni kívánt adatbázis nevét:

$ createdb -U postgres -W test
Password:
CREATE DATABASE

Az adatbázis sikeresen elkészült akkor ezután képes különböző feladatok elvégzésére. Menjünk tovább előre és dobjuk(töröljük) el ezt az adatbázist a dropdb paranccsal:

$ dropdb -U postgres -W test
Password:
DROP DATABASE

Nos, csak a postgres felhasználó tud parancsokat futtatni. Nyilvánvaló, hogy a beállításnak ez a módja nem jó mert mi egy többfelhasználós környezetet szeretnénk. A következő bekezdés megmutatja hogyan lehet dolgozni felhasználói hozzáférésekkel.

Az adatbázis beállítása felhasználói hozzáférésekkel

Mint azt korábban említettük csak, mint postgres felhasználó tudunk belépni és ez nem kívánatos egy többfelhasználós környezetben. A legtöbb esetben különböző felhasználók és szolgáltatások férnek hozzá a szerverhez, és mindegyikük különböző jogosultságokkal rendelkezik. Nos, ezen segít a createuser parancs. Ez a parancs egy nagymértékben rugalmassá teszi az adminisztrációt. Az alábbiakban csinálunk két felhasználót, egy 'superuser' -t aki felvehet felhasználókat, és adminisztrátora az adatbázisnak, majd egy alap felhasználót:

(cseréld ki a gergely-t arra amit használni szeretnél)
$ createuser -a -d -P -E -U postgres -W gergely
Enter password for new user:
Enter it again:
Password:
CREATE USER

Most egy superusert hoztunk létre. A parancs opcióiban lévő -a adja meg, hogy az újonnan létrejövő felhasználó hozhat létre új felhasználókat. A -d kapcsoló adja meg, hogy létrehozhat adatbázisokat. A -P hatására meg kell adni a jelszót, a -E titkosítja a megadott jelszót. Akkor most próbáljuk ki az új felhasználó jogosultságait.

(az andras-t cseréld ki a számodra megfelelőre)
$ createuser -A -D -P -E -U gergely -W andras
Enter password for new user:
Enter it again:
Password:
CREATE USER

Siker! Az új felhasználót a fentiekben létrehozott superuser hozta létre. A -A és -D parancssori kapcsolók szemben a -a és -d opciókkal megtiltják, hogy az új felhasználó létrehozzon új felhasználókat vagy új adatbázisokat. Akkor most ezek a felhasználók készen állnak a munkára, a következő részben új adatbázissal foglalkozunk

3.  PostgreSQL használata

Jogosultságok beállítása

Nos van egy felhasználó, aki létrehozhat adatbázisokat és más felhasználókat, és az alap postgres felhasználó, aki bármit megtehet. A felhasználó aki korábban létrejött jelenleg be tud lépni az adatbázis szerverre, és ennyi. Általában a felhasználóknak szükségük van arra, hogy adatokat szúrjanak be (insert), javítsák, módosítsák azokat, és időnként más feladataik is akadhatnak. Szóval ennek a felhasználónak meg kell adni egy s mást, hogy majdnem bármit megtehessen, azaz kell állítani a megfelelő jogosultságokat. Ez könnyen megtehető a createdb parancs -O kapcsolójának megadásával. Elkezdjük létrehozni az új adatbázist - aminek a neve sajatDB lesz, a superuserrel és az előző teszt felhasználó (nem a superuser) lesz a gazdája:

$ createdb -O andras -U gergely -W sajatDB
Password:
CREATE DATABASE

Nos, van egy sajatDB nevű adatbázisunk amihez a teszt felhasználó hozzáférhet. Tesztelésképpen lépjünk be az andras felhasználóval a sajatDB adatbázisba. Ezt a psql programmal tehetjük meg. Ez az a program amit arra használunk, hogy parancssoron keresztül csatlakozzunk a PostgreSQL adatbázishoz. Szóval csatlakozzunk valahogy így:

$ psql -U andras -W sajatDB
Password:
Welcome to psql 8.0.4, the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
       \h for help with SQL commands
       \? for help with psql commands
       \g or terminate with semicolon to execute query
       \q to quit

sajatDB=>

A teszt-felhasználó belépett az adatbázisba és elkezdhet használni különböző parancsokat. Azért, hogy megmutassuk a PostgreSQL használatának ízét a következő részben megnézünk néhány alap parancsot amelyekkel a psql kliensen keresztül használhatunk.

Alap PostgreSQL parancsok és egy tábla létrehozása

Kezdetnek itt van egy lista arról a pár parancsról amiket meg fogunk mutatni.

A \c[onnect] parancs kivételével mindegyik használatát be fogjuk mutatni a későbbiek során. Akkor most az adatbázis üres. Be kell szúrni (INSERT) valamennyi adatot. Az adatbevitel első lépése tulajdonképpen a tábla létrehozása. De most nincsenek táblák az adatbázisban, szóval csinálnunk kell egyet. Ezt megtehetjük a CREATE TABLE paranccsal. Meg kell határozni a tábla elemeit. Ez tartalmazza a Product ID, Description, és price oszlopokat:

sajatDB=> CREATE TABLE products (
sajatDB(>   product_id SERIAL,
sajatDB(>   description TEXT,
sajatDB(>   price DECIMAL
sajatDB(> );
NOTICE:  CREATE TABLE will create implicit sequence "products_product_id_seq"
for serial column "products.product_id"
CREATE TABLE

Nyugodtan hagyd figyelmen kívül a NOTICE részt. Teljesen ártalmatlan. Nézd meg a funkció utolsó sorát: a CREATE TABLE jelzi ha a parancs sikeresen végrehajtásra került. Akkor most haladjunk előre és nézzük meg a \d paranccsal, hogy mit is csináltunk:

sajatDB=> \d products
                                 Table "public.products"
   Column    |  Type   |                            Modifiers
-------------+---------+------------------------------------------------------------------
 product_id  | integer | not null default nextval('public.products_product_id_seq'::text)
 description | text    |
 price       | numeric |

A tábla valóban létrejött. Most, hogy készen van tegyünk bele adatot. A következő szakaszban ezt fogjuk megmutatni.

Adatok bevitele (INSERT) az adatbázisba

Ebben a részben két lehetőségét mutatom meg az adatbázis adatokkal való feltöltésének. Elsőként nézzük meg az INSERT parancsot:

INSERT INTO [tablename] (column1,column2,column3) VALUES(value1,value2,value3)

tablename tartalmazza a tábla nevét amibe az adatok belekerülnek. (column1,column2,column3) elemekkel adhatod meg, hogy melyik oszlopba kerüljenek adatok. Fontos, hogy a VALUES részben is ebben a sorrendben legyenek megadva az oszlopnevek. VALUES(value1,value2,value3) a bevitelre kerülő értékek listája. Ismételten: a values rész sorrendjének ugyanannak kell lennie, mint a columns résznek mert: column1-be kerül a value1, column2 -be kerül a value2, stb. A két sorrendnek egyformának kell lennie. Akkor most rakjunk (insert) adatokat az adatbázisba:

sajatDB=> INSERT INTO products (description,price)
VALUES('A test product', 12.00);
INSERT 17273 1

Az utolsó sort meg kell magyaráznom. Az insert parancs visszaad egy OID-t (Objektum Azonosító) és a bevitelre került sorok számát. Az OID ezen dokumentum hatókörén kívül esik. De itt olvashatsz róla: PostgreSQL manual A szituáció a következő: van 20,000 terméked és ennyi adatnak a bevitele a fenti insertekkel kissé unalmas és fárasztó. De nincsen semmi elveszve. A COPY paranccsal is lehet adatokat bevinni a táblába stdin-en keresztül, fájlból. A példának megfelelően feltételezzük, hogy csv (comma separated values, vesszővel elválasztott értékek) fájlban vannak adataid, és ez a fájl így néz ki tartalmilag:

2,meat,6.79
3,soup,0.69
4,soda,1.79

Most használjuk a COPY parancsot adatok bevitelére:

sajatDB=> COPY products FROM STDIN WITH DELIMITER AS ',';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 2,meat,6.79
>> 3,soup,0.69
>> 4,soda,1.79
>> \.

Szerencsétlenségünkre ez a megoldás nem ad vissza semmi információt az adatok beviteléről, mint azt az INSERT INTO teszi. Honnan tudjuk, hogy az adatok bevitelre kerültek? A következő részben megnézzük hogyan tudunk lekérdezéseket megírni, és futtatni az adatokon, hogy ellenőrizzük a bevitt adatokat.

PostgreSQL lekérdezések

Ebben a részben megnézzük a SELECT használatát, hogy adatokat kérjünk le a táblából. A SELECT így néz ki:

SELECT (column1,column2|*) FROM (table) [WHERE (conditionals)]

Két lehetőség van: az első a *, hogy minden adatot, oszlopot lekérdezzünk. A második, hogy megadjuk mely oszlopokat akarjuk lekérni. A második lehetőség egy jó megoldás arra, hogy csak a kiválaszott oszlop adatait lásd. Elsőként a SELECT -t használjuk a *-al, hogy minden oszlop megjelenjen:

sajatDB=> SELECT * FROM products;
 product_id |  description   | price
------------+----------------+-------
          1 | A test product | 12.00
          2 | meat           |  6.79
          3 | soup           |  0.69
          4 | soda           |  1.79
(4 rows)

Ami itt látható az az összes adat a táblában amit korábban felvittünk. Most pedig csak a description és a price oszlopokat akarom látni, a product id nem érdekel. Ebben az esetben meg kell adni, hogy melyik táblákat akarom lekérdezni:

sajatDB=> SELECT description,price FROM products;
  description   | price
----------------+-------
 A test product | 12.00
 meat           |  6.79
 soup           |  0.69
 soda           |  1.79
(4 rows)

Most a product és a price oszlopok tartalma látható, így csak a számomra fontos adatokra koncentrálhatok. Akkor most nézzük meg, hogy hogyan nézhetjük meg a $2.00 -nál nagyobb értékű termékeket. Itt használjuk a WHERE klauzulát ilyen módon:

sajatDB=> SELECT description,price FROM products WHERE price > 2.00;
  description   | price
----------------+-------
 A test product | 12.00
 meat           |  6.79
(2 rows)

Most csak a $2.00 -nál drágább termékek jelennek meg. Így sokkal jobban koncentrálhatunk a fontos adatokra. A lekérdezések ilyen módon való használata nagyon hatékony módja az adatok kezelésének. Ilyen módon nagyon extrém reportok készíthetőek.

Befejezés

Ez volt a PostgreSQL ismertető. Egy nagy köszönet illeti Masatomo Nakanot, az előző Gentoo PostgreSQL karbantartónak a sok segítségéért. Bármilyen javaslatod van ezzel az ismertetővel kapcsolatban, azt a Chris White címre küldheted. További bővebb információkat találsz PostgreSQL weboldalán.

Ez a dokumentum a Creative Commons - Attribution / Share Alike licensz védelme alatt áll.