path: root/doc/FAQ_hungarian

   PostgreSQL GyIK Utolsó módosítás dátuma: 2002 Okt 20. Fordítás
   aktualizálása: 2003 január 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. Legfrissebb
   magyar nyelvű verzió:
   http://www.rootshell.be/~hornyakl/downloads/postgres_faq/ 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 lassúak 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 megtalá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 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álónak
   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. 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,
   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.
   _________________________________________________________________
   Felhasználói kliens kérdések 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élyezed azt -i opcióval a
   postmasternek, és nem állítod be host a 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
   indítást. A postgres program -s, -A és -t opciói is nagyon hasznosak
   lehetnek hibakeresésnél és teljesítmé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,
   vagy 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 belsiő adatstruktúrák és adatállományok
   formátuma. Ezek a 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
   dokumentá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 első pár sort akarod
   megkapni. Gondolj arra, hogy a lekérdezésben lehet ORDER BY is. Ha van
   olyan index, ami megfelel 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 hogy
   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 mennyisé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 adottat. 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 módositá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 lassúak 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 contrib/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.