mirror/postgresql
2
0
Fork 0
mirror of https://git.postgresql.org/git/postgresql.git synced 2024-12-21 08:29:39 +08:00
Code Issues Packages Projects Releases Wiki Activity
23b8a0ce61
postgresql/doc/FAQ_hungarian
Bruce Momjian 4e9face69a Add Hugarian FAQ, from Laszlo Hornyak
2003-01-13 23:00:32 +00:00

1122 lines
49 KiB
Plaintext
Raw Blame History

PostgreSQL GyIK
Utolsó módosítás dátuma: 2002 Okt 20.
A GyIK karbantartója: Bruce Momjian (pgman@candle.pha.pa.us)
Fordító: Hornyák László (hornyakl.NOSPAM@inf.elte.hu)
A legfrissebb verzió itt érhető el (angol):
http://www.PostgreSQL.org/docs/faq-english.html.
Platform specifikus kérdések:
http://www.PostgreSQL.org/users-lounge/docs/faq.html.
_________________________________________________________________
Általános kérdések
1.1) Mi a PostgreSQL? Hogy kell kimondani?
1.2) Mik a PostgreSQL felhasználási feltételei?
1.3) Milyen UNIX operációs rendszereken fut PostgreSQL?
1.4) Milyen nem UNIX operációs rendszerek elérhetőek?
1.5) Hogyan tudok PostgreSQL-t szerezni?
1.6) Hogyan kapok terméktámogatást?
1.7) Melyik a legfrissebb kiadás?
1.8) Milyen dokumentáció áll rendelkezésre?
1.9) Hogyan találok információt hibákról vagy hiányzó funkcionalításról?
1.10) Hogy tanuljam meg az SQL nyelvet?
1.11) A PostgreSQL 2000. év kompatibilis?
1.12) Hogyan lehet csatlakozni a fejlesztő csapathoz?
1.13) Hogyan küldjek hibajelentést?
1.14) Milyen a PostgreSQL más DBMS-ekkel összehasonlítva?
1.15) Hogyan tudom üzletileg segiteni a PostgreSQL-t?
Felhasználói kliens kérdések
2.1) Van ODBC meghajtó PostgreSQL-hez?
2.2) Milyen eszközök állnak rendelkezésre PostgreSQL Web fejlesztésekhez?
2.3) Van a PostgreSQL-hez grafikus felhasználói felület ? Riport
generátor? Beágyazott lekérdező nyelv felület?
2.4) Milyen programozási nyelvekkel lehet elérni a PostgreSQL szervert?
Adminisztrációs kérdések
3.1) Hogyan tudom a PostgreSQL-t /usr/local/pgsql -től eltérő helyre
installálni?
3.2) AMikor elindítom a postmaster-t, egy "Bad System Call"-t vagy core
dump-ot kapok. Miért?
3.3) Amikor megpróbálom inditani a postmaster-t, "IpcMemoryCreate" hibákat
kapok. Miért?
3.4) Amikor megpróbálom inditani a postmaster-t, "IpcSemaphoreCreate" hibákat
kapok. Miért?
3.5) Hogyan tudom kontrollálni a más gépekről érkező kapcsolat kéréseket?
3.6) Hogyan tudom nagyobb teljesítményre hangolni az adatbázisomat?
3.7) Milyen hibakereső lehetőségek érhetőek el?
3.8) Miért kapok "Sorry, too many clients" hibát csatlakozásnál?
3.9) Mi van pgsql_tmp könyvtárban?
3.10) Miért kell dumpolni és újratölteni PostgreSQL kiadás váltásánál?
Működtetési kérdések
4.1) Mi a különbség a bináris és a normál kurzorok között?
4.2) Hogyan tudom select-elni a lekérdezés első pár sorát?
4.3) Hogy tudom kilistázni a táblákat vagy más dolgokat a PostgreSQL-ben?
4.4) Hogyan tudok eltávolítani egy oszlopot egy táblából?
4.5) Mi a maximális mérete egy sornak, egy táblának vagy egy adatbázisnak?
4.6) Mekkora adatbázis lemez terület szükséges egy tipikus szöveg állomány
tárolásához?
4.7) Hogy tudhatom meg milyen táblák, indexek, adatbázisok vagy felhasználók
vannak definiálva?
4.8) A lekérdezéseim lassúak, vagy nem használják az indexeket. Miért?
4.9) Hogy tudom ellenőrizni, hogy optimalizálta a lekérdezés optimalizáló a
lekérdezésem?
4.10) Mi az R-tree index?
4.11) Mi a Genetic Query Optimizer?
4.12) Hogyan tudok regexp keresést és case-insensitive regexp keresést
használni? Hogyan tudok indexet használni case-insensitive kereséshez?
4.13) Hogyan tudom észlelni egy lekérdezésban, ha egy mező NULL?
4.14) Mi a különbség a különböző karaktertípusok között?
4.15.1) Hogyan tudok létrehozni automatikusan növekvő értékű mezőt?
4.15.2) Hogyan kaphatom meg egy SERIAL beszúrás értékét?
4.15.3) A currval() és a nextval() nem teremt holtpont veszélyes helyzetet
a felhasználók között?
4.15.4) Miért nem használódnak fel újra a sequence számok tranzakció abort
esetén?
Miért vannak problémák a serial oszlopok számozásával?
4.16) Mi a OID? Mi a TID?
4.17) Mi a PostgreSQL-ben használt kifejezések jelentése?
4.18) Miért kapom ezt a hibát: "ERROR: Memory exhausted in
AllocSetAlloc()"?
4.19) Hogyan tudhatom meg PostgreSQL, milyen verziót futtatok?
4.20) Miért kapok "invalid large obj descriptor" hibát nagy objektumok
kezelésénél?
4.21) Hogy hozhatok létre olyan oszlopot, aminek alapértelmezett érétke a
jelenlegi idő?
4.22) Miért olyan lassuak az al-lekérdezéseim IN-nel?
4.23) Hogyan tudok outer join-t végrehajtani?
4.24) Hogyan tudok több adatbázison végrehajtani lekérdezést?
4.25) Hogy tudok több soros vagy oszlopos eredményt visszaadni egy
funkcióból?
4.26) Miért nem tudom megbizhatóan létrehozni és törölni az átmeneti
táblákat a PL/pgSQL funkciókban?
4.27) Milyen replikációs lehetőségek vannak?
4.28) Milyen kódolási lehetőségek vannak?
A PostgreSQL kiterjesztése
5.1) Írtam egy felhasználói funkciót. Miért core dumpol az adatbázis amikor
használom?
5.2) Hogyan lehet új adattípusokat és funkciókat hozzáadni a PostgreSQL
disztribúcióhoz?
5.3) Hogyan lehet olyan C funkciót írni, ami Tuple-t ad vissza?
(több soros több oszlopos eredmények)
5.4) Megváltoztattam egy forrás állományt. Miért nem változik a bináris
újrafordítás után?
_________________________________________________________________
Általános kérdések
1.1) Mi a PostgreSQL? Hogy kell kimondani?
Így ejstd ki: Post-Gres-Q-L.
(Vagy talán inkább töltsd le a kis mp3-at a PostgreSQL homepage-ről)
A PostgreSQL a POSTGRES adatbázis management rendszer egy kiegészítése,
ami egy következő generációs DBMS kutatási prototípus. Megtartja a
POSTGRES adatmodellét és gazdag adattípus választékát, de a PostQuel
lekérdező nyelvet az SQL egy kiterjesztett verziójával helyettesíti.
A PostgreSQL szabad és a teljes forráskód hozzáférhető.
A PostgreSQL fejlesztését egy csapat végzi, amelynek minden tagja
megtalálható a PostgreSQL fejlesztői levelezési listán. A jelenlegi
koordinátor Marc G. Fournier (scrappyp@PostgreSQL.org). Ez a csapat
felelős minden fejlesztésért.
A PostgreSQL 1.01 alkotói Andrew Yu és Jolly Chen voltak. Sokan
járultak hozzá portolással, teszteléssel, hibakereséssel és
fejlesztéssel. Az eredeti Postgres kód, amiből a PostgreSQL származik
Michael Stonebraker professzor irányítása alatt fejlesztettek az
egyetem programozói, tanulói és végzett tanulói.
A szoftver ereeti neve Postgres volt. Amikor SQL funkcionalítással
egészítették ki 1995-ben, a nevét Postgres95-re változtatták. 1996
végén kapta mai nevét.
1.2) Mik a PostgreSQL felhasználási feltételei?
Az eredeti angol copyright szöveg:
--------------------
PostgreSQL is subject to the following COPYRIGHT:
PostgreSQL Data Base Management System
Portions copyright (c) 1996-2002, PostgreSQL Global Development Group
Portions Copyright (c) 1994-6 Regents of the University of California
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written
agreement is hereby granted, provided that the above copyright notice
and this paragraph and the following two paragraphs appear in all
copies.
IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND
ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
The above is the BSD license, the classic open-source license. It has
no restrictions on how the source code may be used. We like it and
have no intention of changing it.
--------------------
Ami nagyon leegyszerűsítve azt jelenti, hogy jogod van használni a
szoftvert mindenféle ellenszolgáltatás (pénz, stb) nélkül, a forrás
kódot módosíthatod, és továbbadhatod, DE semmilyen, a szoftver használatából
következő károsodásért nem vállal garanciát a fejlesztő.
A fenti a BSD licensz, egy klasszikus nyilt-forráskód licensz. Nem
tartalmaz megszorításokat arra, hogy a forráskódot hogyan használod fel.
Kedveljük ezt a licensz formát és nem áll szándékunkban megváltoztatni.
1.3) Milyen UNIX operációs rendszereken fut PostgreSQL?
Általában minden UNIX-kompatibilis operációs rendszer képes arra hogy
futtassa a PostgreSQL-t. Azokat a platformokat, amiken tesztelték a
kiadást megalálhatod a installációs utasítások között.
1.4) Milyen nem UNIX operációs rendszerek elérhetőek?
Kliens
A libpq C függvénykönyvtárat, a psql-t és más felületeket le lehet úgy
fordítani, hogy fussanak MS Windows operációs rendszereken. Ebben az esetben
a kliens MS Windows-on fut és TCP/IP segítségével kommunikál a Unixon
futó szerverrel. A "win32.mak" állomány a kiadás része, ennek segítségével
lehet Win32 platformokra lefordítani a libpq-t és a psql-t. A PostgreSQL
ODBC kliensekkel is képes kommunikálni.
Szerver
Az adatbázis szerver Cygwin segítségével fut Windows NT és Win2k
rendszereken. További információ található a pgsql/doc/FAQ_MSWIN
állományban és a MS Windows FAQ-ban a következő helyen:
http://www.PostgreSQL.org/docs/faq-mswin.html.
Natív MS Windows NT/2000/XP portok jelenleg fejlesztés alatt állnak.
1.5) Hogyan tudok PostgreSQL-t szerezni?
Az elsődleges anonim ftp oldal:
ftp://ftp.PostgreSQL.org/pub.
A tükör oldalak listája megtalálható a fő weboldalunkon.
1.6) Hogyan kapok terméktámogatást?
Az elsődleges lista a pgsql-general@postgresql.org. Ez használható
a PostgreSQL-lel kapcsolatos párbeszédekre. Ha fel szeretnél íratkozni,
küldj egy levelet a következő tartalommal (nem tárggyal) a
pgsql-general-request@postgresql.org címre:
subscribe
end
Az kivonatot minden tagnak elküldi a szerver, amikor a fő listán
összegyűlt körülbelül 30k üzenet.
Van egy hibákkal kapcsolatos levelezési lista is:
pgsql-bugs-request@PostgreSQL.org a következö tartalommal:
subscribe
end
A fejleszt?i levelezési lista:
pgsql-hackers-request@PostgreSQL.org a következ? tertalommal:
subscribe
end
Egyéb levelezési listák találhatóak a weboldalunkon:
http://www.PostgreSQL.org
Van egy IRC csatorna is #PostgreSQL néven ahol felteheted kérédseid.
A következő unix paranccsal csatlakozhatsz:
irc -c '#PostgreSQL' "$USER" irc.phoenix.net.
A kereskedelmi terméktámogatást nyújtó cégek listája elérhetö itt:
http://www.PostgreSQL.org/users-lounge/commercial-support.html
1.7) Melyik a legfrissebb kiadás?
A legfrissebb PostgreSQL kiadás a 7.3.
A tervek szerint minden negyedik hónapban van új kiadás.
1.8) Milyen dokumentáció áll rendelkezésre?
Számos kézikönyv, man oldalak és kis teszt példák találhatóak a kiadásban
a doc/ könyvtár alatt. Az interneten is olvashatod a dokumentációt a
következő címen:
http://www.PostgreSQL.org/users-lounge/docs/.
Két PostgreSQL könyv érhető el az interneten a
http://www.PostgreSQL.org/docs/awbook.html és a
http://www.commandprompt.com/ppbook/ címeken.
A megvásárolható könyvek listája itt található:
http://www.ca.PostgreSQL.org/books/.
A PostgreSQL-lel kapcsolatos technikai jellegű cikkek gy?jteménye:
http://techdocs.PostgreSQL.org/.
A psql parancs rendelkezik néhány \d utasítással, amellyekkel listázhatóak
az operátorok, a funkciók, stb.
A website is tartalmaz további dokumentációkat.
1.9) Hogyan találok információt hibákról vagy hiányzó funkcionalításról?
A PostgreSQLaz SQL-92 szabvány egy kiegészítése. Nézd meg a TODO listákat
ha érdekelnek az ismert hibák.
1.10) Hogy tanuljam meg az SQL nyelvet?
A PostgreSQL könyv a http://www.PostgreSQL.org/docs/awbook.html
címen tartalmaz SQL alapokat. Elérhető egy másik SQL könyv is a
http://www.commandprompt.com/ppbook címen. Egy szép oktató anyag
található a http://www.intermedia.net/support/sql/sqltut.shtm,
a http://ourworld.compuserve.com/homepages/graeme_birchall/HTM_COOK.HTM
és a http://sqlcourse.com oldalakon.
Egy másik lehetőség a "Tanítsd magad 21 nap alatt SQL-re, második
kiadás" a http://members.tripod.com/er4ebus/sql/index.htm.
Sok felhasználonk tetszett a gyakorlati SQL könyv ("The Practical
SQL Handbook").
1.11) A PostgreSQL 2000. év kompatibilis?
Igen, könnyedén kezeli a 2000 utáni és időszámításunk elött 2000 elötti
dátumokat is.
1.12) Hogyan lehet csatlakozni a fejlesztő csapathoz?
Elösször is töltsd le a forráskódot, és olvasd el a PostgreSQL
fejlesztői dokumnetációt a web oldalunkon vagy a kiadásban. Ezután
íratkozz fel a pgsql-hackers és a pgsql-patches levelezési listákra.
Végül pedig küldj be magas szinvonalú patch-eket a pgsql-patches listára.
Van egy pár ember, akiknek commit privilégiumuk a PostgreSQL CVS fán.
Ők olyan sok magas szinvonalú patch-et küldtek be, hogy az addigi
csapat már nem tudta követni, és nem volt kétségünk arról, hogy a
patch-ek amiket ők küldenek jó minőségű.
1.13) Hogyan küldjek hibajelentést?
Látogass el a BugTool oldalra:
http://www.PostgreSQL.org/bugs/bugs.php
Itt megtalálod követendő utasításokat.
Ellenőrizd az ftp oldalunkon is, hogy nincs-e újabb verzió vagy folt.
ftp://ftp.PostgreSQL.org/pub
1.14) Milyen a PostgreSQL más DBMS-ekkel összehasonlítva?
Számos nézőpontból lehet vizsgálni a szoftvert: képességek, teljesítmény
megbízhatóság, támogatottság és ár.
Képességek
A PostgreSQL rendelkezik a nagy, kereskedelmi DBMS-ek képességeivel:
tranzakciók, al-lekérdezések, triggerek, nézetek, külső kulcsok,
integrítás és kifinoult zármechanizmusok. Van néhány képessége,
ami a kereskedelmi adatbázisokból hiányzik, mint például a
felhasználó által definiált típusok, öröklődés, szabályok és
verzió kontroll a zárolási viták redukálásáért.
Teljesítmény
A PostgreSQL teljesítménye hasonlít a kereskedelmi és más nyílt
adatbázis szerverekéhez. Lehet bizonyos esetekben lassabb, másokban
gyorsabb. A MySQL nevű tanuló RDBMS például gyorsabban hajt végre
insert/update műveleteket, mivel a tranzakciókat elsumákolja.
Persze a MySQL nem rendelkezik a képességek részben felsoroltak
nagy részével nem rendelkezik. Mi a megbízhatóságra és a
képességekre építünk, bár a teljesítmény is nő minden kiadással.
Van egy érdekes oldal a MySQL és a PostgreSQL összehasonlításával
a http://openacs.org/philosophy/why-not-mysql.html címen.
Megbízhatóság
Tudjuk hogy ha egy DBMS nem megbízható, akkor teljesen haszontalan.
Igyekszünk jól tesztelt, stabil kódot kiadni, amiben a lehető
legkevesebb hiba van. Minden kiadás elött eltellik legalább 1
hónap béta teszt, és a kiadási történet is azt mutatja, hogy
stabil kódot adunk ki, ami készen áll a produktív felhasználásra.
Úgy gondoljuk, felülmúlunk más adatbázis szoftvereket ezen a téren.
Támogatás
A levelezési listáink kapcsolatot teremtenek a fejlesztők
és felhasználók csoportjával , akik segítenek a problémák
megoldásában. Bár nem tudjuk garantálni hogy ki tudjuk
javítani a hibát, más, kereskedelmi adatbázis cégek sem tudják.
A fejlesztő csoport közvetlen elérési lehetősége, a közösség,
a dokumentáció és a forráskód gyakran támogatást biztosít,
mint más adatbázisoknál. Van kereskedelmi, alkalmi támogatás
azoknak, akiknek szüksége van rá (lásd: 1.6).
Ár
A PostgreSQL szabad bármilyen felhasználásra, akár kereskedelmire
is. A termékhez hozzáadhatod a saját forráskódjaidat korlátozás
nélkül,
We are free for all use, both commercial and non-commercial.
You can add our code to your product with no limitations,
except those outlined in our BSD-style license stated above.
1.15) Hogyan tudom üzletileg segiteni a PostgreSQL-t?
A PostgreSQL első osztályú infrastruktúrával rendelkezik, amit 1996-ban
indítottunk el. Mindent Marc Fourniernek köszönhetünk, aki létrehozta
és karbantartja a rendszert.
A minőségi infrastruktúra nagyon fontos egy nyilt forrású szoftver
esetében. Megvéd az olyan fennakadásoktól, amelyek komoly késéseket
okoznak a fejlesztésekben.
Természetesen ez az infrastruktúra nem olcsó. Számos havi és állandó
kiadásunk van. Ha a cégednek van pénze, amivel támogatná erőfeszítéseinket,
kérlek látogass el a http://store.pgsql.com/shopping/ oldalra.
Bár a weboldal "PostgreSQL, Inc"-ként említi, a hozzájárulások kizárólag
a PostgreSQL fejlesztésre értendóek, és nem egy meghatározott cégnek. Ha
jobban tetszik, küldhetsz csekket is a kapcsolati címek bármelyikére.
_________________________________________________________________
User Client Questions
2.1) Van ODBC meghajtó PostgreSQL-hez?
Két ODBC meghajtó érhető el: PsqlODBC és a OpenLink ODBC.
A PsqlODBC a PostgreSQL kiadás része. További információ található a
ftp://ftp.PostgreSQL.org/pub/odbc/ oldalon.
Az OpenLink ODBC-t a http://www.openlinksw.com címről töltheted le.
Ez az ő szabványos ODBC kliens szoftverükkel működik, így minden
általuk támogatott platformon (Win, Mac, Unix, VMS) elérhető lesz
a PostgreSQL szerver.
Talán olyan vevőknek fogják eladni, akik kereskedelmi minőségű terméket
szeretnének kapni, de a freeware verzió mindig elérhető lesz. Kérdéseidet
a termékkel kapcsolatban a postgres95@openlink.co.uk címen teheted fel.
Olvasd el az ODBC fejezetet is a programozók kézikönyvében!
2.2) Milyen eszközök állnak rendelkezésre PostgreSQL Web fejlesztésekhez?
Egy szép bemutató olvasható az adatbázissal támogatott web oldalanról
a http://www.webreview.com weboldalon.
A web integrációhoz a PHP egy kiválló szoftver. Letölthető a
http://www.php.net címről.
Komplexebb esetekre sokan használják a Perl felületet és a CGI.pm vagy a
mod_perl-t.
2.3) Van a PostgreSQL-hez grafikus felhasználói felület ? Riport
generátor? Beágyazott lekérdező nyelv felület?
Van egy szép PgAccess nevű grafikus felületünk, ami riport generátorként
is használható. A weboldalát megtalálod a http://www.pgaccess.org/ címen.
A disztribúció tartalmazza az ecpg programot is, ami egy beágyazott SQL
lekérdezési felület C nyelvhez.
2.4) Milyen programozási nyelvekkel lehet elérni a PostgreSQL szervert?
A következök:
* C (libpq)
* C++ (libpq++)
* Embedded C (ecpg)
* Java (jdbc)
* Perl (DBD::Pg and perl5)
* ODBC (odbc)
* Python (PyGreSQL)
* TCL (libpgtcl)
* C Easy API (libpgeasy)
* PHP ('pg_' functions, Pear::DB)
További programozási felületek érhetőek el a
http://www.PostgreSQL.org/interfaces.html és a
http://gborg.PostgreSQL.org oldalakon.
_________________________________________________________________
Adminisztrációs kérdések
3.1) Hogyan tudom a PostgreSQL-t /usr/local/pgsql -től eltérő helyre
installálni?
A configure script --prefix paraméterének használatával.
3.2) AMikor elindítom a postmaster-t, egy "Bad System Call"-t vagy core
dump-ot kapok.
Miért?
Számos probléma lehet, de legelösször ellenőrizd le, hogy a kerneled
System V kiegészítésekkel rendelkezik-e. A PostgreSQL használja a
kernel osztott memória és szemafor API-ját.
3.3) Amikor megpróbálom inditani a postmaster-t, "IpcMemoryCreate" hibákat
kapok. Miért?
Vagy nincs megfelelően konfigurálva a kerneled osztott memória támogatása
vagy meg kell nagyobbítanod a maximális osztott memória méretet.
A pontos méret szükséglet függ az architektúrádtól és attól hogy hány
buffert és processzt konfigurálsz a postmasternek. Legalább 1 MB
területre szükséged van. A PostgreSQL Adminisztráció kézikönyvben
olvashatsz részletesebb információkat az osztott memóriáról és a
szemaforokról.
3.4) Amikor megpróbálom inditani a postmaster-t, "IpcSemaphoreCreate"
hibákat kapok. Miért?
Ha a hibaüzenet ez: " IpcSemaphoreCreate: semget failed (No space
left on device)", akkor a kerneled konfigurációja nem tesz lehet?vé
elegend? szemafort. A PostgreSQL szerver processzenként 1 szemafort
igényel. Egy átmeneti megoldás lehet az hogy a postmastert kevesebb
maximális processz számmal inditod el. Használd a -D paramétert.
Egy sokkal megfelelőbb megoldás az ha növeled a kerneled SEMMNS
és SEMMNI paramétereit.
A hibás szemaforok is adatázis lerobbanásához is vezethet nagy terhelés
esetén.
Ha a hibaüzenet valami más, lehet hogy nincs szemaforok támogatás
forditva a kerneledbe. Olvasd el a PostgreSQL adminisztrátorok
kézikönyvében az osztott memóriáról és a szemaforokról szóló fejezetet.
3.5) Hogyan tudom kontrollálni a más gépekről érkező kapcsolat kéréseket?
Alapértelmezésben a PostgreSQL a helyi kapcsolatokat Unix socketekkel
valósítja meg. Más gépek nem lesznek képesek csatlakozni, ha nem
engedélyezi azt -i opcióval a postmasternek, és nem állít be host alapú
azonosítást a pg_hba.conf állományban. Ezzel válnak lehetővé a TCP/IP
kapcsolatok.
3.6) Hogyan tudom nagyobb teljesítményre hangolni az adatbázisomat?
Az indexelés feltétlenül gyorsítja a lekérdezéseket. Az EXPLAIN
parancs lehetővé teszi hogy lásd, hogy a PostgreSQL miként interpretálja
a lekérdezést és melyik indexet használja.
Ha sok INSERT műveletet hajtassz végre, csináld nagy kötegekben a COPY
paranccsal. Ez sokkal gyorsabb mint az egyedi INSERT parancsok. Másodszor:
Azok a műveletek, amelyek nincsenek tranzakció blokkon belül, azok saját
tranzakciót indítanak. Sok műveletet érdemes egy tranzakción belül
végrehajtani. Ez csökkenti a tranzakció kezelés többletidejét. Az indexeket
javasolt a nagy adatváltozások elött eltávolítani, majd újra létrehizni.
Számos teljesítmény javító lehetőség van. Kikapcsolhatod az fsync()
műveletet a postmaster -o -F opciókval való indításakor. Így nem fog
az amugy lassú fsync() függvény meghívódni minden tranzakció végén.
Használhatod a postmaster -B opcióját is az osztott memória szegmens
méretének növeléséhez. Ha az értéket túl magasra állítod, lehet hogy
a postmaster nem indul el, mert túllépted az operációs rendszer által
megengedett méretet. Minden buffer 8K méretű és alapértelmezésban 64
buffer van.
A -S opcióval növelheted a szerver átmeneti rendezésekre fenntartott
memória területét. Az értéket kilobyteban add meg. Az alapértelmezett
érték 512K.
Használhatod a CLUSTER utasítást is, hogy a táblákat egy indexnek
megfelelően csoportosítsd. Olvasd el a CLUSTER kézikönyv oldalt további
részletekért.
3.7) Milyen hibakereső lehetőségek érhetőek el?
A PostgreSQL számos lehetöséggel rendelkezik ami értékes lehet a hiba-
keresésnél.
Elösször is, futtathatod a configure scriptet --enable-cassert
opcióval, sok assert() funkcióhivás ellenörzi a program futását és
megállitja ha valami vératlan hiba történik.
Mind a postmaster és a postgres számos hibakeresö lehetüséggel rendelkezik.
Mindig amikor elinditod a postmastert, gyözödj meg róla, hogy a kimenetet
log állományba küldöd. Igy:
cd /usr/local/pgsql
./bin/postmaster >server.log 2>&1 &
Ez egy server.log állományt hoz létre a felsö PostgreSQL könyvtárban.
Ez az állomány tartlamaz majd számos hasznos információt a szerverrel
kapcsolatos problémákról és hibákról. A postmaster -d opciójával lehet
részletesebb hibakeresö információt kapni. A -d opcióhoz meg kell
határozni egy hiba szintet. Vigyázz, a magas hibakeresö szint nagy
log állományt okozhat.
Ha a postmaster nem fut, akkor futtathatod a postgres szervert
parancssorból is, és az SQL kifejezést közvetlenül ennek adhatod át.
Ez csak hibakeresés esetében javasolt. Az új sor a kifejezés végét jelenti,
nem a pontosvesszö. Ha hibakeresö opciókkal forditottad a szervert,
használhatsz egy debuggert is hogy lásd hogy mi történik. Mivel igy a
szervert nem a postmaster inditotta, nem többfelhasználós környezetként
fut, igy a zárolási és a szerverek közötti kommunikációs hiba jelenségek
nem jelentkeznek.
Ha már fut a postmaster, indits egy psql-t, és nézd meg a szerver processz
PID-jét! Egy debuggert használhatsz a processzhez csatlakozáshoz.
Beállithatsz töráspontokat és elindithatsz lekérdezéseket. Ha a postgres
inditásban keresel hibát, a PGOPTIONS környezeti változót állitsd be "-W n"
értékre. Ez n másodperc várakozást idéz elö, igy tudsz csatlakozni a
processzhez, el tdsz hejezni töréspontokat, majd folytathatod a inditást.
A postgres program -s, -A és -t opciói is nagyon hasznosak lehetnek
hibakeresésnél és teljesitmény mérésnél.
Profiling lehtöséggel is fordithatod a szervert, hogy lásd melyik
funkciók foglalják el a futási időt. A szerver profile állományai
a pgsql/data/base/dbname könzvtárba kerülnek, a kliens profile
állományok az aktuális könyvtárba. Linuxon ehhez szükséges a
-DLINUX_PROFILE fordítási direktiva.
3.8) Miért kapok "Sorry, too many clients" (Túl sok kliens)
hibát csatlakozásnál?
Növelned kell a postmaster egyidejűleg futtatott szerver processz szám
korlátját.
Az alapértelmezett korlát 32 processz. Ezt növelhetjed úgy, hogy
újrainditod a postmastert és -N opcióval meghatárotod az új értéket,
vagz módositod a postgresql.conf-ot.
Ne felejtsd el, hogy ha növeled a szerver processzek maximális számát,
akkor bufferek számát is növelned kell, legalább a processzek számának
kétszeresére. Nagy processz számokesetében valószinüleg a Unix
konfigurációs paramétereken is növelni kell. Ellenörizd a SHMMAX
(az osztott memória szegmensek maximális mérete), a SEMMNS és a SEMMNI
(a szemaforok maximális száma), az NPROC (a processzek maximális száma),
a MAXUPRC (felhasználónkénti maximális processz szám) és a NFILE és NINODE
(a megnzitott állománzok maximális száma) paramétereket. A PostgreSQL
azért korlátozza külön a processz számot, hogy a rendszeredet ne terhelhesse
meg túlságosan.
A PostgreSQL 6.5 verzióban a maximális szerver processz szám 64 volt és
a módositáshoz bele kellett irni a include/storage/sinvaladt.h állományba
és újra kellett forditani a servert.
3.9) Mi van pgsql_tmp könyvtárban?
Ez a könyvtár a lekérdezés végrehajtó által létrehezott átmeneti
állományokat tartalmazza. Például ha egy rendezést kell végrehajtani
egy ORDER BY kifejezés miatt és a m?velet több memóriát vesz
igénybe, mint amennyit a -S paraméter megenged, akkor az átmeneti
könyvtárban hoz létre egy állományt a fennmaradó adat tárolására.
Az átmeneti állományok többnyire törl?dnek, de meg is maradhat ha
például váratlan hibával leáll a szerver egy rendezés közben. Inditáskor
és leállitáskor ezeket az állományokat törli a postmaster.
3.10) Miért kell dumpolni és újratölteni PostgreSQL kiadás váltásánál?
A PostgreSQL csapat csak apróbb változtatásokat hajt végre a kisebb
kiadások között, igy ha 7.2 verzióról állsz át 7.2.1 verzióra, akkor nem
szükséges kidumplonod az adatbázist. A nagy kiadások esetében (például
verzióról 7.3-ra áttérésnél) változik a bels? adatstruktúrák és
adatállományok formátuma.Ezeka változások gyakran nagyon összetettek,
ezért inkáb nem tartunk fenn visszafelé kompatibilitást. A dump
az adatot általános formátumban irja ki, majd az új formátumban lehet
azt visszatöleni.
Azokban a kiadásokban, amelyek között az adat formátum nem változik,
a pg_upgrade program használható dumpolás és helzreállitás nélkül.
_________________________________________________________________
Működtetési kérdések
4.1) Mi a különbség a bináris és a normál kurzorok között?
Nézd meg a DECLARE dokumentációját.
4.2) Hogyan tudom select-elni a lekérdezés első pár sorát?
Olvasd el a FETCH dokumnetációját, vagy használd a SELECT
LIMIT-et.
Az egész lekérdezést végre kell hajtani, még akkor is, ha csak az alsö
pár sort akarod megkapni. Gondolj arra, hogy a lekérdezésben lehet ORDER BY
is. Ha van olyan index, ami megdfelel az ORDER BY kifejezésednek, a
PostgreSQL képes lehet az elsö néhány rekord visszaadására, vagy a teljes
lekérdezésnek le kell futnia, amig a kért rekordok le nem generálódnak.
4.3) Hogy tudom kilistázni a táblákat vagy más dolgokat a PostgreSQL-ben?
Elolvashatod a psql forrás kódjában a pgsql/src/bin/psql/describe.c
állományban. Ez SQL parancsokat tartalmaz, amelyek azokat a kimeneteket
állitják elö, amiket a per jellel kezdödö parancsok adnak vissza.
4.4) Hogyan tudok eltávolítani egy oszlopot egy táblából?
Ez a funkcionalitás a 7.3 verziótül kezdve érhetö el az ALTER TABLE
DROP COLUMN -nal. A régebbi vertiókban igy lehet végrehajtani:
BEGIN;
LOCK TABLE old_table;
SELECT ... -- minden oszlopot, kivétel amit törölni szeretnél
INTO TABLE new_table
FROM old_table;
DROP TABLE old_table;
ALTER TABLE new_table RENAME TO old_table;
COMMIT;
4.5) Mi a maximális mérete egy sornak, egy táblának vagy egy adatbázisnak?
A korlátok:
adatbázis: korlátlan (1 TB az általunk ismert lagnagyobb)
tábla: 16 TB
rekord/sor 1.6TB
mezö 1 GB
a tábla sorainak száma: korlátlan
a tábla oszlopainak száma: 250-1600 az oszlop nevektől függöen
A tábla indexeinek száma: korlátlan
Természetesen nem igazán korlátlan, de a tárterület, memória és egyéb
külsö tényezök korlátozzák. A teljesitmény romolhat, ha ezek az értékek
szokatlanul nagyok.
A 16 TB-os legnagyobb tábla méret nem igényel nagy állomány támogatást.
A nagy táblák több 1 GB méretü állományba kerölnek, igy az állomány
rendszer korlátai nem lényegesek.
A maximális tábla méret és az oszlopok maximális oszlop szám növelhetö,
ha az alapértelmezett blokkméretet 32k-ra növeled.
4.6) Mekkora adatbázis lemez terület szükséges egy tipikus szöveg állomány
tárolásához?
A PostgreSQL akár a szöveg állomány helyigénzének ötszörösét is elfoglalhaja.
Képzelj el például, egy 100.000 soros szöveget, aminek minde sora
egy számból és egy szövegből áll. Tegyük el, hogy átlagosan 20 byte hosszú
szövegek. Ez a szövegállomány körülbelül 2.8 MB helyet foglalna el.
A tábla ami a fenti adatszerkezetet eltárolná, körülbelül 6.4 MB-os lenne.
Ezt a következöképpen számolhatjuk ki:
36 byte: sor fejléc
24 byte: egy int mezö + egy szöveg mezö
4 byte: mutato
---------------------------------------
64 byte soronkent.
Az adat oldal mérete a PostgreSQL-ben 8192 byte, igy
8192 / 64 = 128 rekord adatbázis oldalanként (lefelé kerekitve).
100000 rekord / 128 rekord oldalanként = 782 adat oldal (felelé kerekitve).
782 adatbázis oldal * 8192 byte olalanként = 6,406,144 byte (6.4 MB)
Az indexek nem foglalnak túl sokat, de tartalmazzák az indexelt adatot,
igy ezek is lehetnek nagyok.
A NULL értékek bittérképben vannak tárolva, igy kevés helyet foglanak.
4.7) Hogy tudhatom meg milyen táblák, indexek, adatbázisok vagy felhasználók
vannak definiálva?
A psql-ben találsz számos '\' karakterrel kezdödö utasítást az ilyen
információk listázására. A '\?' segitségével tudot kilistázni ezeket
a parancsokat. Ezen kivül vannak rendszer táblák, amelyek nevei 'pg_'
-vel kezdödnek.
Próbáld ki a pgsql/src/tutorial/syscat.source állományt is. Ez sok
példát tartalmaz az rendszertáblákon végrehajtott SELECT-ekröl.
4.8) A lekérdezéseim lassúak, vagy nem használják az indexeket. Miért?
Az indexeket nem használja a szerver minden lekérdezésnél automatikusan.
Csak akkor használ indexet, ha a tábla mérete egy megadott alsó határ
felett van, és a lekérdezés csak a sorok egy kis részét érinti. Ez azért
van, mert a véletlen hozzáférés még mindig lassabb lehet mint az tábla
szekvenciális olvasása.
Hogy a PostgreSQL meg tudja határozni hogy kell-e indexet használni,
léteznie kell egy statisztikának a tábláról. Ez a statisztikai adatok a
VAACUM ANALYZE vagy az egyszer? ANALYZE m?veletek során
jönnek létre. A statisztikai adatok felhasználásával az optimalizáló
meg tudja határozni, hogy hány sor van a táblában, és el tudja dönteni,
hogy használjon-e indexet. A statisztiaki adatgyüjtést id?nként végre
kell hajtani, ahogy a tábla adatai változnak.
Az indexeket normális esetben nem használja az ORDER BY vagy
az OUTER JOIN. A szekvenciális olvasás általában gyorsabb, mint az
index keresés egy nagy táblában.
Bár a LIMIT az ORDER BY-val kombinálva használhat indexet, mert
a tábla csak kis része érintett. Bár a MIN és MAX SQL funkciók sem
használják az indexeket, ezeket az értékeket egy ORDER BY + LIMIT
lekérdezéssel is le lehet kérdezni:
SELECT col
FROM tab
ORDER BY col [ DESC ]
LIMIT 1;
Amikor helyettesítő jel operátorokat használsz, mint a LIKE kulcsszó
vagy a ~, az indexeket csak bizonyos körülmények között lehet használni:
* A kereső string kezdete a keresési minta elején kell hogz legyen.
például:
+ A LIKE minták nem kezdődhetnek % jellel.
+ ~ (regexp) kifejezések nem kezdődhetnek ^ jellel.
* A keresési kifejezés nem kezdődhet karakter osztállyal.
* A case-insensitive keresés (ILIKE, ~*) nem használnak indexet
ehelyett funkcionális indexet használnak, amit a 4.12 pontban
találhatsz.
* Az alapértelmezett C hellyel kell futtatni az initdbüt.
4.9) Hogy tudom ellenőrizni, hogy optimalizálta a lekérdezés optimalizáló
a lekérdezésem?
Olvasd el a dokumentáció EXPLAIN-ról szóló részét.
4.10) Mi az R-tree index?
Az R-tree index a térbeli adat indexelésére alkalmas. Egy hash
index nem képes tartomány keresésekre. A B-tree index csak egy
dimenzión kezeli a tartomány kereséseket. Például ha az indexet
egy pont (point adattípus) típusú mez.re építjük, gyorsabban
kezeli az olyan jellegü lekérdezéseket, mint egy adott körben
található pontok.
Az R-tree tervezési mintát eredetileg leíró szöveg:
Guttman, A. "R-trees: A Dynamic Index Structure for Spatial
Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt of
Data, 45-57.
Ezt olvashatod Stonebraker "Readings in Database Systems" c.
könyvében.
A beépített R-tree kezelni tudják a sokszögeket (polygon adattípus)
és a dobozokat (box). Elméletileg, az R-tree kiterjeszthető további
dimenziókra is. Gyakorlatilag ezen dolgoznod kell egy kicsit, és
még nincs dokumentációnk arról hogy az hogyan müködik.
4.11) Mi a Genetic Query Optimizer?
A GEQO modul a lekérdezés optimalizáció sebességét növeli nagy
mennziség? tábla összekapcsolása esetén. Lehet?vé teszi a nagy
lekérdezések végrehajtását nem teljes kereséssel.
4.12) Hogyan tudok regexp keresést és case-insensitive regexp keresést
használni? Hogyan tudok indexet használni case-insensitive kereséshez?
A ~ operátor hajt végre reguláris kifejezés (regexp) értelmezést,
a ~* ennek case-insensitive változata. A LIKE case-insensitive
változata az ILIKE.
A case-insensitive egyenlőség műveleteket általában igy hajtjuk
végre:
SELECT *
FROM tab
WHERE lower(col) = 'abc';
Ez nem fog indexet használni, bár létrehozhatsz egy funkció indexet:
CREATE INDEX tabindex ON tab (lower(col));
4.13) Hogyan tudom észlelni egy lekérdezésben, ha egy mező NULL?
Használd "IS NULL"-t és az "IS NOT NULL"-t.
4.14) Mi a különbség a különböző karaktertípusok között?
Type Internal Name Notes
--------------------------------------------------
"char" char 1 character
CHAR(n) bpchar blank padded to the specified fixed length
VARCHAR(n) varchar size specifies maximum length, no padding
TEXT text no specific upper limit on length
BYTEA bytea variable-length byte array (null-byte safe)
Látni fogod a belső elnevezésüket, ha tanulmányozod a rendszertáblákat
és néhány hibaüzenetet.
Az utóbbi négy a "varlena" típusok, ami a tárolásuk módjára utal:
az els? 4 byte a lemezen a hosszúság, a többi az adat. A valódi méret
tehát nagyobb mint a deklarált hosszúság.Ezek azadatok tömöritve
tárolódnak el, igy kevesebb helyet foglalnek el az elöre számitottnál.
A CHAR(n) a legjobb megoldás, ha stabil hosszúságú stringet tárolsz.
A VARCHAR(n) jó arra az esetekre, ha a hosszúság változik, de van
felső korlátja. A TEXT típus korlátlan hosszúságú (1 GB-ig) szövegek
tárolására alklamas. A BYTEA bináris adatok tárolására van. A
teljesitmény mutatói hasonlóak ezenek a típusoknak.
4.15.1) Hogyan tudok létrehozni automatikusan növekvő értékű mezőt?
A PostgreSQL rendelkezik egy SERIAL adattípussal. Ez egy szekvenciát
és egy indexet hoz létre az oszlopon. Például ez:
CREATE TABLE person (
id SERIAL,
name TEXT
);
ugyanezt jelenti:
CREATE SEQUENCE person_id_seq;
CREATE TABLE person (
id INT4 NOT NULL DEFAULT nextval('person_id_seq'),
name TEXT
);
CREATE UNIQUE INDEX person_id_key ON person ( id );
A szekvenciákkal kapcsolatban olvasd el a create_sequence man
oldalt. A sor OID-jét is használhatod egyedi azonositóként, bár
ebben az esetben figyelj a pg_gump használatánál a -o opcióra
(COPY WITH OIDS, másolás OID-dal), hogy meg?rizd az értékeket.
4.15.2) Hogyan kaphatom meg egy SERIAL beszúrás értékét?
Egy megoldás erre az, ha a nextval() funkcióval megszerzed az
értéket még mielött beszúrnád az adatot a táblába. Erre itt láthatsz
egy példát:
new_id = execute("SELECT nextval('person_id_seq')");
execute("INSERT INTO person (id, name) VALUES (new_id, 'Blaise Pascal')");
Esetleg lekérdezheted a szekvencia állapotát a sor beszúrása után.
execute("INSERT INTO person (name) VALUES ('Blaise Pascal')");
new_id = execute("SELECT currval('person_id_seq')");
Végül pedig, használhatod a visszaadott OID értéket is, bár ez a lehető
legkevésbé portolható. Perl DBI-ben, Edmund Mergl DBD::Pg moduljában
az OID érték használható a $sth->execute() után ($sth->{pg_oid_status}).
4.15.3) A currval() és a nextval() nem teremt holtpont veszélyes helyzetet
a felhasználók között?
Nem. A currval() funkció a szerver processzed által adott értéket adja
vissza, nem pedig a többi szerver processz által adtottat.
4.15.4) Miért nem használódnak fel újra a sequence számok tranzakció
abort esetén?
Miért vannak problémák a serial oszlopok számozásával?
A párhuzamosság fejlesztése érdekében a sorozat számokat kérésre
adja ki a szerver futó tranzakcióknak, és azokat nem zárja, amig
a tranzakció véget nem ér. Ez jukakat okoz a számozásokban a
visszaforditott tranzakciók miatt.
4.16) Mi a OID? Mi a TID?
Az OID a PostgreSQL egyedi sor azonositója. Minden sor, ami létrejön
a szerveren, kap egy OID-t. Minden OID, amit az initdb alatt jön létre
16384 alatt van (lásd include/access/transam.h). Minden, felhasználó
által létrehozott OID legalább ennyi. Alapértelmezésben, az OID
nem csak a táblában vagy az adatbázisban egyedi, hanem a teljes
PostgreSQL adatbázis rendszerben.
A PostgreSQL az OID-okat a belsö tábláiban használja a sorok táblák
között összekapcsolásához. Ezek az OID-k használhatóak a rekordok
azonositására is amikor táblákat csatol össze a szerver (JOIN).
Az OID-ot használhatod mezö típusként is, és indexelheted is.
Az OID érték egy központi területröl származik, amit minden szerver
processz használ. Ha az OID-ot valami másra szeretnéd cserélni:
CREATE TABLE new_table(old_oid oid, mycol int);
SELECT old_oid, mycol INTO new FROM old;
COPY new TO '/tmp/pgtable';
DELETE FROM new;
COPY new WITH OIDS FROM '/tmp/pgtable';
Az OID 4 byte-os integer értékként tárolódik, igy 4 milliárdnál túlcsordul.
Még soha senki nem jelezte hogy ez történt volna, és ezt a korlátot
igyekszünk eltávolitani, még mielött bárki észrevenné.
A TID a fizikai sorok blokk és offszet címmel való azonositására szolgál.
A TID változik minden rekord modositás és törlés alkalmával. Ezeket az
indexek használják hogy a fizikai sort gyorsan megtalálják.
4.17) Mi a PostgreSQL-ben használt kifejezések jelentése?
Néhol a forrás kódban és a dokumnetációban találhatóak kifejezések,
amelyek általánosabb jelentéssel bírnak. Itt van néhány:
* tábla (table), reláció (relation), osztály (class)
* sor (row), rekord (record), tuple (nincs magyar jelentés)
* oszlop (column), mezö (field), attributum (attribute)
* retrieve, select
* helyettesit (replace), módosit (update)
* hozzáfűz (append), beszúr (insert)
* OID, sorozat érték (serial value)
* portal, cursor
* range variable, tábla név, tábla alias
Az általános adatbázis kifejezések összefoglalóját itt olvasható:
http://hea-www.harvard.edu/MST/simul/software/docs/pkgs/pgsql/glossary
/glossary.html
4.18) Miért kapom ezt a hibát: "ERROR: Memory exhausted in
AllocSetAlloc()"?
Lehet hogy elfogyott a virtuális memóriád, vagy a kerneled erőforrás
korlátai alacsonyak. Próbáld ki ezt mielött elinditanád a postmastert:
ulimit -d 262144
limit datasize 256m
A shelltől függően ezek közül csak az egyik fut majd le, de a
processzek adatszegmensét sokkal magasabbra állitja, ami talán
elég lesz a lekérdezés végrehajtásához. Ez az utasítás a jelenlegi
processzre (a shelled) érvényes, és minden általa létrehozott
processzre. Ha problémád van az SQL klienssel, mert a szerver
túl nagy adatot küld vissza, próbáld meg e klienssel is ugyanezt.
4.19) Hogyan tudhatom meg PostgreSQL, milyen verziót futtatok?
A psql programban select version();
4.20) Miért kapok "invalid large obj descriptor" hibát nagy objektumok
kezelésénél?
A nagy objektumok kezelését egy tranzakciós blokkban helyezd el.
(BEGIN és COMMIT között)
Jelenleg a PostgreSQL ezt a szabályt azzal teszi kötelezővé, hogy a
tranzakció végén a nagy objektumokat lezárja, igy a tranzakció után
az első művelet amit az objektumon végrahajtanál hibás lesz.
Ha olyan programozási felületet használsz mint az ODBC vagy a JDBC
akkor valószinűleg ki kell kapcsolnod az auto-commit-ot.
4.21) Hogy hozhatok létre olyan oszlopot, aminek alapértelmezett
érétke a jelenlegi idő?
Használd a CURRENT_TIMESTAMP -ot:
CREATE TABLE test (x int, modtime timestamp DEFAULT CURRENT_TIMESTAMP );
4.22) Miért olyan lassuak az al-lekérdezéseim IN-nel?
Jelenleg az al-lekérdezéseket a külső lekérdezéshez csatoljuk. Ha
az allekérdezés csak kevés sort eredményez és a külső lekérdezés
sokat, akkor az IN is gyors. Az EXISTS kulcsszó használatával
gyorsithatod a lekérdezéseket.
SELECT *
FROM tab
WHERE col IN (SELECT subcol FROM subtab);
EXISTS használatával:
SELECT *
FROM tab
WHERE EXISTS (SELECT subcol FROM subtab WHERE subcol = col);
Ahhoz hogy ez gyorsan fusson le, a subcol indexelt oszlopnak kell
hogy legyen. Reméljük ezt a korlátot sikerül hamarosan legyőznünk.
4.23) Hogyan tudok outer join-t végrehajtani?
A PostgreSQL a szabványos SQL szintaktikát követi. Itt van két példa:
SELECT *
FROM t1 LEFT OUTER JOIN t2 ON (t1.col = t2.col);
vagy
SELECT *
FROM t1 LEFT OUTER JOIN t2 USING (col);
Ezek az identikus lekérdezések összekapcsolják a t1.col és a t2.col
mezőket, és a t1 bármelyik kapcsolatlan sorát is visszadják. A RIGHT
JOIN a t2 kapcsolatlan sorait adta volna vissza, a FULL JOIN pedig
a kapcsolt, és mindkét tábla kapcsolatlan sorait adja. Az OUTER
kulcsszó opcionális, a LEFT, RIGHT és FULL JOIN szintaktikailag
helyes. Az átlagos összekapcsolásokat INNER JOIN-nak nevezzük.
Az előző kiadásokban a OUTER JOIN lekérdezéseket UNION és NOT IN
kulcsszavakkal lehetett szimulálni. Például a tab1 és a tab2
összekapcsolása:
SELECT tab1.col1, tab2.col2
FROM tab1, tab2
WHERE tab1.col1 = tab2.col1
UNION ALL
SELECT tab1.col1, NULL
FROM tab1
WHERE tab1.col1 NOT IN (SELECT tab2.col1 FROM tab2)
ORDER BY col1
4.24) Hogyan tudok több adatbázison végrehajtani lekérdezést?
Arra nincs lehetőség, hogy más adatbázisból kérdezz le adatot.
Mivel a PostgreSQL adatbázis specifikus rendszer táblákat tölt
be, bizonytalan hogy egy adatbázisok közötti lekérdezésnek hogyan
kellene viselkednie.
A contrib/dblink könyvtárban találsz egy megoldást erre, ami
funkció hivások segitségével működik. Persze, a kliens hozhat létre
szimultán kapcsolatot több adatbázissal, és összefésülheti az
eredményeket.
4.25) Hogy tudok több soros vagy oszlopos eredményt visszaadni egy
funkcióból?
A PL/pgSQL tárolt eljárás nyelvvel refcursor használatával.
Részletesen itt:
http://www.PostgreSQL.org/idocs/index.php?plpgsql-cursors.html
4.26) Miért nem tudom megbizhatóan létrehozni és törölni az átmeneti
táblákat a PL/pgSQL funkciókban?
A PL/pgSQL cacheli a funkciók tartalmát, aminek az a szerencsétlen
mellékhatása, hogy ha egy PL/pgSQL funkció használ egy átmeneti
táblát, ami kés?bb törlődik majd ujra létrejön, akkor az újra lefutó
funkció nem fogja megtalálni a táblát, mert a cache változat a régi
táblára tartalmaz mutatót. A megoldás erre az EXECUTE utasítás
használata az átmeneti táblák kezelésére PL/pgSQL-ben. Ez a
lekérdezés újrafordítását fogja előidézni minden alkalommal.
4.27) Milyen replikációs lehetőségek vannak?
Számos master/slave replikációs lehetőség létezik. Ez csak a master
adatbázis számára teszi lehetővé, hogy az adatokat változtassa. Egy
Listát olvashatsz ezekről itt:
http://gborg.PostgreSQL.org/genpage?replication_research
Egy többfelhasználós replikációs rendszer készül itt:
http://gborg.PostgreSQL.org/project/pgreplication/projdisplay.php.
4.28) Milyen kódolási lehetőségek vannak?
- A cotrib/pgcrypto tartlamaz számos SQL lekérdezésben használható kódolást.
- A kliens-szerver kommunikáció rejtjelezésére a hostssl használható.
Ezt a pg_hba.conf-ben engedélyeztheted.
- Az adatbázis felhsználók jelszavait tároláskor kódolja a rendszer. Régebbi
verziókban a PASSWORD_ENCRYPTION opcióval lehetett
bekapcsolni.
- A szerveren használhatsz kódolt fájrendszert.
_________________________________________________________________
A PostgreSQL kiterjesztése
5.1) Írtam egy felhasználói funkciót. Miért core dumpol az adatbázis amikor
használom?
Számos probléma lehet. Elöbb probáld ki a funkciódat egy különálló
alkalmazásban.
5.2) Hogyan lehet új adattípusokat és funkciókat hozzáadni a PostgreSQL
disztribúcióhoz?
Küldd el a kiegészítéseid a pgsql-hackers levelezési listára és a
forráskodjaid végül a contrib-ban kötnek ki.
5.3) Hogyan lehet olyan C funkciót írni, ami Tuple-t ad vissza?
A 7.3 verziótól kezdve a PostgreSQL támogatja a táblázatokat
viszzaadó funkciókat C, PL/pgSQL és SQL nyelveken. Bővebb
dokumentációt a Programozó kézikönyvben találsz. Egy C példa
funkció található a contrib/tablefunc könyvtárban.
5.4) Megváltoztattam egy forrás állományt. Miért nem változik a bináris
újrafordítás után?
A Makefile-ok nem ismerik a include állományok megfelelő függőségeit.
Végre kell hajtanod egy make clean-t, majd újra egy make-t. Ha GCC-t
használsz felhasználhatod a configure script --enable-depend opcióját,
így a compiler maga fogja ellenőrizni a függőségeket.
Reference in New Issue View Git Blame Copy Permalink