[edit] Last updated: Mon, 01 Nov 2010

CXXV. PostgreSQL Funktionen

Einführung

PostgreSQL ist ein kostenloses Open Source Datenbanksystem. Es wurde ursprünglich im UC Berkeley Computer Science Department entwickelt und hat Pionierarbeit bei objektrelationalen Datenbankkonzepten geleistet, die jetzt Einzug in einige kommerzielle Datenbanken halten. PostgreSQL bietet SQL92/SQL99 Sprachunterstützung, Transaktionen, referentielle Integrität, benutzerdefinierte Funktionen und ein erweiterbares Typkonzept. PostgreSQL ist eine Weiterentwicklung des ursprünglichen Berkeley-Codes.

Anforderungen

Um PostgreSQL benutzen zu können, brauchen Sie mindestens eine Version 6.5 oder später. Um alle Leistungsmerkmale des PostgreSQL-Moduls nutzen zu können, müssen Sie eine Version ab 8.0 haben. PostgreSQL unterstützt viele Zeichencodierungen, einschließlich multibyte character encoding. Die aktuelle Version sowie weitere Informationen über PostgreSQL sind auf den Seiten » http://www.postgresql.org/ erhältlich und die ausführliche Dokumentation finden Sie unter » PostgreSQL Documentation.

Installation

Um die PostgreSQL-Unterstützung zu aktivieren müssen Sie PHP mit der Option --with-pgsql[=DIR] kompilieren. DIR ist das Basis Installationsverzeichnis von PostgreSQL, normalerweise /usr/local/pgsql. Falls das shared-object-Modul verfügbar ist, kann PostgreSQL mit der extension-Directive in php.ini oder der Funktion dl() geladen werden.

Laufzeit Konfiguration

Das Verhalten dieser Funktionen wird durch Einstellungen in der php.ini beeinflusst.

Tabelle 224. PostgreSQL Konfigurationsoptionen

Name	Standard	Änderbar	Changelog
pgsql.allow_persistent	"1"	PHP_INI_SYSTEM
pgsql.max_persistent	"-1"	PHP_INI_SYSTEM
pgsql.max_links	"-1"	PHP_INI_SYSTEM
pgsql.auto_reset_persistent	"0"	PHP_INI_SYSTEM	Verfügbar seit PHP 4.2.0.
pgsql.ignore_notice	"0"	PHP_INI_ALL	Verfügbar seit PHP 4.3.0.
pgsql.log_notice	"0"	PHP_INI_ALL	Verfügbar seit PHP 4.3.0.

Weitere Details und die Definitionen der PHP_INI_*-Konstanten finden Sie im Anhang G, php.ini Einstellungen.

Hier eine kurze Erklärung der Konfigurationsoptionen:

pgsql.allow_persistent boolean: Bestimmt, ob persistente PostgreSQL-Verbindungen zulässig sind.
pgsql.max_persistent integer: Legt die maximale Anzahl persistenter PostgreSQL-Verbindungen pro Prozess fest.
pgsql.max_links integer: Legt Die maximale Anzahl aller PostgreSQL-Verbindungen, einschliesslich der persistenten Verbindungen, pro Prozess fest.
pgsql.auto_reset_persistent integer: Findet ungültige persistente Verbindungen, die mit der Funktion pg_pconnect() geöffnet wurden. Erfordert ein wenig Mehraufwand.
pgsql.ignore_notice integer: Bestimmt, ob Notice-Meldungen vom PostgreSQL-Server ignoriert werden sollen.
pgsql.log_notice integer: Bestimmt, ob Notice-Meldungen vom PostgreSQL-Server protokolliert werden sollen. Die PHP-Direktive pgsql.ignore_notice muss deaktiviert sein, um die Meldungen zu protokollieren.

Resource Typen

Im PostgreSQL-Modul werden zwei Ressource-Typen verwendet: Der erste ist die Verbindungskennung für Datenbankverbindungen, die zweite Ressource ist die Ergebniskennung, die ein Abfrageergebnis enthält.

Vordefinierte Konstanten

Folgende Konstanten werden von dieser Erweiterung definiert und stehen nur zur Verfügung, wenn die Erweiterung entweder statisch in PHP kompiliert oder dynamisch zur Laufzeit geladen wurde.

PGSQL_ASSOC (integer): Wird an die Funktion pg_fetch_array() übergeben. Gibt ein assoziatives Array zurück, mit den Feldnamen als Indizes und den entsprechenden Werten.
PGSQL_NUM (integer): Wird an die Funktion pg_fetch_array() übergeben. Gibt eine numerisches Array zurück, mit den Feldnummern als Indizes und den entsprechenden Werten.
PGSQL_BOTH (integer): Wird an die Funktion pg_fetch_array() übergeben. Gibt ein Array zurück, das sowohl assoziativ (mit den Feldnamen) als auch numerisch (mit den Feldnummern) indiziert ist, und den entsprechenden Werten.
PGSQL_CONNECT_FORCE_NEW (integer): Wird an die Funktion pg_connect() übergeben, um eine neue Verbindung zu erzwingen, anstatt eine identische, bereits geöffnete Verbindung wieder zu benutzen.
PGSQL_CONNECTION_BAD (integer): Wird von der Funktion pg_connection_status() zurückgegeben und zeigt an, dass der Status der Datenbankverbindung ungültig ist.
PGSQL_CONNECTION_OK (integer): Wird von der Funktion pg_connection_status() zurückgegeben und zeigt an, dass der Status der Datenbankverbindung gültig ist.
PGSQL_SEEK_SET (integer): Wird an die Funktion pg_lo_seek() übergeben. Das Objekt wird von Beginn an durchsucht.
PGSQL_SEEK_CUR (integer): Wird an die Funktion pg_lo_seek() übergeben. Das Objekt wird ab der aktuellen Position durchsucht.
PGSQL_SEEK_END (integer): Wird an die Funktion pg_lo_seek() übergeben. Das Objekt wird, ausgehend vom Ende, durchsucht.
PGSQL_EMPTY_QUERY (integer): Wird von der Funktion pg_result_status() zurückgegeben, wenn der an den Server gesendete String leer war.
PGSQL_COMMAND_OK (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein Kommando wurde erfolgreich ausgeführt, aber es wurden keine Daten zurückgegeben.
PGSQL_TUPLES_OK (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein Kommando wurde erfolgreich ausgeführt und es wurden Daten (wie etwa ein SELECT oder SHOW) zurückgegeben.
PGSQL_COPY_OUT (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein Datentransfer vom Server wurde gestartet.
PGSQL_COPY_IN (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein Datentransfer zum Server wurde gestartet.
PGSQL_BAD_RESPONSE (integer): Wird von der Funktion pg_result_status() zurückgegeben. Die Serverantwort wurde nicht verstanden.
PGSQL_NONFATAL_ERROR (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein nicht-fataler Fehler (eine Notiz oder Warnung) ist aufgetreten.
PGSQL_FATAL_ERROR (integer): Wird von der Funktion pg_result_status() zurückgegeben. Ein fataler Fehler ist aufgetreten.
PGSQL_TRANSACTION_IDLE (integer): Wird von der Funktion pg_transaction_status() zurückgegeben. Die Verbindung wird momentan nicht benutzt, es findet aktuell keine Transaktion statt.
PGSQL_TRANSACTION_ACTIVE (integer): Wird von der Funktion pg_transaction_status() zurückgegeben. Die Verbindung wird momentan benutzt. Es wird eine Abfrage ausgeführt, die noch nicht beendet ist.
PGSQL_TRANSACTION_INTRANS (integer): Wird von der Funktion pg_transaction_status() zurückgegeben. Die Verbindung wird von einer Transaktion benutzt, ist aber momentan nicht aktiv.
PGSQL_TRANSACTION_INERROR (integer): Wird von der Funktion pg_transaction_status() zurückgegeben. Die Verbindung wurde von einer abgebrochenen Transaktion benutzt und ist momentan nicht aktiv.
PGSQL_TRANSACTION_UNKNOWN (integer): Wird von der Funktion pg_transaction_status() zurückgegeben. Die Verbindung ist ungültig.
PGSQL_DIAG_SEVERITY (integer): Wird an die Funktion pg_result_error_field() übergeben. Gibt den Schweregrad des Fehlers zurück. Die Feldinhalte sind ERROR, FATAL oder PANIC (in einer Fehlermeldung) oder WARNING, NOTICE, DEBUG, INFO oder LOG (in einer Notice-Meldung) oder eine lokalisierte Übersetzung davon. Dieses Feld ist immer verfügbar.
PGSQL_DIAG_SQLSTATE (integer): Wird an die Funktion pg_result_error_field() übergeben. Gibt den SQLSTATE-Code des Fehlers zurück. Der SQLSTATE-Code identifiziert den Typ des aufgetretenen Fehlers. Dieser kann von Anwendungen ausgewertet werden, um entsprechende Operationen auszuführen (beispielsweise Fehlerbehandlungsroutinen), als Reaktion auf einen bestimmten Datenbankfehler. dieses Feld kann nicht lokalisiert werden und ist immer verfügbar.
PGSQL_DIAG_MESSAGE_PRIMARY (integer): Wird an die Funktion pg_result_error_field() übergeben. Dies ist die primäre, für Menschen lesbare Fehlermeldung (normalerweise in einer Zeile) und ist immer verfügbar.
PGSQL_DIAG_MESSAGE_DETAIL (integer): Wird an die Funktion pg_result_error_field() übergeben. Detail: eine optionale untergeordnete Fehlermeldung, in der das Problem genauer beschrieben wird. Diese Meldung kann mehrere Zeilen lang sein.
PGSQL_DIAG_MESSAGE_HINT (integer): Wird an die Funktion pg_result_error_field() übergeben. Hint: ein optionaler Hinweis, wie mit dem Problem umzugehen ist. Dies wurde eingeführt, um (möglicherweise unpassende) Lösungen zur Verfügung zu stellen, anstatt harte Fakten, wie bei Details. Diese Meldung kann mehrere Zeilen lang sein.
PGSQL_DIAG_STATEMENT_POSITION (integer): Wird an die Funktion pg_result_error_field() übergeben. Dies ist ein String, der eine dezimale Integerzahl enthält, die die Cursorposition des originalen SQL-Strings angibt, an der ein Fehler auftrat. Das erste Zeichen hat die Position 1 und zur Bestimmung der Positionen werden Zeichen zugrundegelegt und nicht Bytes.
PGSQL_DIAG_INTERNAL_POSITION (integer): Wird an die Funktion pg_result_error_field() übergeben. Per Definition ist das dasselbe wie das Feld PG_DIAG_STATEMENT_POSITION, es wird aber benutzt, wenn die Cursorposition auf ein intern generiertes Kommando verweist und nicht auf eines, das vom Benutzer eingegeben wurde. Das Feld PG_DIAG_INTERNAL_QUERY wird immer gesetzt, wenn dieses Feld gesetzt ist.
PGSQL_DIAG_INTERNAL_QUERY (integer): Wird an die Funktion pg_result_error_field() übergeben. Dies ist der Text eines fehlgeschlagenen, intern generierten Kommandos. Das kann beispielsweise eine SQL-Abfrage sein, die von einer PL/pgSQL-Funktion gesendet wurde.
PGSQL_DIAG_CONTEXT (integer): Wird an die Funktion pg_result_error_field() übergeben. Dies gibt einen Hinweis auf den Kontext, in dem ein Fehler auftrat. Gegenwärtig sind Zurückverfolgungen des Aufrufstacks von Funktionen aktivierter prozeduraler Sprachen darin enthalten, sowie intern generierte Abfragen. Die Ablaufverfolgung enthält einen Eintrag pro Zeile, die neuesten Einträge zuerst.
PGSQL_DIAG_SOURCE_FILE (integer): Wird an die Funktion pg_result_error_field() übergeben. Dies ist der Name der Datei im PostgreSQL Quellcode, bei der der Fehler gemeldet wurde.
PGSQL_DIAG_SOURCE_LINE (integer): Wird an die Funktion pg_result_error_field() übergeben. Die Zeilennummer in der Datei im PostgreSQL Quellcode, bei der der Fehler gemeldet wurde.
PGSQL_DIAG_SOURCE_FUNCTION (integer): Wird an die Funktion pg_result_error_field() übergeben. Der Name der Funktion im PostgreSQl-Quellcode, bei der der Fehler gemeldet wurde.
PGSQL_ERRORS_TERSE (integer): Wird an die Funktion pg_set_error_verbosity() übergeben. Damit wird festgelegt, dass Fehlermeldungen die Felder severity, primary text und position enthalten. Normalerweise passt das alles in eine Zeile.
PGSQL_ERRORS_DEFAULT (integer): Wird an die Funktion pg_set_error_verbosity() übergeben. Die Standardeinstellung gibt Meldungen mit den oben beschriebenen Inhalten zurück, zuzüglich aller Details, Hinweise und Kontext-Informationen. (Dies kann mehrere Zeilen umfassen.)
PGSQL_ERRORS_VERBOSE (integer): Wird an die Funktion pg_set_error_verbosity() übergeben. In diesem Modus werden alle verfügbaren Felder zurückgegeben.
PGSQL_STATUS_LONG (integer): Wird an die Funktion pg_result_status() übergeben. Zeigt an, dass ein numerischer Ergebniscode gewünscht ist.
PGSQL_STATUS_STRING (integer): Wird an die Funktion pg_result_status() übergeben. Zeigt an, dass eine textuelles Ergebnis gewünscht ist.
PGSQL_CONV_IGNORE_DEFAULT (integer): Wird an die Funktion pg_convert() übergeben. Während der Konversion werden Standardwerte in der Tabelle ignoriert.
PGSQL_CONV_FORCE_NULL (integer): Wird an die Funktion pg_convert() übergeben. Anstelle eines leeren Strings string wird der SQL Nullwert NULL benutzt.
PGSQL_CONV_IGNORE_DEFAULT (integer): Wird an die Funktion pg_convert() übergeben. Die Konversion von NULL in SQL NOT NULL-Spalten wird ignoriert.

Anmerkungen

Anmerkung: Nicht alle Funktionen sind in allen Versionen verfügbar. Es hängt davon ab, welche libpq Version (das PostgreSQL C Client Interface) auf Ihrem Rechner verfügbar ist und wie libpq kompiliert wurde. Falls eine Funktion nicht verfügbar ist, liegt es daran, dass libpq die nötigen Routinen nicht unterstützt, die die Funktion braucht.

Anmerkung: Die meisten PostgreSQL Funktionen nehmen den Parameter connection als ersten optionalen Parameter entgegen. Falls er nicht angegeben wurde, wird die zuletzt geöffnete Verbindung benutzt. Wenn keine geöffnete Verbindung existiert, geben diese Funktionen FALSE zurück.

Anmerkung: PostgreSQL wandelt automatisch alle Bezeichner in Kleinbuchstaben um (beispielsweise Tabellennamen oder Spaltennamen) und zwar sowohl bei der Erzeugung der Objekte als auch in Abfragen. Um Namen in Gross- und Kleinschreibung oder in Grossbuchstaben zu erzwingen, müssen diese in Anführungszeichen ("") eingeschlossen werden.

Anmerkung: PostgreSQL stellt keine speziellen Kommandos zur Verfügung, um Informationen über ein Datenbank-Schema (z. B. alle Tabellen in der aktuellen Datenbank) zu erhalten. Stattdessen gibt es ab der Version 7.4 und höher ein Standard-Schma, das information_schema, in dem alle notwendigen Informationen in System-Views enthalten sind und die einfach abzufragen sind. Ausführliche Informationen darüber gibt es in der » PostgreSQL Documentation.

Beispiele

Dieses einfache Beispiel zeigt den Verbindungsaufbau, die Ausführung einer einfachen Abfrage, die Ausgabe der Abfrageergebnisse und, wie eine Verbindung wieder geschlossen wird.

Beispiel 1581. PostgreSQL extension overview example


<?php

// Verbindungsaufbau und Auswahl der Datenbank

$dbconn = pg_connect("host=localhost dbname=publishing user=www password=foo")

    or die('Verbindungsaufbau fehlgeschlagen: ' . pg_last_error());



// Eine SQL-Abfrge ausführen

$query = 'SELECT * FROM authors';

$result = pg_query($query) or die('Abfrage fehlgeschlagen: ' . pg_last_error());



// Ergebnisse in HTML ausgeben

echo "<table>\n";

while ($line = pg_fetch_array($result, null, PGSQL_ASSOC)) {

    echo "\t<tr>\n";

    foreach ($line as $col_value) {

        echo "\t\t<td>$col_value</td>\n";

    }

    echo "\t</tr>\n";

}

echo "</table>\n";



// Speicher freigeben

pg_free_result($result);



// Verbindung schliessen

pg_close($dbconn);

?>

Inhaltsverzeichnis

pg_affected_rows — Gibt die Anzahl betroffener Datensätze (Tupel) zurück
pg_cancel_query — Löscht eine asynchrone Abfrage
pg_client_encoding — Gibt die Kodierung des Clients zurück
pg_close — Schließt eine PostgreSQL-Verbindung
pg_connect — Öffnet eine PostgreSQL Verbindung
pg_connection_busy — Gibt den Status der Verbindung zurück (busy/not busy)
pg_connection_reset — Setzt die Verbindung zurück und verbindet neu
pg_connection_status — Gibt den Verbindungsstatus zurück
pg_convert — Konvertiert die Werte eines assoziativen Arrays in passende Werte für SQL-Kommandos.
pg_copy_from — Fügt Datensätze aus einem Array in eine Tabelle ein
pg_copy_to — Kopiert eine Tabelle in ein Array
pg_dbname — Gibt den Namen der Datenbank zurück
pg_delete — Löscht Datensätze
pg_end_copy — Synchronisation mit dem PostgreSQL-Server
pg_escape_bytea — Maskiert Binärdaten zum Einfügen in ein Feld vom Typ bytea
pg_escape_string — Maskiert einen String zum Einfügen in Felder mit text/char Datentypen
pg_execute — Fordert den Datenankserver auf, eine vorbereitete Anfrage mit den angegebenen Parametern auszuführen und wartet auf das Ergebnis.
pg_fetch_all_columns — Gibt alle Werte einer bestimmten Spalte eines Abfrageergebnisses in einem Array zurück
pg_fetch_all — Gibt alle Zeilen eines Abfrageergebnisses als Array zurück.
pg_fetch_array — Holt eine Zeile als Array
pg_fetch_assoc — Holt eine Zeile als assoziatives Array
pg_fetch_object — Holt einen Datensatz als Objekt
pg_fetch_result — Liefert Werte aus einer Ergebnismenge
pg_fetch_row — Holt einen Datensatz als numerisches Array
pg_field_is_null — Prüft, ob ein Feld einen SQL NULL-Wert enthält
pg_field_name — Gibt den Namen eines Feldes zurück
pg_field_num — Gibt die Feldnummer des angegebenen Feldes zurück
pg_field_prtlen — Gibt die Länge des Feldes zurück
pg_field_size — Gibt den belegten Speicher für ein Feld zurück
pg_field_table — Returns the name or oid of the tables field
pg_field_type_oid — Gibt die ID des PostgreSQL-Datentyps (OID) eines Feldes zurück
pg_field_type — Gibt den Datentyp eines Feldes zurück
pg_free_result — Gibt den durch Ergebnisse belegten Speicher frei
pg_get_notify — Gibt eine SQL NOTIFY-Nachricht zurück
pg_get_pid — Prüft die Datenbankverbindung
pg_get_result — Gibt asynchrone Abfrageergebnisse zurück
pg_host — Gibt den Namen des Host zurück, zu dem verbunden wurde
pg_insert — Überträgt Werte aus einem Array in eine Tabelle
pg_last_error — Gibt die letzte Fehlermeldung einer Verbindung zurück
pg_last_notice — Gibt die letzte NOTICE-Meldung des PostgreSQL-Servers zurück
pg_last_oid — Gibt den Objektbezeichner (OID) des zuletzt eingefügten Datensatzes zurück
pg_lo_close — Schließt ein Large Object
pg_lo_create — Erzeugt ein Large Object
pg_lo_export — Exportiert ein Large Object in eine Datei
pg_lo_import — Importiert ein Large Object aus einer Datei
pg_lo_open — Öffnet ein Large Object
pg_lo_read_all — Liest ein Large Object vollständig und reicht es direkt an den Browser weiter
pg_lo_read — Liest ein Large Object
pg_lo_seek — Setzt die Lese- oder Schreibposition in einem Large Object
pg_lo_tell — Gibt die aktuelle Lese- oder Schreibposition in einem Large Object zurück
pg_lo_unlink — Löscht ein Large Object
pg_lo_write — Schreibt in ein Large Object
pg_meta_data — Gibt Metadaten einer Tabelle als Array zurück
pg_num_fields — Gibt die Anzahl der Felder in einem Abfrageergebnis zurück
pg_num_rows — Gibt die Anzahl der Zeilen in einem Abfrageergebnis zurück
pg_options — Gibt die Verbindungsoptionen der aktuellen Verbindung zurück
pg_parameter_status — Gibt den Wert einer aktuellen Server-Einstellung zurück.
pg_pconnect — Öffnet eine persistente PostgreSQL-Verbindung
pg_ping — Prüft die Datenbankverbindung
pg_port — Gibt die Portnummer zurück, über die die Verbindung aufgebaut wurde
pg_prepare — Sendet eine Aufforderung an den Server, eine vorbereitete Anfrage mit den übergebenen Parametern zu erzeugen und wartet auf ihre Beendigung.
pg_put_line — Sendet eine NULL-terminierte Zeichenkette zum PostgreSQL-Server
pg_query_params — Sendet ein Kommando zum Server und wartet seine Ausführung ab. Getrennt vom SQL-Kommando können dabei Parameter übergeben werden.
pg_query — Führt eine Abfrage aus
pg_result_error_field — Gibt den Inhalt eines bestimmtes Feldes zu einer Fehlermeldung zurück.
pg_result_error — Gibt die mit der Ergebniskennung verknüpfte Fehlermeldung zurück
pg_result_seek — Setzt den internen Datensatzzeiger auf die angegebene Position in einem Abfrageergebnis
pg_result_status — Gibt den Status eines Abfrageergebnisses zurück
pg_select — Wählt Datensätze aus
pg_send_execute — Sendet eine Aufforderung an den Server, eine vorbereitete Abfrage mit den übergebenen Parametern auszuführen, ohne auf die Ergebnisse zu warten.
pg_send_prepare — Sendet eine Aufforderung an den Server, eine vorbereitete Abfrage mit den übergebenen Parametern zu erzeugen, ohne auf ihre Beendigung zu warten.
pg_send_query_params — Sendet ein Kommando und separate Parameter zum Server, ohne auf die Rückgabe der Ergebnisse zu warten.
pg_send_query — Sendet eine asynchrone Abfrage
pg_set_client_encoding — Setzt die Kodierung des Clients
pg_set_error_verbosity — Bestimmt den Detaillierungsgrad von Fehlermeldungen, die von pg_last_error() und pg_result_error() zurückgegeben werden.
pg_trace — Ermöglicht die Ablaufverfolgung einer Verbindung
pg_transaction_status — Gibt den aktuellen Transaktionsstatus des Servers zurück.
pg_tty — Gibt den TTY Namen für die Verbindung zurück
pg_unescape_bytea — Entfernt Maskierungen für den Typ bytea
pg_untrace — Beendet die Ablaufverfolgung einer PostgreSQL-Verbindung
pg_update — Aktualisiert eine Tabelle
pg_version — Gibt ein Array zurück, das die Versionen von Client, Protokoll und Server zurückgibt (falls verfügbar)

pg_affected_rows

sql_regcase

[edit] Last updated: Mon, 01 Nov 2010

add a note User Contributed Notes PostgreSQL Funktionen

cc[plus]php[at]c2se[dot]com 25-Mar-2009 09:12


Parsing a postgres array can be a tricky problem, he's my take on this, it handles multi-dimensional arrays plus escaping using a nasty regexp to determine the limits of each data-item.





<?php


function pg_array_parse( $text, &$output, $limit = false, $offset = 1 )


{


  if( false === $limit )


  {


    $limit = strlen( $text )-1;


    $output = array();


  }


  if( '{}' != $text )


    do


    {


      if( '{' != $text{$offset} )


      {


        preg_match( "/(\\{?\"([^\"\\\\]|\\\\.)*\"|[^,{}]+)+([,}]+)/", $text, $match, 0, $offset );


        $offset += strlen( $match[0] );


        $output[] = ( '"' != $match[1]{0} ? $match[1] : stripcslashes( substr( $match[1], 1, -1 ) ) );


        if( '},' == $match[3] ) return $offset;


      }


      else  $offset = pg_array_parse( $text, $output[], $limit, $offset+1 );


    }


    while( $limit > $offset );


  return $output;


}


?>

rainer at hihn dot org 08-Dec-2008 01:07


<?php

function pg_export_table_content() {

    /*

      * this function exports all contents of all tables in the file import.sql

      * $pg-> = my postgres db class

      */

    $tables = array();

    $mytables = array();



    $all_tables = $pg->query("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' and table_type = 'BASE TABLE';");

    while($row = $pg->fetch_row($all_tables)) {

        $tables[] = $row->table_name;

    }



    $esc[] = "value";

    $esc[] = "time";

    $esc[] = "order";

    $esc[] = "comment";

    $esc[] = "group";

    $esc[] = "time";

    $esc[] = "name";

    $esc[] = "alter";

    $esc[] = "user";

    

    foreach($tables as $v1) {

        $myqry = "select * from \"".$v1."\"";

        $myres = $pg->query($myqry);

        while($myrow = $pg->fetch_assoc($myres)) {

            $mytables[$v1][] = $myrow;

        }

    }

    

    $handle = fopen("./import.sql", "w+");

    

    foreach($mytables as $k1 => $v1) {

        foreach($v1 as $k2 => $v2) {

            foreach($v2 as $k3 => $v3) {    

                if(in_array($k3, $esc)) {

                    $mycols[] = "\"".$k3."\"";

                }

                else {

                    $mycols[] = $k3;

                }

                

                $col_qry = "select column_name, data_type from information_schema.columns where table_name = '".$k1."'";

                $col_res = $pg->query($col_qry);

                while($col_row = $pg->fetch_assoc($col_res)) {

                    $mydatatypes[$col_row["column_name"]] = $col_row["data_type"];

                }



                if(($mydatatypes[$k3] == "integer") || ($mydatatypes[$k3] == "bigint") || ($mydatatypes[$k3] == "smallint")) {

                    if(empty($v3)) {

                        $myval[] = "NULL";

                    }

                    else {

                        $myval[] = $v3;

                    }

                }

                else {

                    $myval[] = "'".$v3."'";

                }

            }

            $myquery = "insert into ".$k1."(".implode(",", $mycols).") VALUES (".implode(",", $myval).");";

            unset($myval,$mycols);

            fwrite($handle, $myquery."\n");

        }

    }

    

    fclose($handle);

}

?>

Demeter dot Tamas at stud dot u-szeged dot hu 28-Jul-2008 01:40


There is no need to parse a postgres array. The stored procedures should never return an array. Use SETOF instead.

veggivore at yahoo dot com 22-Feb-2008 03:39


Parse a PostgreSQL array of any dimension to a PHP array.



Works great if you absolutely trust the data ;-)



<?php

function pg_array_parse($array, $asText = true) {

    $s = $array;

    if ($asText) {

        $s = str_replace("{", "array('", $s);

        $s = str_replace("}", "')", $s);    

        $s = str_replace(",", "','", $s);    

    } else {

        $s = str_replace("{", "array(", $s);

        $s = str_replace("}", ")", $s);

    }

    $s = "\$retval = $s;";

    eval($s);

    return $retval;

}

?>

12-Mar-2007 09:28


Quick and dirty emulation of the mysql_select_db () function for Postgres:



<?php



function pg_select_db ($dbName)

{

    $query = '\connect '.pg_escape_string ($dbName);

    if ($result = pg_query ($query))

        return (true);

    else

        return (false);

}

?>



Obviously not a great example, but it at least demonstrates how to implement mysql_select_db functionality when using Postgres.  Or you could always use schemas :)

16-Nov-2006 04:30


Chris KL: Will parse well {"\\"}? The second " will be treat as escaped while it shoudn't...

20-Oct-2006 10:10


Lots of advice on stored procedures didn't work for me.  This did:



<?php

$response = pg_query( $connection, "BEGIN; DECLARE s CURSOR FOR SELECT get_consumer('harry'); FETCH ALL IN s; END;" );

?>



..where harry looks like this:



CREATE OR REPLACE FUNCTION get_consumer( varchar )

RETURNS refcursor

AS '

DECLARE

  _name          ALIAS FOR $1;

  r              refcursor;

BEGIN

  OPEN r FOR SELECT name FROM consumer

  WHERE

    consumer.name = _name

  ;

  RETURN r;

END

' LANGUAGE 'plpgsql';

Chris KL 10-Nov-2005 05:17


Here is a better array parser for PHP.  It will work with 1-d arrays only.  Unlike the example below it will work in all cases.



    /**

     * Change a db array into a PHP array

     * @param $arr String representing the DB array

     * @return A PHP array

     */

    function phpArray($dbarr) {

        // Take off the first and last characters (the braces)

        $arr = substr($dbarr, 1, strlen($dbarr) - 2);



        // Pick out array entries by carefully parsing.  This is necessary in order

        // to cope with double quotes and commas, etc.

        $elements = array();

        $i = $j = 0;        

        $in_quotes = false;

        while ($i < strlen($arr)) {

            // If current char is a double quote and it's not escaped, then

            // enter quoted bit

            $char = substr($arr, $i, 1);

            if ($char == '"' && ($i == 0 || substr($arr, $i - 1, 1) != '\\')) 

                $in_quotes = !$in_quotes;

            elseif ($char == ',' && !$in_quotes) {

                // Add text so far to the array

                $elements[] = substr($arr, $j, $i - $j);

                $j = $i + 1;

            }

            $i++;

        }

        // Add final text to the array

        $elements[] = substr($arr, $j);



        // Do one further loop over the elements array to remote double quoting

        // and escaping of double quotes and backslashes

        for ($i = 0; $i < sizeof($elements); $i++) {

            $v = $elements[$i];

            if (strpos($v, '"') === 0) {

                $v = substr($v, 1, strlen($v) - 2);

                $v = str_replace('\\"', '"', $v);

                $v = str_replace('\\\\', '\\', $v);

                $elements[$i] = $v;

            }

        }



        return $elements;

    }

1413 at blargh dot com 11-Oct-2005 05:09


Here is some quick and dirty code to convert Postgres-returned arrays into PHP arrays.  There's probably a billion bugs, but since I'm only dealing with variable-depth-and-length arrays of integers, it works for my needs.



Most notably, any data that might have commas in it won't work right...



<?php

function PGArrayToPHPArray($pgArray)

{

  $ret = array();

  $stack = array(&$ret);

  $pgArray = substr($pgArray, 1, -1);

  $pgElements = explode(",", $pgArray);

  

  ArrayDump($pgElements);



  foreach($pgElements as $elem)

    {

      if(substr($elem,-1) == "}")

        {

          $elem = substr($elem,0,-1);

          $newSub = array();

          while(substr($elem,0,1) != "{")

            {

              $newSub[] = $elem;

              $elem = array_pop($ret);

            }

          $newSub[] = substr($elem,1);

          $ret[] = array_reverse($newSub);

        }

      else

        $ret[] = $elem;

    }

  return $ret;

}

?>

anis_wn at gawab dot com 05-Jun-2005 09:45


Setting up PostgreSQL for higher security PHP connection.



Case:

We want to connect to PostgreSQL database using username and password supplied by webuser at login time.



Fact (Linux):

Apache (perhaps other servers, too) running the server as (default to) apache user account. So if you connect to PostgreSQL using default user, apache will be assingned for it. If you hard code the user and password in your PHP script, you'll loose security restriction from PostgreSQL.



Solution:

(You are assumed to have enough privilege to do these things, though)

1. Edit pg_hba.conf to have the line like the one below

    host    db_Name    [web_server_ip_address] [ip_address_mask] md5

2. Add to you script the login page that submits username and password.

3. Use those information to login to PostgreSQL like these...

<?

    $conn = "host=$DBHost port=$DBPort dbname=$DBName ".

            "user='{$_POST['dbUsername']}' password='{$_POST['dbPassword']}'";

    $db = pg_connect ($conn);

[your other codes go here...]

?>

4. You must add users in PostgreSQL properly.

5. For your convenience, you can store the username and password to $_SESSION variable.



Good luck.

Anis WN

WillowCatkin at hotmail dot com 21-May-2005 06:43


There is an example:

<?php

/*

 * Define PostgreSQL database server connect parameters.

 */

define('PGHOST','10.0.0.218');

define('PGPORT',5432);

define('PGDATABASE','example');

define('PGUSER', 'root');

define('PGPASSWORD', 'nopass');

define('PGCLIENTENCODING','UNICODE');

define('ERROR_ON_CONNECT_FAILED','Sorry, can not connect the database server now!');



/*

 * Merge connect string and connect db server with default parameters.

 */

pg_pconnect('host=' . PGHOST . ' port=' . PGPORT . ' dbname=' . PGDATABASE . ' user=' . PGUSER . ' password=' . PGPASSWORD);



/*

 * generate sql statements to call db-server-side stored procedure(or function) 

 * @parameter    string    $proc        stored procedure name.

 * @parameter    array    $paras        parameters, 2 dimensions array.

 * @return        string    $sql = 'select "proc"(para1,para2,para3);'

 * @example    pg_prepare('userExists',

 *                            array(

 *                                array('userName','chin','string'),

 *                                array('userId','7777','numeric')

 *                            )

 * )

 */

function pg_prepare($proc, $paras)

{

    $sql = 'select "' . $proc . '"(';

    $sql .= $paras[0][2] == 'numeric' ? $paras[0][1] : "'" . str_replace("'","''",$paras[0][1]) . "'";

    $len = count($paras);

    for ($i = 1; $i < $len; $i ++)

    {

        $sql .= ',';

        $sql .= $paras[$i][2] == 'numeric' ? $paras[$i][1] : "'" . str_replace("'","''",$paras[$i][1]) . "'";

    }

    $sql .= ');';

    return $sql;

}

?>

adaml at mimuw edu pl 02-Oct-2004 06:07


Yes, PHP does support stored procedures

You have to add "select" before the name of the 

procedure, just like that:



$result = pg_querry($conn, "SELECT procedure_x($aa)");



if a procedure returns a cursor you do something like that:



$result = pg_query($conn, "SELECT procedure_x('rcursor'); FETCH ALL IN rcursor");

74012 dot 2773 at compuserve dot com 01-Jul-2004 09:35


for just a list of tables, this works with postgresql-7.2.1:



function pg_list_tables($db) {

    $sql = "select relname from pg_stat_user_tables order by relname;";

    return pg_query($db, $sql);

}

abondi at ijk dot it 26-May-2004 05:11


I've found another function to mimic the following mysql list tables function (http://www.php.net/manual/en/function.mysql-list-tables.php) that's more useful for my target:



function pg_list_tables() {

      $sql = "SELECT a.relname AS Name

          FROM pg_class a, pg_user b

          WHERE ( relkind = 'r') and relname !~ '^pg_' AND relname !~ '^sql_'

          AND relname !~ '^xin[vx][0-9]+' AND b.usesysid = a.relowner

          AND NOT (EXISTS (SELECT viewname FROM pg_views WHERE viewname=a.relname));";

      return(pg_query($conn, $sql));

}

daniel at bichara dot com dot br 30-Dec-2002 05:04


Running RedHat Linux and Apache with suexec enabled you must include pgsql.so on each .php file using dl("pgsql.so") and remove "extension=pgsql.so" from php.ini, otherwise Apache (httpd) will not start.

anonymous at unknown dot com 29-Nov-2002 09:50


I just wanted to add to my previous post I've got the system up and running.

Environment: Windows XP, Apache 1.3.23, Php 4.3 RC2, PostGreSQL beta4 native windows build



Installation was fairly easy: 

1. read the readme.txt

2. edit the setenv.bat as described in readme

3. run 'initdb'

    all execs are in /bin

    help is accessed like <command> --help

4. Start the psql deamon - you may want to create a batch file like

    'D:\postgres_beta4\bin\postmaster -h localhost -D D:/postgres_beta4/data'



    --deamon should be up and running now--



You can login into a shell from a console like

    'psql -h localhost -d <username>'



You must load the postgresql extension by editing the php.ini and restarting apache in order to access psql with php.



And one final not: when running

    $dbconn = pg_connect ("host=localhost port=5432 dbname=$dbname user=$user");

remember that $user and or $dbname is CASESENSITIVE.



Oh yeah, I created the data dir manually - don't know whether that was necessary



Grtz Vargo

mystran at wasteland dot pp dot htv dot fi 03-Feb-2002 07:46


Nice to know fact that I didn't find documented here.





PHP will return values of PostgreSQL boolean datatype as single character strings "t" and "f", not PHP true and false.





[Editor's Note]


't' or 'f' is valid boolean expression for PostgreSQL.





All values from PostgreSQL are strings, since PostgreSQL integer, float may be much larger than PHP's native int, double can handle. PostgreSQL array is not supported.

saberit at home dot com 15-Sep-2001 02:11


I tried compiling PHP from source with PostgreSQL support (./configure --with-pgsql=/usr/local/pgsql) and ran into a bunch of problems when trying to 'make'. The problem was that some of the PostgreSQL headers were not installed by default when I installed PostgreSQL from source. When installing PostgreSQL make sure you 'make install-all-headers' after you 'make install'.

hubert at hubertmuller dot com 09-Jul-2001 04:36


The best way to find the separated list of tables, sequences, keys etc is:





SELECT relname FROM pg_class WHERE relkind='<value>' AND relname !~ '^pg_';





<value> takes:


i for keys,


r for relations,


S for sequences





Note that all tables names that begins with 'pg_' are PostgreSQL internal tables (this explain why I use AND relname !~ '^pg_' condition).

passion at monkey dot org 27-Jun-2001 06:53


I've tried to mimic the following mysql database connection functions for postgres. 


http://www.php.net/manual/en/function.mysql-list-dbs.php


http://www.php.net/manual/en/function.mysql-list-tables.php





These are assuming that you're passing in $link as the result from pg_connect:





function pg_list_dbs($link)


{  


    $sql = 'SELECT datname FROM pg_database';


    return (pg_query($link, $sql));


}  





function pg_list_tables($link)


{  


    $sql = "SELECT relname FROM pg_class WHERE relname !~ '^pg_'";


    return (pg_query($link, $sql));


}

!spamcraig at ahdore dot com 15-Apr-2001 01:11


If you want to extract data from select statements, you need to store the result index, and then apply pg_result to that value. Basically, do this





$resultIdx = pg_query ($database, "select * from tablename");


$mySelect = pg_fetch_result($resultIdx, 0, 0);  // gets column 0 of tuple 0


echo("My select: [".$mySelect."]");





I'm new to php and had to do some fiddling around to work this out. It's reasonably elementary, but not demonstrated by the examples on these pages. Hopefully it will come in useful to someone else.

bleach at chek dot com 02-Mar-2000 12:36


If you want to see all the objects in a database, you can find that information in the pg_class table. <BR>


SELECT * FROM pg_class;<BR>


Now this is going to be kind of long and complex, to see how psql command handles the \d and other things. use the syntax.  psql -E <Database>, ie psql -E mydatabase <BR>


What this will do is show the SQL command used for everything. So when you type a \d or something, it shows the SQL query used for the result.

add a note