PostgreSQL - Kurzanleitung

PostgreSQL ist ein leistungsstarkes, objektrelationales Open-Source-Datenbanksystem. Es verfügt über mehr als 15 Jahre aktive Entwicklungsphase und eine bewährte Architektur, die ihm einen guten Ruf für Zuverlässigkeit, Datenintegrität und Korrektheit eingebracht hat.

Dieses Tutorial gibt Ihnen einen schnellen Einstieg in PostgreSQL und macht Sie mit der PostgreSQL-Programmierung vertraut.

Was ist PostgreSQL?

PostgreSQL (ausgesprochen als post-gress-Q-L) ist ein relationales Open-Source-Datenbankmanagementsystem (DBMS), das von einem weltweiten Team von Freiwilligen entwickelt wurde. PostgreSQL wird von keinem Unternehmen oder einer anderen privaten Einrichtung kontrolliert und der Quellcode ist kostenlos verfügbar.

Eine kurze Geschichte von PostgreSQL

PostgreSQL, ursprünglich Postgres genannt, wurde an der UCB von einem Informatikprofessor namens Michael Stonebraker erstellt. Stonebraker startete Postgres 1986 als Folgeprojekt zu seinem Vorgänger Ingres, der jetzt Computer Associates gehört.

  • 1977-1985 - Ein Projekt namens INGRES wurde entwickelt.

    • Proof-of-Concept für relationale Datenbanken

    • Gründung der Firma Ingres im Jahr 1980

    • 1994 von Computer Associates gekauft

  • 1986-1994 - POSTGRES

    • Entwicklung der Konzepte in INGRES mit Schwerpunkt auf Objektorientierung und Abfragesprache - Quel

    • Die Codebasis von INGRES wurde nicht als Basis für POSTGRES verwendet

    • Kommerzialisiert als Illustra (gekauft von Informix, gekauft von IBM)

  • 1994-1995 - Postgres95

    • Unterstützung für SQL wurde 1994 hinzugefügt

    • Veröffentlicht als Postgres95 im Jahr 1995

    • 1996 als PostgreSQL 6.0 erneut veröffentlicht

    • Aufbau des PostgreSQL Global Development Teams

Hauptmerkmale von PostgreSQL

PostgreSQL läuft unter allen gängigen Betriebssystemen, einschließlich Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64) und Windows. Es unterstützt Text, Bilder, Sounds und Videos und enthält Programmierschnittstellen für C / C ++, Java, Perl, Python, Ruby, Tcl und Open Database Connectivity (ODBC).

PostgreSQL unterstützt einen großen Teil des SQL-Standards und bietet viele moderne Funktionen, darunter die folgenden:

  • Komplexe SQL-Abfragen
  • SQL-Unterauswahl
  • Fremde Schlüssel
  • Trigger
  • Views
  • Transactions
  • Multiversion Concurrency Control (MVCC)
  • Streaming-Replikation (ab 9.0)
  • Hot Standby (ab 9.0)

Sie können die offizielle Dokumentation von PostgreSQL überprüfen, um die oben genannten Funktionen zu verstehen. PostgreSQL kann vom Benutzer auf viele Arten erweitert werden. Zum Beispiel durch Hinzufügen neuer -

  • Datentypen
  • Functions
  • Operators
  • Aggregierte Funktionen
  • Indexmethoden

Unterstützung für prozedurale Sprachen

PostgreSQL unterstützt vier Standard-Verfahrenssprachen, mit denen die Benutzer ihren eigenen Code in einer der Sprachen schreiben können und der vom PostgreSQL-Datenbankserver ausgeführt werden kann. Diese prozeduralen Sprachen sind - PL / pgSQL, PL / Tcl, PL / Perl und PL / Python. Außerdem werden andere nicht standardmäßige prozedurale Sprachen wie PL / PHP, PL / V8, PL / Ruby, PL / Java usw. unterstützt.

Um die Grundlagen von PostgreSQL zu verstehen, installieren wir zunächst PostgreSQL. In diesem Kapitel wird die Installation von PostgreSQL auf Linux-, Windows- und Mac OS-Plattformen erläutert.

PostgreSQL unter Linux / Unix installieren

Befolgen Sie die angegebenen Schritte, um PostgreSQL auf Ihrem Linux-Computer zu installieren. Stellen Sie sicher, dass Sie als angemeldet sindroot bevor Sie mit der Installation fortfahren.

  • Wählen Sie die gewünschte Versionsnummer von PostgreSQL und so genau wie möglich die gewünschte Plattform aus EnterpriseDB

  • Ich habe heruntergeladen postgresql-9.2.4-1-linux-x64.runfür meine 64 Bit CentOS-6 Maschine. Führen wir es nun wie folgt aus:

[root@host]# chmod +x postgresql-9.2.4-1-linux-x64.run
[root@host]# ./postgresql-9.2.4-1-linux-x64.run
------------------------------------------------------------------------
Welcome to the PostgreSQL Setup Wizard.

------------------------------------------------------------------------
Please specify the directory where PostgreSQL will be installed.

Installation Directory [/opt/PostgreSQL/9.2]:
  • Sobald Sie das Installationsprogramm starten, werden Ihnen einige grundlegende Fragen gestellt, z. B. der Speicherort der Installation, das Kennwort des Benutzers, der die Datenbank verwendet, die Portnummer usw. Behalten Sie also alle Standardwerte bei, mit Ausnahme des Kennworts, das Sie als Kennwort angeben können nach Ihrer Wahl. Es installiert PostgreSQL auf Ihrem Linux-Computer und zeigt die folgende Meldung an:

Please wait while Setup installs PostgreSQL on your computer.

 Installing
 0% ______________ 50% ______________ 100%
 #########################################

-----------------------------------------------------------------------
Setup has finished installing PostgreSQL on your computer.
  • Führen Sie die folgenden Schritte nach der Installation aus, um Ihre Datenbank zu erstellen:

[root@host]# su - postgres
Password:
bash-4.1$ createdb testdb bash-4.1$ psql testdb
psql (8.4.13, server 9.2.4)

test=#
  • Sie können den Postgres-Server starten / neu starten, falls er nicht mit dem folgenden Befehl ausgeführt wird:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]
  • Wenn Ihre Installation korrekt war, wird die PotsgreSQL-Eingabeaufforderung angezeigt test=# wie oben gezeigt.

PostgreSQL unter Windows installieren

Befolgen Sie die angegebenen Schritte, um PostgreSQL auf Ihrem Windows-Computer zu installieren. Stellen Sie sicher, dass Sie Antivirus von Drittanbietern während der Installation deaktiviert haben.

  • Wählen Sie die gewünschte Versionsnummer von PostgreSQL und so genau wie möglich die gewünschte Plattform aus EnterpriseDB

  • Ich habe postgresql-9.2.4-1-windows.exe für meinen Windows-PC heruntergeladen, der im 32-Bit-Modus ausgeführt wird. Lassen Sie uns also ausführen postgresql-9.2.4-1-windows.exeals Administrator zur Installation von PostgreSQL. Wählen Sie den Speicherort aus, an dem Sie es installieren möchten. Standardmäßig wird es im Ordner "Programme" installiert.

  • Der nächste Schritt des Installationsprozesses besteht darin, das Verzeichnis auszuwählen, in dem Ihre Daten gespeichert werden sollen. Standardmäßig wird es im Verzeichnis "data" gespeichert.

  • Als Nächstes werden Sie beim Setup nach dem Kennwort gefragt, damit Sie Ihr Lieblingskennwort verwenden können.

  • Der nächste Schritt; Behalten Sie den Port als Standard bei.

  • Als ich im nächsten Schritt nach "Gebietsschema" gefragt wurde, wählte ich "Englisch, USA".

  • Die Installation von PostgreSQL auf Ihrem System dauert eine Weile. Nach Abschluss des Installationsvorgangs wird der folgende Bildschirm angezeigt. Deaktivieren Sie das Kontrollkästchen und klicken Sie auf die Schaltfläche Fertig stellen.

Nach Abschluss des Installationsvorgangs können Sie über Ihr Programmmenü unter PostgreSQL 9.2 auf die Shell pgAdmin III, StackBuilder und PostgreSQL zugreifen.

PostgreSQL auf einem Mac installieren

Befolgen Sie die angegebenen Schritte, um PostgreSQL auf Ihrem Mac-Computer zu installieren. Stellen Sie sicher, dass Sie als angemeldet sindadministrator bevor Sie mit der Installation fortfahren.

  • Wählen Sie die neueste Versionsnummer von PostgreSQL für Mac OS aus, die bei EnterpriseDB verfügbar ist

  • Ich habe heruntergeladen postgresql-9.2.4-1-osx.dmgfür mein Mac OS mit OS X Version 10.8.3. Lassen Sie uns nun das dmg-Image im Finder öffnen und einfach darauf doppelklicken, um das PostgreSQL-Installationsprogramm im folgenden Fenster zu erhalten:

  • Klicken Sie anschließend auf postgres-9.2.4-1-osxSymbol, das eine Warnmeldung ausgibt. Akzeptieren Sie die Warnung und fahren Sie mit der weiteren Installation fort. Es wird nach dem Administratorkennwort gefragt, wie im folgenden Fenster gezeigt -

Geben Sie das Kennwort ein, fahren Sie mit der Installation fort und starten Sie nach diesem Schritt Ihren Mac neu. Wenn das folgende Fenster nicht angezeigt wird, starten Sie die Installation erneut.

  • Sobald Sie das Installationsprogramm starten, werden Ihnen einige grundlegende Fragen gestellt, z. B. der Speicherort der Installation, das Kennwort des Benutzers, der die Datenbank verwendet, die Portnummer usw. Behalten Sie daher alle Standardwerte bei, mit Ausnahme des Kennworts, das Sie angeben können nach Ihrer Wahl. Es installiert PostgreSQL auf Ihrem Mac-Computer im Anwendungsordner, den Sie überprüfen können -

  • Jetzt können Sie jedes Programm starten, mit dem Sie beginnen möchten. Beginnen wir mit der SQL Shell. Wenn Sie SQL Shell starten, verwenden Sie einfach alle angezeigten Standardwerte, außer geben Sie Ihr Kennwort ein, das Sie zum Zeitpunkt der Installation ausgewählt hatten. Wenn alles gut geht, befinden Sie sich in der Postgres-Datenbank und apostgress# Die Eingabeaufforderung wird wie unten gezeigt angezeigt.

Herzliche Glückwünsche!!! Jetzt haben Sie Ihre Umgebung bereit, um mit der PostgreSQL-Datenbankprogrammierung zu beginnen.

Dieses Kapitel enthält eine Liste der PostgreSQL SQL-Befehle, gefolgt von den genauen Syntaxregeln für jeden dieser Befehle. Dieser Befehlssatz stammt aus dem Befehlszeilentool psql. Nachdem Sie Postgres installiert haben, öffnen Sie die psql als -

Program Files → PostgreSQL 9.2 → SQL Shell(psql).

Mit psql können Sie mit dem Befehl \ help eine vollständige Liste der Befehle erstellen. Verwenden Sie für die Syntax eines bestimmten Befehls den folgenden Befehl:

postgres-# \help <command_name>

Die SQL-Anweisung

Eine SQL-Anweisung besteht aus Token, bei denen jedes Token entweder ein Schlüsselwort, einen Bezeichner, einen Bezeichner in Anführungszeichen, eine Konstante oder ein Sonderzeichensymbol darstellen kann. In der folgenden Tabelle wird eine einfache SELECT-Anweisung verwendet, um eine grundlegende, aber vollständige SQL-Anweisung und ihre Komponenten zu veranschaulichen.

WÄHLEN ID, Name VON Zustände
Token-Typ Stichwort Kennungen Stichwort Kennung
Beschreibung Befehl ID- und Namensspalten Klausel Tabellenname

PostgreSQL SQL-Befehle

ABBRECHEN

Brechen Sie die aktuelle Transaktion ab.

ABORT [ WORK | TRANSACTION ]

ALTER AGGREGATE

Ändern Sie die Definition einer Aggregatfunktion.

ALTER AGGREGATE name ( type ) RENAME TO new_name
ALTER AGGREGATE name ( type ) OWNER TO new_owner

ÄNDERUNGSKONVERTIERUNG

Ändern Sie die Definition einer Konvertierung.

ALTER CONVERSION name RENAME TO new_name
ALTER CONVERSION name OWNER TO new_owner

ALTER DATABASE

Ändern Sie einen datenbankspezifischen Parameter.

ALTER DATABASE name SET parameter { TO | = } { value | DEFAULT }
ALTER DATABASE name RESET parameter
ALTER DATABASE name RENAME TO new_name
ALTER DATABASE name OWNER TO new_owner

ALTER DOMAIN

Ändern Sie die Definition eines domänenspezifischen Parameters.

ALTER DOMAIN name { SET DEFAULT expression | DROP DEFAULT }
ALTER DOMAIN name { SET | DROP } NOT NULL
ALTER DOMAIN name ADD domain_constraint
ALTER DOMAIN name DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
ALTER DOMAIN name OWNER TO new_owner

ALTER FUNCTION

Ändern Sie die Definition einer Funktion.

ALTER FUNCTION name ( [ type [, ...] ] ) RENAME TO new_name
ALTER FUNCTION name ( [ type [, ...] ] ) OWNER TO new_owner

ALTER GROUP

Ändern Sie eine Benutzergruppe.

ALTER GROUP groupname ADD USER username [, ... ]
ALTER GROUP groupname DROP USER username [, ... ]
ALTER GROUP groupname RENAME TO new_name

ALTER INDEX

Ändern Sie die Definition eines Index.

ALTER INDEX name OWNER TO new_owner
ALTER INDEX name SET TABLESPACE indexspace_name
ALTER INDEX name RENAME TO new_name

ALTER SPRACHE

Ändern Sie die Definition einer prozeduralen Sprache.

ALTER LANGUAGE name RENAME TO new_name

ALTER OPERATOR

Ändern Sie die Definition eines Operators.

ALTER OPERATOR name ( { lefttype | NONE }, { righttype | NONE } )
OWNER TO new_owner

ALTER OPERATOR CLASS

Ändern Sie die Definition einer Operatorklasse.

ALTER OPERATOR CLASS name USING index_method RENAME TO new_name
ALTER OPERATOR CLASS name USING index_method OWNER TO new_owner

ALTER SCHEMA

Ändern Sie die Definition eines Schemas.

ALTER SCHEMA name RENAME TO new_name
ALTER SCHEMA name OWNER TO new_owner

ÄNDERN SIE DIE SEQUENZ

Ändern Sie die Definition eines Sequenzgenerators.

ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ RESTART [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

ALTER TABLE

Ändern Sie die Definition einer Tabelle.

ALTER TABLE [ ONLY ] name [ * ]
action [, ... ]
ALTER TABLE [ ONLY ] name [ * ]
RENAME [ COLUMN ] column TO new_column
ALTER TABLE name
RENAME TO new_name

Wo Aktion eine der folgenden Zeilen ist -

ADD [ COLUMN ] column_type [ column_constraint [ ... ] ]
DROP [ COLUMN ] column [ RESTRICT | CASCADE ]
ALTER [ COLUMN ] column TYPE type [ USING expression ]
ALTER [ COLUMN ] column SET DEFAULT expression
ALTER [ COLUMN ] column DROP DEFAULT
ALTER [ COLUMN ] column { SET | DROP } NOT NULL
ALTER [ COLUMN ] column SET STATISTICS integer
ALTER [ COLUMN ] column SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
ADD table_constraint
DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
CLUSTER ON index_name
SET WITHOUT CLUSTER
SET WITHOUT OIDS
OWNER TO new_owner
SET TABLESPACE tablespace_name

ALTER TABLESPACE

Ändern Sie die Definition eines Tablespace.

ALTER TABLESPACE name RENAME TO new_name
ALTER TABLESPACE name OWNER TO new_owner

ALTER TRIGGER

Ändern Sie die Definition eines Triggers.

ALTER TRIGGER name ON table RENAME TO new_name

ALTER TYPE

Ändern Sie die Definition eines Typs.

ALTER TYPE name OWNER TO new_owner

ALTER USER

Ändern Sie ein Datenbankbenutzerkonto.

ALTER USER name [ [ WITH ] option [ ... ] ]
ALTER USER name RENAME TO new_name
ALTER USER name SET parameter { TO | = } { value | DEFAULT }
ALTER USER name RESET parameter

Wo Option sein kann -

[ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| VALID UNTIL 'abstime'

ANALYSIEREN

Sammeln Sie Statistiken über eine Datenbank.

ANALYZE [ VERBOSE ] [ table [ (column [, ...] ) ] ]

START

Starten Sie einen Transaktionsblock.

BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]

Wobei transaction_mode einer von - ist

ISOLATION LEVEL { 
   SERIALIZABLE | REPEATABLE READ | READ COMMITTED
   | READ UNCOMMITTED
}
READ WRITE | READ ONLY

KONTROLLPUNKT

Erzwingen Sie einen Transaktionsprotokollprüfpunkt.

CHECKPOINT

SCHLIESSEN

Schließen Sie einen Cursor.

CLOSE name

CLUSTER

Gruppieren Sie eine Tabelle nach einem Index.

CLUSTER index_name ON table_name
CLUSTER table_name
CLUSTER

KOMMENTAR

Definieren oder ändern Sie den Kommentar eines Objekts.

COMMENT ON {
   TABLE object_name |
   COLUMN table_name.column_name |
   AGGREGATE agg_name (agg_type) |
   CAST (source_type AS target_type) |
   CONSTRAINT constraint_name ON table_name |
   CONVERSION object_name |
   DATABASE object_name |
   DOMAIN object_name |
   FUNCTION func_name (arg1_type, arg2_type, ...) |
   INDEX object_name |
   LARGE OBJECT large_object_oid |
   OPERATOR op (left_operand_type, right_operand_type) |
   OPERATOR CLASS object_name USING index_method |
   [ PROCEDURAL ] LANGUAGE object_name |
   RULE rule_name ON table_name |
   SCHEMA object_name |
   SEQUENCE object_name |
   TRIGGER trigger_name ON table_name |
   TYPE object_name |
   VIEW object_name
} 
IS 'text'

VERPFLICHTEN

Übernehmen Sie die aktuelle Transaktion.

COMMIT [ WORK | TRANSACTION ]

KOPIEREN

Kopieren Sie Daten zwischen einer Datei und einer Tabelle.

COPY table_name [ ( column [, ...] ) ]
FROM { 'filename' | STDIN }
[ WITH ]
[ BINARY ]
[ OIDS ]
[ DELIMITER [ AS ] 'delimiter' ]
[ NULL [ AS ] 'null string' ]
[ CSV [ QUOTE [ AS ] 'quote' ]
[ ESCAPE [ AS ] 'escape' ]
[ FORCE NOT NULL column [, ...] ]
COPY table_name [ ( column [, ...] ) ]
TO { 'filename' | STDOUT }
[ [ WITH ]
[ BINARY ]
[ OIDS ]
[ DELIMITER [ AS ] 'delimiter' ]
[ NULL [ AS ] 'null string' ]
[ CSV [ QUOTE [ AS ] 'quote' ]
[ ESCAPE [ AS ] 'escape' ]
[ FORCE QUOTE column [, ...] ]

AGGREGATE ERSTELLEN

Definieren Sie eine neue Aggregatfunktion.

CREATE AGGREGATE name (
   BASETYPE = input_data_type,
   SFUNC = sfunc,
   STYPE = state_data_type
   [, FINALFUNC = ffunc ]
   [, INITCOND = initial_condition ]
)

CAST ERSTELLEN

Definieren Sie eine neue Besetzung.

CREATE CAST (source_type AS target_type)
WITH FUNCTION func_name (arg_types)
[ AS ASSIGNMENT | AS IMPLICIT ]
CREATE CAST (source_type AS target_type)
WITHOUT FUNCTION
[ AS ASSIGNMENT | AS IMPLICIT ]

CREATE CONSTRAINT TRIGGER

Definieren Sie einen neuen Einschränkungsauslöser.

CREATE CONSTRAINT TRIGGER name
AFTER events ON
table_name constraint attributes
FOR EACH ROW EXECUTE PROCEDURE func_name ( args )

KONVERTIERUNG ERSTELLEN

Definieren Sie eine neue Konvertierung.

CREATE [DEFAULT] CONVERSION name
FOR source_encoding TO dest_encoding FROM func_name

DATENBANK ERSTELLEN

Erstellen Sie eine neue Datenbank.

CREATE DATABASE name
[ [ WITH ] [ OWNER [=] db_owner ]
   [ TEMPLATE [=] template ]
   [ ENCODING [=] encoding ]
   [ TABLESPACE [=] tablespace ] 
]

DOMAIN ERSTELLEN

Definieren Sie eine neue Domain.

CREATE DOMAIN name [AS] data_type
[ DEFAULT expression ]
[ constraint [ ... ] ]

Wo Einschränkung ist -

[ CONSTRAINT constraint_name ]
{ NOT NULL | NULL | CHECK (expression) }

FUNKTION ERSTELLEN

Definieren Sie eine neue Funktion.

CREATE [ OR REPLACE ] FUNCTION name ( [ [ arg_name ] arg_type [, ...] ] )
RETURNS ret_type
{ LANGUAGE lang_name
   | IMMUTABLE | STABLE | VOLATILE
   | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
   | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
   | AS 'definition'
   | AS 'obj_file', 'link_symbol'
} ...
[ WITH ( attribute [, ...] ) ]

GRUPPE ERSTELLEN

Definieren Sie eine neue Benutzergruppe.

CREATE GROUP name [ [ WITH ] option [ ... ] ]
Where option can be:
SYSID gid
| USER username [, ...]

INDEX ERSTELLEN

Definieren Sie einen neuen Index.

CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
( { column | ( expression ) } [ opclass ] [, ...] )
[ TABLESPACE tablespace ]
[ WHERE predicate ]

SPRACHE ERSTELLEN

Definieren Sie eine neue Verfahrenssprache.

CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
HANDLER call_handler [ VALIDATOR val_function ]

OPERATOR ERSTELLEN

Definieren Sie einen neuen Operator.

CREATE OPERATOR name (
   PROCEDURE = func_name
   [, LEFTARG = left_type ] [, RIGHTARG = right_type ]
   [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
   [, RESTRICT = res_proc ] [, JOIN = join_proc ]
   [, HASHES ] [, MERGES ]
   [, SORT1 = left_sort_op ] [, SORT2 = right_sort_op ]
   [, LTCMP = less_than_op ] [, GTCMP = greater_than_op ]
)

OPERATORKLASSE ERSTELLEN

Definieren Sie eine neue Operatorklasse.

CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type
USING index_method AS
{ OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ RECHECK ]
   | FUNCTION support_number func_name ( argument_type [, ...] )
   | STORAGE storage_type
} [, ... ]

REGEL ERSTELLEN

Definieren Sie eine neue Umschreiberegel.

CREATE [ OR REPLACE ] RULE name AS ON event
TO table [ WHERE condition ]
DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }

SCHEMA ERSTELLEN

Definieren Sie ein neues Schema.

CREATE SCHEMA schema_name
[ AUTHORIZATION username ] [ schema_element [ ... ] ]
CREATE SCHEMA AUTHORIZATION username
[ schema_element [ ... ] ]

SEQUENZ ERSTELLEN

Definieren Sie einen neuen Sequenzgenerator.

CREATE [ TEMPORARY | TEMP ] SEQUENCE name
[ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

TABELLE ERSTELLEN

Definieren Sie eine neue Tabelle.

CREATE [ [ GLOBAL | LOCAL ] { 
   TEMPORARY | TEMP } ] TABLE table_name ( { 
      column_name data_type [ DEFAULT default_expr ] [ column_constraint [ ... ] ]
      | table_constraint
      | LIKE parent_table [ { INCLUDING | EXCLUDING } DEFAULTS ] 
   } [, ... ]
)
[ INHERITS ( parent_table [, ... ] ) ]
[ WITH OIDS | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace ]

Wo column_constraint ist -

[ CONSTRAINT constraint_name ] { 
   NOT NULL |
   NULL |
   UNIQUE [ USING INDEX TABLESPACE tablespace ] |
   PRIMARY KEY [ USING INDEX TABLESPACE tablespace ] |
   CHECK (expression) |
   REFERENCES ref_table [ ( ref_column ) ]
   [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
   [ ON DELETE action ] [ ON UPDATE action ] 
}
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

Und table_constraint ist -

[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
PRIMARY KEY ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
CHECK ( expression ) |
FOREIGN KEY ( column_name [, ... ] )
REFERENCES ref_table [ ( ref_column [, ... ] ) ]
[ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
[ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

TABELLE ERSTELLEN ALS

Definieren Sie eine neue Tabelle aus den Ergebnissen einer Abfrage.

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name
[ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
AS query

TABLESPACE ERSTELLEN

Definieren Sie einen neuen Tablespace.

CREATE TABLESPACE tablespace_name [ OWNER username ] LOCATION 'directory'

TRIGGER ERSTELLEN

Definieren Sie einen neuen Trigger.

CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
EXECUTE PROCEDURE func_name ( arguments )

TYP ERSTELLEN

Definieren Sie einen neuen Datentyp.

CREATE TYPE name AS
( attribute_name data_type [, ... ] )
CREATE TYPE name (
INPUT = input_function,
OUTPUT = output_function
[, RECEIVE = receive_function ]
[, SEND = send_function ]
[, ANALYZE = analyze_function ]
[, INTERNALLENGTH = { internal_length | VARIABLE } ]
[, PASSEDBYVALUE ]
[, ALIGNMENT = alignment ]
[, STORAGE = storage ]
[, DEFAULT = default ]
[, ELEMENT = element ]
[, DELIMITER = delimiter ]
)

BENUTZER ERSTELLEN

Definieren Sie ein neues Datenbankbenutzerkonto.

CREATE USER name [ [ WITH ] option [ ... ] ]

Wo Option sein kann -

SYSID uid
| [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| IN GROUP group_name [, ...]
| VALID UNTIL 'abs_time'

ANSICHT ERSTELLEN

Definieren Sie eine neue Ansicht.

CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS query

DEALLOCATE

Geben Sie eine vorbereitete Erklärung frei.

DEALLOCATE [ PREPARE ] plan_name

ERKLÄREN

Definieren Sie einen Cursor.

DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
[ FOR { READ ONLY | UPDATE [ OF column [, ...] ] } ]

LÖSCHEN

Zeilen einer Tabelle löschen.

DELETE FROM [ ONLY ] table [ WHERE condition ]

DROP AGGREGATE

Entfernen Sie eine Aggregatfunktion.

DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]

DROP CAST

Entfernen Sie einen Gipsverband.

DROP CAST (source_type AS target_type) [ CASCADE | RESTRICT ]

TROPFENKONVERTIERUNG

Entfernen Sie eine Konvertierung.

DROP CONVERSION name [ CASCADE | RESTRICT ]

DROP DATABASE

Entfernen Sie eine Datenbank.

DROP DATABASE name

DROP DOMAIN

Entfernen Sie eine Domain.

DROP DOMAIN name [, ...] [ CASCADE | RESTRICT ]

TROPFENFUNKTION

Entfernen Sie eine Funktion.

DROP FUNCTION name ( [ type [, ...] ] ) [ CASCADE | RESTRICT ]

TROPFENGRUPPE

Entfernen Sie eine Benutzergruppe.

DROP GROUP name

DROP INDEX

Entfernen Sie einen Index.

DROP INDEX name [, ...] [ CASCADE | RESTRICT ]

TROPFENSPRACHE

Entfernen Sie eine prozedurale Sprache.

DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]

TROPFENBETREIBER

Entfernen Sie einen Bediener.

DROP OPERATOR name ( { left_type | NONE }, { right_type | NONE } )
[ CASCADE | RESTRICT ]

TROPFENBETREIBERKLASSE

Entfernen Sie eine Operatorklasse.

DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]

TROPFENREGEL

Entfernen Sie eine Umschreiberegel.

DROP RULE name ON relation [ CASCADE | RESTRICT ]

TROPFENSCHEMA

Entfernen Sie ein Schema.

DROP SCHEMA name [, ...] [ CASCADE | RESTRICT ]

TROPFENFOLGE

Entfernen Sie eine Sequenz.

DROP SEQUENCE name [, ...] [ CASCADE | RESTRICT ]

TROPFENTABELLE

Entfernen Sie einen Tisch.

DROP TABLE name [, ...] [ CASCADE | RESTRICT ]

DROP TABLESPACE

Entfernen Sie einen Tablespace.

DROP TABLESPACE tablespace_name

TROPFEN-TRIGGER

Entfernen Sie einen Auslöser.

DROP TRIGGER name ON table [ CASCADE | RESTRICT ]

TROPFENTYP

Entfernen Sie einen Datentyp.

DROP TYPE name [, ...] [ CASCADE | RESTRICT ]

DROP USER

Entfernen Sie ein Datenbankbenutzerkonto.

DROP USER name

TROPFENANSICHT

Eine Ansicht entfernen.

DROP VIEW name [, ...] [ CASCADE | RESTRICT ]

ENDE

Übernehmen Sie die aktuelle Transaktion.

END [ WORK | TRANSACTION ]

AUSFÜHREN

Führen Sie eine vorbereitete Anweisung aus.

EXECUTE plan_name [ (parameter [, ...] ) ]

ERKLÄREN

Zeigen Sie den Ausführungsplan einer Anweisung an.

EXPLAIN [ ANALYZE ] [ VERBOSE ] statement

HOLEN

Abrufen von Zeilen aus einer Abfrage mit einem Cursor.

FETCH [ direction { FROM | IN } ] cursor_name

Wo Richtung leer sein kann oder eine von -

NEXT
PRIOR
FIRST
LAST
ABSOLUTE count
RELATIVE count
count
ALL
FORWARD
FORWARD count
FORWARD ALL
BACKWARD
BACKWARD count
BACKWARD ALL

GEWÄHREN

Definieren Sie Zugriffsrechte.

GRANT { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] table_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE db_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { CREATE | ALL [ PRIVILEGES ] }
ON TABLESPACE tablespace_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION func_name ([type, ...]) [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { USAGE | ALL [ PRIVILEGES ] }
ON LANGUAGE lang_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA schema_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

EINFÜGEN

Erstellen Sie neue Zeilen in einer Tabelle.

INSERT INTO table [ ( column [, ...] ) ]
{ DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | query }

HÖR MAL ZU

Warten Sie auf eine Benachrichtigung.

LISTEN name

BELASTUNG

Laden oder laden Sie eine gemeinsam genutzte Bibliotheksdatei.

LOAD 'filename'

SPERREN

Schließ einen Tisch ab.

LOCK [ TABLE ] name [, ...] [ IN lock_mode MODE ] [ NOWAIT ]

Wobei lock_mode einer von - ist

ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
| SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

BEWEGUNG

Positionieren Sie einen Cursor.

MOVE [ direction { FROM | IN } ] cursor_name

BENACHRICHTIGEN

Generieren Sie eine Benachrichtigung.

NOTIFY name

BEREITEN

Bereiten Sie eine Anweisung zur Ausführung vor.

PREPARE plan_name [ (data_type [, ...] ) ] AS statement

REINDEX

Indizes neu erstellen.

REINDEX { DATABASE | TABLE | INDEX } name [ FORCE ]

RELEASE SAVEPOINT

Zerstören Sie einen zuvor definierten Sicherungspunkt.

RELEASE [ SAVEPOINT ] savepoint_name

RESET

Stellen Sie den Wert eines Laufzeitparameters auf den Standardwert zurück.

RESET name
RESET ALL

WIDERRUFEN

Entfernen Sie die Zugriffsrechte.

REVOKE [ GRANT OPTION FOR ]
{ { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] table_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE db_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ CREATE | ALL [ PRIVILEGES ] }
ON TABLESPACE tablespace_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION func_name ([type, ...]) [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ USAGE | ALL [ PRIVILEGES ] }
ON LANGUAGE lang_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA schema_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

ROLLBACK

Brechen Sie die aktuelle Transaktion ab.

ROLLBACK [ WORK | TRANSACTION ]

ROLLBACK ZUM SAVEPOINT

Rollback zu einem Sicherungspunkt.

ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name

SPEICHERPUNKT

Definieren Sie einen neuen Sicherungspunkt innerhalb der aktuellen Transaktion.

SAVEPOINT savepoint_name

WÄHLEN

Abrufen von Zeilen aus einer Tabelle oder Ansicht.

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
[ FOR UPDATE [ OF table_name [, ...] ] ]
from_item
[ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
function_name ( [ argument [, ...] ] )
[ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
from_item [ NATURAL ] join_type from_item
[ ON join_condition | USING ( join_column [, ...] ) ]

AUSWÄHLEN IN

Definieren Sie eine neue Tabelle aus den Ergebnissen einer Abfrage.

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
[ FOR UPDATE [ OF table_name [, ...] ] ]

EINSTELLEN

Ändern Sie einen Laufzeitparameter.

SET [ SESSION | LOCAL ] name { TO | = } { value | 'value' | DEFAULT }
SET [ SESSION | LOCAL ] TIME ZONE { time_zone | LOCAL | DEFAULT }

EINSCHRÄNKUNGEN EINSTELLEN

Legen Sie die Modi für die Einschränkungsprüfung für die aktuelle Transaktion fest.

SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }

SET SESSION AUTHORISATION

Legen Sie die Sitzungsbenutzer-ID und die aktuelle Benutzer-ID der aktuellen Sitzung fest.

SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
RESET SESSION AUTHORIZATION

TRANSAKTION EINSTELLEN

Legen Sie die Merkmale der aktuellen Transaktion fest.

SET TRANSACTION transaction_mode [, ...]
SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]

Wobei transaction_mode einer von - ist

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLY

SHOW

Zeigt den Wert eines Laufzeitparameters an.

SHOW name
SHOW ALL

TRANSAKTION STARTEN

Starten Sie einen Transaktionsblock.

START TRANSACTION [ transaction_mode [, ...] ]

Wobei transaction_mode einer von - ist

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLY

KÜRZEN

Leere einen Tisch.

TRUNCATE [ TABLE ] name

UNHÖREN

Hören Sie nicht mehr auf eine Benachrichtigung.

UNLISTEN { name | * }

AKTUALISIEREN

Aktualisieren Sie die Zeilen einer Tabelle.

UPDATE [ ONLY ] table SET column = { expression | DEFAULT } [, ...]
[ FROM from_list ]
[ WHERE condition ]

VAKUUM

Sammeln Sie Müll und analysieren Sie optional eine Datenbank.

VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]

In diesem Kapitel werden die in PostgreSQL verwendeten Datentypen erläutert. Beim Erstellen einer Tabelle geben Sie für jede Spalte einen Datentyp an, dh welche Art von Daten Sie in den Tabellenfeldern speichern möchten.

Dies ermöglicht mehrere Vorteile -

  • Consistency - Operationen für Spalten desselben Datentyps liefern konsistente Ergebnisse und sind normalerweise die schnellsten.

  • Validation - Die ordnungsgemäße Verwendung von Datentypen impliziert die Formatvalidierung von Daten und die Zurückweisung von Daten außerhalb des Bereichs des Datentyps.

  • Compactness - Da eine Spalte einen einzelnen Werttyp speichern kann, wird sie kompakt gespeichert.

  • Performance- Die ordnungsgemäße Verwendung von Datentypen ermöglicht die effizienteste Speicherung von Daten. Die gespeicherten Werte können schnell verarbeitet werden, was die Leistung verbessert.

PostgreSQL unterstützt eine Vielzahl von Datentypen. Außerdem können Benutzer mit dem SQL-Befehl CREATE TYPE ihren eigenen benutzerdefinierten Datentyp erstellen . In PostgreSQL gibt es verschiedene Kategorien von Datentypen. Sie werden unten diskutiert.

Numerische Typen

Numerische Typen bestehen aus Zwei-Byte-, Vier-Byte- und Acht-Byte-Ganzzahlen, Vier-Byte- und Acht-Byte-Gleitkommazahlen sowie Dezimalstellen mit auswählbarer Genauigkeit. In der folgenden Tabelle sind die verfügbaren Typen aufgeführt.

Name Speichergröße Beschreibung Angebot
smallint 2 Bytes Ganzzahl mit kleiner Reichweite -32768 bis +32767
ganze Zahl 4 Bytes typische Wahl für Ganzzahl -2147483648 bis +2147483647
Bigint 8 Bytes Ganzzahl mit großer Reichweite -9223372036854775808 bis 9223372036854775807
Dezimal Variable Benutzerdefinierte Genauigkeit, genau bis zu 131072 Stellen vor dem Dezimalpunkt; bis zu 16383 Stellen nach dem Komma
numerisch Variable Benutzerdefinierte Genauigkeit, genau bis zu 131072 Stellen vor dem Dezimalpunkt; bis zu 16383 Stellen nach dem Komma
echt 4 Bytes variable Genauigkeit, ungenau Genauigkeit von 6 Dezimalstellen
Doppelte Genauigkeit 8 Bytes variable Genauigkeit, ungenau Genauigkeit von 15 Dezimalstellen
smallserial 2 Bytes kleine automatisch inkrementierende Ganzzahl 1 bis 32767
seriell 4 Bytes Autoincrementing Integer 1 bis 2147483647
bigserial 8 Bytes große automatisch inkrementierende Ganzzahl 1 bis 9223372036854775807

Geldtypen

Die Geldart speichert einen Währungsbetrag mit einer festen Bruchgenauigkeit. Werte der Datentypen numerisch, int und bigint können in Geld umgewandelt werden . Die Verwendung von Gleitkommazahlen wird nicht empfohlen, um mit Geld umzugehen, da Rundungsfehler auftreten können.

Name Speichergröße Beschreibung Angebot
Geld 8 Bytes Währungsbetrag -92233720368547758.08 bis +92233720368547758.07

Zeichentypen

In der folgenden Tabelle sind die in PostgreSQL verfügbaren allgemeinen Zeichentypen aufgeführt.

S. Nr. Name & Beschreibung
1

character varying(n), varchar(n)

variable Länge mit Limit

2

character(n), char(n)

feste Länge, blank gepolstert

3

text

variable unbegrenzte Länge

Binäre Datentypen

Der Datentyp bytea ermöglicht die Speicherung von Binärzeichenfolgen wie in der folgenden Tabelle angegeben.

Name Speichergröße Beschreibung
bytea 1 oder 4 Bytes plus die eigentliche Binärzeichenfolge Binärzeichenfolge mit variabler Länge

Datums- / Zeittypen

PostgreSQL unterstützt einen vollständigen Satz von SQL-Datums- und Uhrzeittypen, wie in der folgenden Tabelle gezeigt. Die Daten werden nach dem Gregorianischen Kalender gezählt. Hier haben alle Typen eine Auflösung von1 microsecond / 14 digits außer date Typ, dessen Auflösung ist day.

Name Speichergröße Beschreibung Niedriger Wert Hochwertig
Zeitstempel [(p)] [ohne Zeitzone] 8 Bytes Datum und Uhrzeit (keine Zeitzone) 4713 v 294276 AD
TIMESTAMPTZ 8 Bytes Datum und Uhrzeit mit Zeitzone 4713 v 294276 AD
Datum 4 Bytes Datum (keine Tageszeit) 4713 v 5874897 AD
Zeit [(p)] [ohne Zeitzone] 8 Bytes Tageszeit (kein Datum) 00:00:00 24:00:00
Zeit [(p)] mit Zeitzone 12 Bytes Nur Tageszeiten mit Zeitzone 00: 00: 00 + 1459 24: 00: 00-1459
Intervall [Felder] [(p)] 12 Bytes Zeitintervall -178000000 Jahre 178000000 Jahre

Boolescher Typ

PostgreSQL bietet den Standard-SQL-Typ Boolean. Der boolesche Datentyp kann die Zustände true , false und einen dritten unbekannten Zustand haben , der durch den SQL-Nullwert dargestellt wird.

Name Speichergröße Beschreibung
Boolescher Wert 1 Byte Zustand von wahr oder falsch

Aufzählungstyp

Aufzählungstypen (Aufzählungstypen) sind Datentypen, die einen statischen, geordneten Satz von Werten umfassen. Sie entsprechen den Aufzählungstypen, die in einer Reihe von Programmiersprachen unterstützt werden.

Im Gegensatz zu anderen Typen müssen Aufzählungstypen mit dem Befehl CREATE TYPE erstellt werden. Dieser Typ wird zum Speichern eines statischen, geordneten Satzes von Werten verwendet. Zum Beispiel Kompassrichtungen, dh NORD, SÜD, OST und WEST oder Wochentage wie unten gezeigt -

CREATE TYPE week AS ENUM ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

Aufgezählte Aufzählungen können wie alle anderen Typen verwendet werden.

Geometrischer Typ

Geometrische Datentypen repräsentieren zweidimensionale räumliche Objekte. Der grundlegendste Typ, der Punkt, bildet die Grundlage für alle anderen Typen.

Name Speichergröße Darstellung Beschreibung
Punkt 16 Bytes Zeigen Sie auf ein Flugzeug (x, y)
Linie 32 Bytes Unendliche Leitung (nicht vollständig implementiert) ((x1, y1), (x2, y2))
lseg 32 Bytes Endliches Liniensegment ((x1, y1), (x2, y2))
Box 32 Bytes Rechteckige Box ((x1, y1), (x2, y2))
Pfad 16 + 16n Bytes Geschlossener Pfad (ähnlich wie Polygon) ((x1, y1), ...)
Pfad 16 + 16n Bytes Pfad öffnen [(x1, y1), ...]
Polygon 40 + 16n Polygon (ähnlich wie geschlossener Pfad) ((x1, y1), ...)
Kreis 24 Bytes Kreis <(x, y), r> (Mittelpunkt und Radius)

Netzwerkadressentyp

PostgreSQL bietet Datentypen zum Speichern von IPv4-, IPv6- und MAC-Adressen. Es ist besser, diese Typen anstelle von Nur-Text-Typen zum Speichern von Netzwerkadressen zu verwenden, da diese Typen eine Eingabefehlerprüfung sowie spezialisierte Operatoren und Funktionen bieten.

Name Speichergröße Beschreibung
cidr 7 oder 19 Bytes IPv4- und IPv6-Netzwerke
inet 7 oder 19 Bytes IPv4- und IPv6-Hosts und -Netzwerke
macaddr 6 Bytes MAC-Adressen

Bit-String-Typ

Bitstringtypen werden zum Speichern von Bitmasken verwendet. Sie sind entweder 0 oder 1. Es gibt zwei SQL-Bittypen:bit(n) und bit varying(n), wobei n eine positive ganze Zahl ist.

Textsuchtyp

Dieser Typ unterstützt die Volltextsuche, bei der eine Sammlung von Dokumenten in natürlicher Sprache durchsucht wird, um diejenigen zu finden, die am besten zu einer Abfrage passen. Hierfür gibt es zwei Datentypen:

S. Nr. Name & Beschreibung
1

tsvector

Dies ist eine sortierte Liste verschiedener Wörter, die normalisiert wurden, um verschiedene Varianten desselben Wortes zusammenzuführen, die als "Lexeme" bezeichnet werden.

2

tsquery

Dies speichert Lexeme, nach denen gesucht werden soll, und kombiniert sie unter Berücksichtigung der Booleschen Operatoren & (AND), | (Oder und ! (NICHT). Klammern können verwendet werden, um die Gruppierung der Operatoren zu erzwingen.

UUID-Typ

Eine UUID (Universally Unique Identifiers) wird als Folge von hexadezimalen Kleinbuchstaben in mehreren durch Bindestriche getrennten Gruppen geschrieben, insbesondere einer Gruppe von acht Ziffern, gefolgt von drei Gruppen von vier Ziffern, gefolgt von einer Gruppe von 12 Ziffern Insgesamt 32 Stellen, die die 128 Bits darstellen.

Ein Beispiel für eine UUID ist - 550e8400-e29b-41d4-a716-446655440000

XML-Typ

Der XML-Datentyp kann zum Speichern von XML-Daten verwendet werden. Zum Speichern von XML-Daten müssen Sie zunächst XML-Werte mit der Funktion xmlparse wie folgt erstellen:

XMLPARSE (DOCUMENT '<?xml version="1.0"?>
<tutorial>
<title>PostgreSQL Tutorial </title>
   <topics>...</topics>
</tutorial>')

XMLPARSE (CONTENT 'xyz<foo>bar</foo><bar>foo</bar>')

JSON-Typ

Der Datentyp json kann zum Speichern von JSON-Daten (JavaScript Object Notation) verwendet werden. Solche Daten können auch als Text gespeichert werden , aber der json- Datentyp hat den Vorteil, dass überprüft wird, ob jeder gespeicherte Wert ein gültiger JSON-Wert ist. Es stehen auch verwandte Unterstützungsfunktionen zur Verfügung, mit denen der JSON-Datentyp wie folgt direkt verarbeitet werden kann.

Beispiel Beispiel Ergebnis
array_to_json ('{{1,5}, {99,100}}' :: int []) [[1,5], [99,100]]
row_to_json (row (1, 'foo')) {"f1": 1, "f2": "foo"}

Array-Typ

PostgreSQL bietet die Möglichkeit, eine Spalte einer Tabelle als mehrdimensionales Array variabler Länge zu definieren. Es können Arrays eines beliebigen integrierten oder benutzerdefinierten Basistyps, Aufzählungstyps oder zusammengesetzten Typs erstellt werden.

Deklaration von Arrays

Der Array-Typ kann als deklariert werden

CREATE TABLE monthly_savings (
   name text,
   saving_per_quarter integer[],
   scheme text[][]
);

oder mit dem Schlüsselwort "ARRAY" als

CREATE TABLE monthly_savings (
   name text,
   saving_per_quarter integer ARRAY[4],
   scheme text[][]
);

Werte einfügen

Array-Werte können als Literalkonstante eingefügt werden, wobei die Elementwerte in geschweiften Klammern eingeschlossen und durch Kommas getrennt werden. Ein Beispiel ist unten gezeigt -

INSERT INTO monthly_savings 
VALUES (‘Manisha’, 
‘{20000, 14600, 23500, 13250}’, 
‘{{“FD”, “MF”}, {“FD”, “Property”}}’);

Zugriff auf Arrays

Ein Beispiel für den Zugriff auf Arrays ist unten dargestellt. Mit dem folgenden Befehl werden die Personen ausgewählt, deren Ersparnisse im zweiten Quartal höher sind als im vierten Quartal.

SELECT name FROM monhly_savings WHERE saving_per_quarter[2] > saving_per_quarter[4];

Arrays ändern

Ein Beispiel für das Ändern von Arrays ist unten dargestellt.

UPDATE monthly_savings SET saving_per_quarter = '{25000,25000,27000,27000}'
WHERE name = 'Manisha';

oder mit der ARRAY-Ausdruckssyntax -

UPDATE monthly_savings SET saving_per_quarter = ARRAY[25000,25000,27000,27000]
WHERE name = 'Manisha';

Arrays suchen

Ein Beispiel für die Suche nach Arrays ist unten dargestellt.

SELECT * FROM monthly_savings WHERE saving_per_quarter[1] = 10000 OR
saving_per_quarter[2] = 10000 OR
saving_per_quarter[3] = 10000 OR
saving_per_quarter[4] = 10000;

Wenn die Größe des Arrays bekannt ist, kann die oben angegebene Suchmethode verwendet werden. Andernfalls zeigt das folgende Beispiel, wie gesucht wird, wenn die Größe nicht bekannt ist.

SELECT * FROM monthly_savings WHERE 10000 = ANY (saving_per_quarter);

Zusammengesetzte Typen

Dieser Typ repräsentiert eine Liste von Feldnamen und deren Datentypen, dh die Struktur einer Zeile oder eines Datensatzes einer Tabelle.

Erklärung der zusammengesetzten Typen

Das folgende Beispiel zeigt, wie ein zusammengesetzter Typ deklariert wird

CREATE TYPE inventory_item AS (
   name text,
   supplier_id integer,
   price numeric
);

Dieser Datentyp kann in den folgenden Tabellen zum Erstellen verwendet werden:

CREATE TABLE on_hand (
   item inventory_item,
   count integer
);

Composite Value Input

Zusammengesetzte Werte können als Literalkonstante eingefügt werden, wobei die Feldwerte in Klammern eingeschlossen und durch Kommas getrennt werden. Ein Beispiel ist unten gezeigt -

INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);

Dies gilt für das oben definierte Inventarelement . Das Schlüsselwort ROW ist tatsächlich optional, solange der Ausdruck mehr als ein Feld enthält.

Zugriff auf zusammengesetzte Typen

Verwenden Sie für den Zugriff auf ein Feld einer zusammengesetzten Spalte einen Punkt gefolgt vom Feldnamen, ähnlich wie beim Auswählen eines Felds aus einem Tabellennamen. Um beispielsweise einige Unterfelder aus unserer Beispieltabelle on_hand auszuwählen, lautet die Abfrage wie folgt:

SELECT (item).name FROM on_hand WHERE (item).price > 9.99;

Sie können auch den Tabellennamen verwenden (z. B. in einer multitablen Abfrage).

SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;

Bereichstypen

Bereichstypen stellen Datentypen dar, die einen Datenbereich verwenden. Der Bereichstyp kann diskrete Bereiche (z. B. alle ganzzahligen Werte 1 bis 10) oder kontinuierliche Bereiche (z. B. ein beliebiger Zeitpunkt zwischen 10:00 Uhr und 11:00 Uhr) sein.

Die verfügbaren integrierten Bereichstypen umfassen die folgenden Bereiche:

  • int4range - Bereich der ganzen Zahl

  • int8range - Reichweite von Bigint

  • numrange - Bereich der numerischen

  • tsrange - Bereich des Zeitstempels ohne Zeitzone

  • tstzrange - Bereich des Zeitstempels mit Zeitzone

  • daterange - Datumsbereich

Benutzerdefinierte Bereichstypen können erstellt werden, um neue Arten von Bereichen verfügbar zu machen, z. B. IP-Adressbereiche, die den Inet-Typ als Basis verwenden, oder Float-Bereiche, die den Float-Datentyp als Basis verwenden.

Bereichstypen unterstützen inklusive und exklusive Bereichsgrenzen mit den Zeichen [] bzw. (). Zum Beispiel repräsentiert '[4,9)' alle ganzen Zahlen ab und einschließlich 4 bis einschließlich 9.

Objektkennungstypen

Objektkennungen (OIDs) werden von PostgreSQL intern als Primärschlüssel für verschiedene Systemtabellen verwendet. Wenn WITH OIDS angegeben oder die Konfigurationsvariable default_with_oids aktiviert ist, werden in solchen Fällen OIDs zu vom Benutzer erstellten Tabellen hinzugefügt. In der folgenden Tabelle sind mehrere Alias-Typen aufgeführt. Die OID-Alias-Typen haben außer speziellen Eingabe- und Ausgaberoutinen keine eigenen Operationen.

Name Verweise Beschreibung Wertebeispiel
oid irgendein numerische Objektkennung 564182
regproc pg_proc Funktionsname Summe
regprocedure pg_proc Funktion mit Argumenttypen Summe (int4)
Regoper pg_operator Name des Bedieners +
Regoperator pg_operator Operator mit Argumenttypen * (Ganzzahl, Ganzzahl) oder - (KEINE, Ganzzahl)
Regclass pg_class Beziehungsname pg_type
regtype pg_type Datentypname ganze Zahl
regconfig pg_ts_config Konfiguration der Textsuche Englisch
regdictionary pg_ts_dict Textsuchwörterbuch einfach

Pseudo-Typen

Das PostgreSQL-Typsystem enthält eine Reihe von Spezialeinträgen, die zusammen als Pseudotyp bezeichnet werden. Ein Pseudotyp kann nicht als Spaltendatentyp verwendet werden, aber er kann verwendet werden, um das Argument oder den Ergebnistyp einer Funktion zu deklarieren.

In der folgenden Tabelle sind die vorhandenen Pseudotypen aufgeführt.

S. Nr. Name & Beschreibung
1

any

Gibt an, dass eine Funktion einen beliebigen Eingabedatentyp akzeptiert.

2

anyelement

Gibt an, dass eine Funktion einen beliebigen Datentyp akzeptiert.

3

anyarray

Gibt an, dass eine Funktion einen beliebigen Array-Datentyp akzeptiert.

4

anynonarray

Gibt an, dass eine Funktion einen beliebigen Nicht-Array-Datentyp akzeptiert.

5

anyenum

Gibt an, dass eine Funktion einen beliebigen Aufzählungsdatentyp akzeptiert.

6

anyrange

Gibt an, dass eine Funktion einen beliebigen Bereichsdatentyp akzeptiert.

7

cstring

Gibt an, dass eine Funktion eine nullterminierte C-Zeichenfolge akzeptiert oder zurückgibt.

8

internal

Gibt an, dass eine Funktion einen serverinternen Datentyp akzeptiert oder zurückgibt.

9

language_handler

Ein prozeduraler Sprachaufruf-Handler wird deklariert, um language_handler zurückzugeben.

10

fdw_handler

Ein Wrapper-Handler für Fremddaten wird deklariert, um fdw_handler zurückzugeben.

11

record

Identifiziert eine Funktion, die einen nicht angegebenen Zeilentyp zurückgibt.

12

trigger

Eine Triggerfunktion wird deklariert, um den Trigger zurückzugeben.

13

void

Gibt an, dass eine Funktion keinen Wert zurückgibt.

In diesem Kapitel wird erläutert, wie Sie eine neue Datenbank in Ihrem PostgreSQL erstellen. PostgreSQL bietet zwei Möglichkeiten zum Erstellen einer neuen Datenbank:

  • Verwenden von CREATE DATABASE, einem SQL-Befehl.
  • Verwenden Sie createdb, eine ausführbare Befehlszeilendatei.

Verwenden von CREATE DATABASE

Dieser Befehl erstellt eine Datenbank über die PostgreSQL-Shell-Eingabeaufforderung. Sie sollten jedoch über die entsprechenden Berechtigungen zum Erstellen einer Datenbank verfügen. Standardmäßig wird die neue Datenbank durch Klonen der Standard - Systemdatenbank erstellt werden template1 .

Syntax

Die grundlegende Syntax der Anweisung CREATE DATABASE lautet wie folgt:

CREATE DATABASE dbname;

wo dbname ist der Name einer Datenbank zu erstellen.

Beispiel

Das Folgende ist ein einfaches Beispiel, das erstellt wird testdb in Ihrem PostgreSQL-Schema

postgres=# CREATE DATABASE testdb;
postgres-#

Verwenden des Befehls createdb

Die ausführbare PostgreSQL-Befehlszeilendatei createdb ist ein Wrapper um den SQL-Befehl CREATE DATABASE . Der einzige Unterschied zwischen diesem Befehl und dem SQL-Befehl CREATE DATABASE besteht darin, dass der erstere direkt über die Befehlszeile ausgeführt werden kann und das Hinzufügen eines Kommentars zur Datenbank in einem einzigen Befehl ermöglicht.

Syntax

Die Syntax für createdb lautet wie folgt :

createdb [option...] [dbname [description]]

Parameter

In der folgenden Tabelle sind die Parameter mit ihren Beschreibungen aufgeführt.

S. Nr. Parameter & Beschreibung
1

dbname

Der Name einer zu erstellenden Datenbank.

2

description

Gibt einen Kommentar an, der der neu erstellten Datenbank zugeordnet werden soll.

3

options

Befehlszeilenargumente, die createdb akzeptiert.

Optionen

In der folgenden Tabelle sind die erstellten Befehlszeilenargumente aufgeführt.

S. Nr. Option & Beschreibung
1

-D tablespace

Gibt den Standardtabellenbereich für die Datenbank an.

2

-e

Echo die Befehle, die createb generiert und an den Server sendet.

3

-E encoding

Gibt das Zeichenkodierungsschema an, das in dieser Datenbank verwendet werden soll.

4

-l locale

Gibt das Gebietsschema an, das in dieser Datenbank verwendet werden soll.

5

-T template

Gibt die Vorlagendatenbank an, aus der diese Datenbank erstellt werden soll.

6

--help

Zeigen Sie Hilfe zu den Befehlszeilenargumenten von createdb an und beenden Sie das Programm.

7

-h host

Gibt den Hostnamen des Computers an, auf dem der Server ausgeführt wird.

8

-p port

Gibt den TCP-Port oder die lokale Unix-Domain-Socket-Dateierweiterung an, auf der der Server auf Verbindungen wartet.

9

-U username

Benutzername, unter dem eine Verbindung hergestellt werden soll.

10

-w

Geben Sie niemals eine Passwortabfrage aus.

11

-W

Erzwingen Sie, dass createdb zur Eingabe eines Kennworts auffordert, bevor Sie eine Verbindung zu einer Datenbank herstellen.

Öffnen Sie die Eingabeaufforderung und wechseln Sie in das Verzeichnis, in dem PostgreSQL installiert ist. Wechseln Sie in das Verzeichnis bin und führen Sie den folgenden Befehl aus, um eine Datenbank zu erstellen.

createdb -h localhost -p 5432 -U postgres testdb
password ******

Der oben angegebene Befehl fordert Sie zur Eingabe des Kennworts des PostgreSQL-Administrators auf postgres, standardmäßig. Geben Sie daher ein Kennwort ein und fahren Sie mit der Erstellung Ihrer neuen Datenbank fort

Sobald eine Datenbank mit einer der oben genannten Methoden erstellt wurde, können Sie sie in der Liste der verwendeten Datenbanken überprüfen \ldh Backslash el Befehl wie folgt -

postgres-# \l
                             List of databases
   Name    |  Owner   | Encoding | Collate | Ctype |   Access privileges   
-----------+----------+----------+---------+-------+-----------------------
 postgres  | postgres | UTF8     | C       | C     | 
 template0 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 template1 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 testdb    | postgres | UTF8     | C       | C     | 
(4 rows)

postgres-#

In diesem Kapitel werden verschiedene Methoden für den Zugriff auf die Datenbank erläutert. Angenommen, wir haben bereits in unserem vorherigen Kapitel eine Datenbank erstellt. Sie können die Datenbank mit einer der folgenden Methoden auswählen:

  • Datenbank-SQL-Eingabeaufforderung
  • OS-Eingabeaufforderung

Datenbank-SQL-Eingabeaufforderung

Angenommen, Sie haben Ihren PostgreSQL-Client bereits gestartet und sind an der folgenden SQL-Eingabeaufforderung gelandet:

postgres=#

Sie können die verfügbare Datenbankliste mit überprüfen \ldh Backslash el Befehl wie folgt -

postgres-# \l
                             List of databases
   Name    |  Owner   | Encoding | Collate | Ctype |   Access privileges   
-----------+----------+----------+---------+-------+-----------------------
 postgres  | postgres | UTF8     | C       | C     | 
 template0 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 template1 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 testdb    | postgres | UTF8     | C       | C     | 
(4 rows)

postgres-#

Geben Sie nun den folgenden Befehl ein, um eine gewünschte Datenbank zu verbinden / auszuwählen. Hier stellen wir eine Verbindung zur testdb- Datenbank her.

postgres=# \c testdb;
psql (9.2.4)
Type "help" for help.
You are now connected to database "testdb" as user "postgres".
testdb=#

OS-Eingabeaufforderung

Sie können Ihre Datenbank an der Eingabeaufforderung selbst auswählen, wenn Sie sich bei Ihrer Datenbank anmelden. Das Folgende ist ein einfaches Beispiel -

psql -h localhost -p 5432 -U postgress testdb
Password for user postgress: ****
psql (9.2.4)
Type "help" for help.
You are now connected to database "testdb" as user "postgres".
testdb=#

Sie sind jetzt bei PostgreSQL testdb angemeldet und können Ihre Befehle in testdb ausführen. Um die Datenbank zu verlassen, können Sie den Befehl \ q verwenden.

In diesem Kapitel wird erläutert, wie Sie die Datenbank in PostgreSQL löschen. Es gibt zwei Möglichkeiten, eine Datenbank zu löschen:

  • Verwenden von DROP DATABASE, einem SQL-Befehl.
  • Verwenden von dropdb eine ausführbare Befehlszeilendatei.
Seien Sie vorsichtig, bevor Sie diesen Vorgang ausführen, da das Löschen einer vorhandenen Datenbank zum Verlust vollständiger Informationen führen würde, die in der Datenbank gespeichert sind.

DROP DATABASE verwenden

Dieser Befehl löscht eine Datenbank. Es entfernt die Katalogeinträge für die Datenbank und löscht das Verzeichnis, das die Daten enthält. Es kann nur vom Datenbankeigentümer ausgeführt werden. Dieser Befehl kann nicht ausgeführt werden, während Sie oder eine andere Person mit der Zieldatenbank verbunden sind (stellen Sie eine Verbindung zu postgres oder einer anderen Datenbank her, um diesen Befehl auszuführen).

Syntax

Die Syntax für DROP DATABASE ist unten angegeben -

DROP DATABASE [ IF EXISTS ] name

Parameter

In der Tabelle sind die Parameter mit ihren Beschreibungen aufgeführt.

S. Nr. Parameter & Beschreibung
1

IF EXISTS

Geben Sie keinen Fehler aus, wenn die Datenbank nicht vorhanden ist. In diesem Fall wird ein Hinweis ausgegeben.

2

name

Der Name der zu entfernenden Datenbank.

Wir können keine Datenbank löschen , die offene Verbindungen hat, einschließlich unserer eigenen Verbindung von psql oder pgAdmin III . Wir müssen zu einer anderen Datenbank oder Vorlage1 wechseln, wenn wir die Datenbank löschen möchten, mit der wir derzeit verbunden sind. Daher ist es möglicherweise bequemer, stattdessen das Programm dropdb zu verwenden, bei dem es sich um einen Wrapper um diesen Befehl handelt.

Beispiel

Das Folgende ist ein einfaches Beispiel, das gelöscht wird testdb aus Ihrem PostgreSQL-Schema -

postgres=# DROP DATABASE testdb;
postgres-#

Dropdb-Befehl verwenden

PostgresSQL-Befehlszeile ausführbar dropdbist ein Befehlszeilen-Wrapper um den SQL-Befehl DROP DATABASE . Es gibt keinen effektiven Unterschied zwischen dem Löschen von Datenbanken über dieses Dienstprogramm und über andere Methoden für den Zugriff auf den Server. dropdb zerstört eine vorhandene PostgreSQL-Datenbank. Der Benutzer, der diesen Befehl ausführt, muss ein Datenbank-Superuser oder der Eigentümer der Datenbank sein.

Syntax

Die Syntax für dropdb lautet wie folgt :

dropdb  [option...] dbname

Parameter

In der folgenden Tabelle sind die Parameter mit ihren Beschreibungen aufgeführt

S. Nr. Parameter & Beschreibung
1

dbname

Der Name einer zu löschenden Datenbank.

2

option

Befehlszeilenargumente, die dropdb akzeptiert.

Optionen

In der folgenden Tabelle sind die Befehlszeilenargumente aufgeführt, die dropdb akzeptiert -

S. Nr. Option & Beschreibung
1

-e

Zeigt die Befehle an, die an den Server gesendet werden.

2

-i

Gibt eine Überprüfungsaufforderung aus, bevor destruktive Aktionen ausgeführt werden.

3

-V

Drucken Sie die Dropdb-Version aus und beenden Sie das Programm.

4

--if-exists

Geben Sie keinen Fehler aus, wenn die Datenbank nicht vorhanden ist. In diesem Fall wird ein Hinweis ausgegeben.

5

--help

Zeigen Sie Hilfe zu Dropdb-Befehlszeilenargumenten an und beenden Sie das Programm.

6

-h host

Gibt den Hostnamen des Computers an, auf dem der Server ausgeführt wird.

7

-p port

Gibt den TCP-Port oder die lokale UNIX-Domain-Socket-Dateierweiterung an, auf der der Server auf Verbindungen wartet.

8

-U username

Benutzername, unter dem eine Verbindung hergestellt werden soll.

9

-w

Geben Sie niemals eine Passwortabfrage aus.

10

-W

Erzwingen Sie, dass dropdb nach einem Kennwort fragt, bevor Sie eine Verbindung zu einer Datenbank herstellen.

11

--maintenance-db=dbname

Gibt den Namen der Datenbank an, zu der eine Verbindung hergestellt werden soll, um die Zieldatenbank zu löschen.

Beispiel

Das folgende Beispiel zeigt das Löschen einer Datenbank an der Eingabeaufforderung des Betriebssystems.

dropdb -h localhost -p 5432 -U postgress testdb
Password for user postgress: ****

Der obige Befehl löscht die Datenbank testdb. Hier habe ich das benutztpostgres (gefunden unter den pg_roles von template1) Benutzername zum Löschen der Datenbank.

Die PostgreSQL CREATE TABLE-Anweisung wird verwendet, um eine neue Tabelle in einer der angegebenen Datenbanken zu erstellen.

Syntax

Die grundlegende Syntax der Anweisung CREATE TABLE lautet wie folgt:

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE ist ein Schlüsselwort, das das Datenbanksystem anweist, eine neue Tabelle zu erstellen. Der eindeutige Name oder Bezeichner für die Tabelle folgt der Anweisung CREATE TABLE. Zu Beginn gehört die leere Tabelle in der aktuellen Datenbank dem Benutzer, der den Befehl ausgibt.

In Klammern wird dann die Liste angezeigt, in der jede Spalte in der Tabelle und der Datentyp definiert sind. Die Syntax wird anhand eines Beispiels deutlich.

Beispiele

Das folgende Beispiel zeigt eine COMPANY-Tabelle mit der ID als Primärschlüssel und NOT NULL. Dies sind die Einschränkungen, die zeigen, dass diese Felder beim Erstellen von Datensätzen in dieser Tabelle nicht NULL sein dürfen.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Lassen Sie uns eine weitere Tabelle erstellen, die wir in unseren Übungen in den folgenden Kapiteln verwenden werden -

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Mit können Sie überprüfen, ob Ihre Tabelle erfolgreich erstellt wurde \d Befehl, mit dem alle Tabellen in einer angehängten Datenbank aufgelistet werden.

testdb-# \d

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

List of relations
 Schema |    Name    | Type  |  Owner
--------+------------+-------+----------
 public | company    | table | postgres
 public | department | table | postgres
(2 rows)

Verwenden \d tablename um jede Tabelle wie unten gezeigt zu beschreiben -

testdb-# \d company

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

Table "public.company"
  Column   |     Type      | Modifiers
-----------+---------------+-----------
 id        | integer       | not null
 name      | text          | not null
 age       | integer       | not null
 address   | character(50) |
 salary    | real          |
 join_date | date          |
Indexes:
    "company_pkey" PRIMARY KEY, btree (id)

Die PostgreSQL DROP TABLE-Anweisung wird verwendet, um eine Tabellendefinition und alle zugehörigen Daten, Indizes, Regeln, Trigger und Einschränkungen für diese Tabelle zu entfernen.

Bei der Verwendung dieses Befehls müssen Sie vorsichtig sein, da nach dem Löschen einer Tabelle alle in der Tabelle verfügbaren Informationen für immer verloren gehen.

Syntax

Die grundlegende Syntax der DROP TABLE-Anweisung lautet wie folgt:

DROP TABLE table_name;

Beispiel

Wir hatten die Tabellen DEPARTMENT und COMPANY im vorherigen Kapitel erstellt. Überprüfen Sie zunächst diese Tabellen (verwenden Sie\d um die Tabellen aufzulisten) -

testdb-# \d

Dies würde das folgende Ergebnis erzeugen -

List of relations
 Schema |    Name    | Type  |  Owner
--------+------------+-------+----------
 public | company    | table | postgres
 public | department | table | postgres
(2 rows)

Dies bedeutet, dass DEPARTMENT- und COMPANY-Tabellen vorhanden sind. Lassen Sie sie uns also wie folgt fallen:

testdb=# drop table department, company;

Dies würde das folgende Ergebnis erzeugen -

DROP TABLE
testdb=# \d
relations found.
testdb=#

Die zurückgegebene Nachricht DROP TABLE zeigt an, dass der Befehl drop erfolgreich ausgeführt wurde.

EIN schemaist eine benannte Sammlung von Tabellen. Ein Schema kann auch Ansichten, Indizes, Sequenzen, Datentypen, Operatoren und Funktionen enthalten. Schemas sind analog zu Verzeichnissen auf Betriebssystemebene, außer dass Schemas nicht verschachtelt werden können. PostgreSQL-Anweisung CREATE SCHEMA erstellt ein Schema.

Syntax

Die grundlegende Syntax von CREATE SCHEMA lautet wie folgt:

CREATE SCHEMA name;

Wobei name der Name des Schemas ist.

Syntax zum Erstellen einer Tabelle im Schema

Die grundlegende Syntax zum Erstellen einer Tabelle im Schema lautet wie folgt:

CREATE TABLE myschema.mytable (
...
);

Beispiel

Sehen wir uns ein Beispiel zum Erstellen eines Schemas an. Stellen Sie eine Verbindung zur Datenbank testdb her und erstellen Sie ein Schema- Myschema wie folgt:

testdb=# create schema myschema;
CREATE SCHEMA

Die Meldung "SCHEMA ERSTELLEN" zeigt an, dass das Schema erfolgreich erstellt wurde.

Lassen Sie uns nun eine Tabelle im obigen Schema wie folgt erstellen:

testdb=# create table myschema.company(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25),
   SALARY   DECIMAL (18, 2),
   PRIMARY KEY (ID)
);

Dadurch wird eine leere Tabelle erstellt. Sie können die mit dem folgenden Befehl erstellte Tabelle überprüfen -

testdb=# select * from myschema.company;

Dies würde das folgende Ergebnis erzeugen -

id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)

Syntax zum Löschen des Schemas

Verwenden Sie den Befehl -, um ein Schema zu löschen, wenn es leer ist (alle darin enthaltenen Objekte wurden gelöscht).

DROP SCHEMA myschema;

Verwenden Sie den Befehl -, um ein Schema mit allen enthaltenen Objekten zu löschen.

DROP SCHEMA myschema CASCADE;

Vorteile der Verwendung eines Schemas

  • Es ermöglicht vielen Benutzern, eine Datenbank zu verwenden, ohne sich gegenseitig zu stören.

  • Es organisiert Datenbankobjekte in logischen Gruppen, um sie übersichtlicher zu gestalten.

  • Anwendungen von Drittanbietern können in separate Schemas eingefügt werden, damit sie nicht mit den Namen anderer Objekte kollidieren.

Das PostgreSQL INSERT INTOAnweisung ermöglicht es, neue Zeilen in eine Tabelle einzufügen. Als Ergebnis einer Abfrage kann eine einzelne Zeile oder mehrere Zeilen gleichzeitig eingefügt werden.

Syntax

Die grundlegende Syntax der INSERT INTO-Anweisung lautet wie folgt:

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);
  • Hier sind Spalte1, Spalte2, ... SpalteN die Namen der Spalten in der Tabelle, in die Sie Daten einfügen möchten.

  • Die Namen der Zielspalten können in beliebiger Reihenfolge aufgelistet werden. Die von der VALUES-Klausel oder -Abfrage bereitgestellten Werte sind der expliziten oder impliziten Spaltenliste von links nach rechts zugeordnet.

Möglicherweise müssen Sie den Spaltennamen nicht in der SQL-Abfrage angeben, wenn Sie Werte für alle Spalten der Tabelle hinzufügen. Stellen Sie jedoch sicher, dass die Reihenfolge der Werte in derselben Reihenfolge wie die Spalten in der Tabelle liegt. Die SQL INSERT INTO-Syntax lautet wie folgt:

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Ausgabe

In der folgenden Tabelle sind die Ausgabenachrichten und ihre Bedeutung zusammengefasst.

S. Nr. Ausgangsnachricht & Beschreibung
1

INSERT oid 1

Nachricht zurückgegeben, wenn nur eine Zeile eingefügt wurde. oid ist die numerische OID der eingefügten Zeile.

2

INSERT 0 #

Nachricht zurückgegeben, wenn mehr als eine Zeile eingefügt wurde. # ist die Anzahl der eingefügten Zeilen.

Beispiele

Lassen Sie uns die COMPANY-Tabelle in erstellen testdb wie folgt -

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   JOIN_DATE	  DATE
);

Im folgenden Beispiel wird eine Zeile in die Tabelle COMPANY eingefügt.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (1, 'Paul', 32, 'California', 20000.00,'2001-07-13');

Im folgenden Beispiel wird eine Zeile eingefügt. Hier wird die Gehaltsspalte weggelassen und hat daher den Standardwert -

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,JOIN_DATE) VALUES (2, 'Allen', 25, 'Texas', '2007-12-13');

Im folgenden Beispiel wird die DEFAULT-Klausel für die Spalte JOIN_DATE verwendet, anstatt einen Wert anzugeben.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (3, 'Teddy', 23, 'Norway', 20000.00, DEFAULT );

Im folgenden Beispiel werden mehrere Zeilen mit der mehrzeiligen VALUES-Syntax eingefügt.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00, '2007-12-13' ), (5, 'David', 27, 'Texas', 85000.00, '2007-12-13');

Alle obigen Anweisungen würden die folgenden Datensätze in der COMPANY-Tabelle erstellen. Im nächsten Kapitel erfahren Sie, wie Sie alle diese Datensätze aus einer Tabelle anzeigen.

ID        NAME        AGE        ADDRESS     SALARY	  JOIN_DATE
----      ----------  -----      ----------  -------      --------
1         Paul        32         California  20000.0      2001-07-13
2         Allen       25         Texas                    2007-12-13
3         Teddy       23         Norway      20000.0
4         Mark        25         Rich-Mond   65000.0      2007-12-13
5         David       27         Texas       85000.0      2007-12-13

PostgreSQL SELECTDie Anweisung wird verwendet, um die Daten aus einer Datenbanktabelle abzurufen, die Daten in Form einer Ergebnistabelle zurückgibt. Diese Ergebnistabellen werden als Ergebnismengen bezeichnet.

Syntax

Die grundlegende Syntax der SELECT-Anweisung lautet wie folgt:

SELECT column1, column2, columnN FROM table_name;

Hier sind Spalte1, Spalte2 ... die Felder einer Tabelle, deren Werte Sie abrufen möchten. Wenn Sie alle im Feld verfügbaren Felder abrufen möchten, können Sie die folgende Syntax verwenden:

SELECT * FROM table_name;

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel zeigt die Felder ID, Name und Gehalt der Kunden, die in der Tabelle CUSTOMERS verfügbar sind.

testdb=# SELECT ID, NAME, SALARY FROM COMPANY ;

Dies würde das folgende Ergebnis erzeugen -

id | name  | salary
 ----+-------+--------
   1 | Paul  |  20000
   2 | Allen |  15000
   3 | Teddy |  20000
   4 | Mark  |  65000
   5 | David |  85000
   6 | Kim   |  45000
   7 | James |  10000
(7 rows)

Wenn Sie alle Felder der Tabelle CUSTOMERS abrufen möchten, verwenden Sie die folgende Abfrage:

testdb=# SELECT * FROM COMPANY;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Was ist ein Operator in PostgreSQL?

Ein Operator ist ein reserviertes Wort oder ein Zeichen, das hauptsächlich in der WHERE-Klausel einer PostgreSQL-Anweisung verwendet wird, um Operationen auszuführen, z. B. Vergleiche und arithmetische Operationen.

Operatoren werden verwendet, um Bedingungen in einer PostgreSQL-Anweisung anzugeben und als Konjunktionen für mehrere Bedingungen in einer Anweisung zu dienen.

  • Rechenzeichen
  • Vergleichsoperatoren
  • Logische Operatoren
  • Bitweise Operatoren

PostgreSQL-Arithmetikoperatoren

Variable annehmen a hält 2 und variabel b hält 3, dann -

Beispiel

Operator Beschreibung Beispiel
+ Addition - Fügt Werte auf beiden Seiten des Operators hinzu a + b ergibt 5
- - Subtraktion - Subtrahiert den rechten Operanden vom linken Operanden a - b ergibt -1
* * Multiplikation - Multipliziert Werte auf beiden Seiten des Operators a * b ergibt 6
/. Division - Teilt den linken Operanden durch den rechten Operanden b / a ergibt 1
%. Modul - Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück b% a ergibt 1
^ Exponentiation - Dies gibt den Exponentenwert des rechten Operanden an a ^ b ergibt 8
| / Quadratwurzel | / 25.0 ergibt 5
|| / Kubikwurzel || / 27.0 ergibt 3
! Fakultät 5! wird 120 geben
!! Fakultät (Präfixoperator) !! 5 ergibt 120

PostgreSQL-Vergleichsoperatoren

Angenommen, Variable a hält 10 und Variable b hält 20, dann -

Beispiele anzeigen

Operator Beschreibung Beispiel
= Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. (a = b) ist nicht wahr.
! = Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. (a! = b) ist wahr.
<> Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. (a <> b) ist wahr.
> Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (a> b) ist nicht wahr.
< Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (a <b) ist wahr.
> = Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (a> = b) ist nicht wahr.
<= Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. (a <= b) ist wahr.

Logische PostgreSQL-Operatoren

Hier ist eine Liste aller in PostgresSQL verfügbaren logischen Operatoren.

Beispiele anzeigen

S. Nr. Betreiber & Beschreibung
1

AND

Der AND-Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer PostgresSQL-Anweisung.

2

NOT

Der NOT-Operator kehrt die Bedeutung des logischen Operators um, mit dem er verwendet wird. Z.B. NICHT EXISTIERT, NICHT ZWISCHEN, NICHT IN usw.This is negate operator.

3

OR

Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer PostgresSQL-Anweisung zu kombinieren.

PostgreSQL-Bitstring-Operatoren

Der bitweise Operator arbeitet mit Bits und führt eine bitweise Operation durch. Die Wahrheitstabelle für & und | ist wie folgt -

p q p & q p | q
0 0 0 0
0 1 0 1
1 1 1 1
1 0 0 1

Angenommen, A = 60; und B = 13; jetzt im Binärformat werden sie wie folgt sein -

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Beispiele anzeigen

Die von PostgreSQL unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt:

Operator Beschreibung Beispiel
& Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. (A & B) ergibt 12, was 0000 1100 ist
| Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. (A | B) ergibt 61, was 0011 1101 ist
~ Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits. (~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist.
<< Binärer Linksschaltoperator. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach links verschoben. Ein << 2 ergibt 240, was 1111 0000 ist
>> Binärer Rechtsschieber. Der Wert der linken Operanden wird um die Anzahl der vom rechten Operanden angegebenen Bits nach rechts verschoben. Eine >> 2 ergibt 15, was 0000 1111 ist
# bitweises XOR. A # B ergibt 49, was 0100 1001 ist

Ein Ausdruck ist eine Kombination aus einem oder mehreren Werten, Operatoren und PostgresSQL-Funktionen, die zu einem Wert ausgewertet werden.

PostgreSQL-AUSDRÜCKE sind wie Formeln und in Abfragesprache geschrieben. Sie können die Datenbank auch nach bestimmten Datensätzen abfragen.

Syntax

Betrachten Sie die grundlegende Syntax der SELECT-Anweisung wie folgt:

SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION | EXPRESSION];

Es gibt verschiedene Arten von PostgreSQL-Ausdrücken, die unten erwähnt werden -

PostgreSQL - Boolesche Ausdrücke

PostgreSQL Boolean Expressions rufen die Daten auf der Basis eines übereinstimmenden Einzelwerts ab. Es folgt die Syntax -

SELECT column1, column2, columnN
FROM table_name
WHERE SINGLE VALUE MATCHTING EXPRESSION;

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Hier ist das einfache Beispiel, das die Verwendung von PostgreSQL Boolean Expressions zeigt -

testdb=# SELECT * FROM COMPANY WHERE SALARY = 10000;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address  | salary
----+-------+-----+----------+--------
  7 | James |  24 | Houston  |  10000
(1 row)

PostgreSQL - Numerischer Ausdruck

Diese Ausdrücke werden verwendet, um eine beliebige mathematische Operation in einer Abfrage auszuführen. Es folgt die Syntax -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

Hier wird numerischer_Ausdruck für mathematische Ausdrücke oder beliebige Formeln verwendet. Das folgende Beispiel zeigt die Verwendung von numerischen SQL-Ausdrücken:

testdb=# SELECT (15 + 6) AS ADDITION ;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

addition
----------
       21
(1 row)

Es gibt mehrere integrierte Funktionen wie avg (), sum (), count (), um sogenannte aggregierte Datenberechnungen für eine Tabelle oder eine bestimmte Tabellenspalte durchzuführen.

testdb=# SELECT COUNT(*) AS "RECORDS" FROM COMPANY;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

RECORDS
---------
       7
(1 row)

PostgreSQL - Datumsausdrücke

Datumsausdrücke geben die aktuellen Systemdatum- und -zeitwerte zurück. Diese Ausdrücke werden bei verschiedenen Datenmanipulationen verwendet.

testdb=#  SELECT CURRENT_TIMESTAMP;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

now
-------------------------------
 2013-05-06 14:38:28.078+05:30
(1 row)

Die PostgreSQL WHERE-Klausel wird verwendet, um eine Bedingung anzugeben, während die Daten aus einer einzelnen Tabelle abgerufen oder mit mehreren Tabellen verknüpft werden.

Wenn die angegebene Bedingung erfüllt ist, wird nur dann ein bestimmter Wert aus der Tabelle zurückgegeben. Mit der WHERE-Klausel können Sie Zeilen herausfiltern, die nicht in die Ergebnismenge aufgenommen werden sollen.

Die WHERE-Klausel wird nicht nur in der SELECT-Anweisung verwendet, sondern auch in der UPDATE-, DELETE-Anweisung usw., die wir in den folgenden Kapiteln untersuchen würden.

Syntax

Die grundlegende Syntax der SELECT-Anweisung mit der WHERE-Klausel lautet wie folgt:

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

Sie können eine Suchbedingung mithilfe von Vergleichs- oder logischen Operatoren angeben . wie>, <, =, LIKE, NOT usw. Die folgenden Beispiele würden dieses Konzept verdeutlichen.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Hier sind einfache Beispiele für die Verwendung logischer PostgreSQL-Operatoren. Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 istAND Gehalt ist größer oder gleich 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age |  address   | salary
----+-------+-----+------------+--------
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(2 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 ist OR Gehalt ist größer oder gleich 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
(4 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE nicht NULL ist. Dies bedeutet, dass alle Datensätze vorhanden sind, da keiner der Datensätze AGE gleich NULL hat.

testdb=#  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
 ----+-------+-----+------------+--------
   1 | Paul  |  32 | California |  20000
   2 | Allen |  25 | Texas      |  15000
   3 | Teddy |  23 | Norway     |  20000
   4 | Mark  |  25 | Rich-Mond  |  65000
   5 | David |  27 | Texas      |  85000
   6 | Kim   |  22 | South-Hall |  45000
   7 | James |  24 | Houston    |  10000
(7 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen NAME mit 'Pa' beginnt, unabhängig davon, was nach 'Pa' steht.

testdb=# SELECT * FROM COMPANY WHERE NAME LIKE 'Pa%';

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name | age |address    | salary
----+------+-----+-----------+--------
  1 | Paul |  32 | California|  20000

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen der AGE-Wert entweder 25 oder 27 beträgt.

testdb=# SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(3 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen der AGE-Wert weder 25 noch 27 beträgt.

testdb=# SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  3 | Teddy |  23 | Norway     |  20000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(4 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, in denen der AGE-Wert zwischen 25 und 27 liegt.

testdb=# SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(3 rows)

Die folgende SELECT-Anweisung verwendet eine SQL-Unterabfrage, bei der die Unterabfrage alle Datensätze mit dem AGE-Feld mit SALARY> 65000 und höher findet. Die WHERE-Klausel wird zusammen mit dem EXISTS-Operator verwendet, um alle Datensätze aufzulisten, in denen AGE aus der externen Abfrage im zurückgegebenen Ergebnis vorhanden ist durch Unterabfrage -

testdb=# SELECT AGE FROM COMPANY
        WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

age
-----
  32
  25
  23
  25
  27
  22
  24
(7 rows)

Die folgende SELECT-Anweisung verwendet eine SQL-Unterabfrage, bei der die Unterabfrage alle Datensätze mit dem AGE-Feld mit SALARY> 65000 und höher findet. Die WHERE-Klausel wird zusammen mit dem Operator> verwendet, um alle Datensätze aufzulisten, bei denen AGE von einer externen Abfrage größer als das Alter in ist das von der Unterabfrage zurückgegebene Ergebnis -

testdb=# SELECT * FROM COMPANY
        WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name | age | address    | salary
----+------+-----+------------+--------
  1 | Paul |  32 | California |  20000

Das PostgreSQL AND und OROperatoren werden verwendet, um mehrere Bedingungen zu kombinieren, um ausgewählte Daten in einer PostgreSQL-Anweisung einzugrenzen. Diese beiden Operatoren werden als Konjunktivoperatoren bezeichnet.

Diese Operatoren bieten die Möglichkeit, mehrere Vergleiche mit verschiedenen Operatoren in derselben PostgreSQL-Anweisung durchzuführen.

Der AND-Operator

Das ANDDer Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer PostgreSQL-Anweisung. Bei Verwendung des AND-Operators wird die vollständige Bedingung als wahr angenommen, wenn alle Bedingungen erfüllt sind. Zum Beispiel ist [Bedingung1] UND [Bedingung2] nur dann wahr, wenn sowohl Bedingung1 als auch Bedingung2 wahr sind.

Syntax

Die grundlegende Syntax des AND-Operators mit der WHERE-Klausel lautet wie folgt:

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Sie können N Bedingungen mit dem Operator AND kombinieren. Damit eine Aktion von der PostgreSQL-Anweisung ausgeführt werden kann, unabhängig davon, ob es sich um eine Transaktion oder eine Abfrage handelt, müssen alle durch das UND getrennten Bedingungen TRUE sein.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 ist AND Gehalt ist größer oder gleich 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(2 rows)

Der OP-Operator

Der OR-Operator wird auch verwendet, um mehrere Bedingungen in der WHERE-Klausel einer PostgreSQL-Anweisung zu kombinieren. Bei Verwendung des ODER-Operators wird die vollständige Bedingung als wahr angenommen, wenn mindestens eine der Bedingungen wahr ist. Zum Beispiel ist [Bedingung1] ODER [Bedingung2] wahr, wenn entweder Bedingung1 oder Bedingung2 wahr ist.

Syntax

Die grundlegende Syntax des OR-Operators mit der WHERE-Klausel lautet wie folgt:

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Sie können N Bedingungen mit dem Operator OR kombinieren. Damit eine Aktion von der PostgreSQL-Anweisung ausgeführt werden kann, unabhängig davon, ob es sich um eine Transaktion oder eine Abfrage handelt, muss nur EINE der durch das ODER getrennten Bedingungen WAHR sein.

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen:

# select * from COMPANY;
  id | name  | age | address   | salary
 ----+-------+-----+-----------+--------
   1 | Paul  |  32 | California|  20000
   2 | Allen |  25 | Texas     |  15000
   3 | Teddy |  23 | Norway    |  20000
   4 | Mark  |  25 | Rich-Mond |  65000
   5 | David |  27 | Texas     |  85000
   6 | Kim   |  22 | South-Hall|  45000
   7 | James |  24 | Houston   |  10000
(7 rows)

Die folgende SELECT-Anweisung listet alle Datensätze auf, bei denen AGE größer oder gleich 25 ist OR Gehalt ist größer oder gleich 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(4 rows)

Das PostgreSQL UPDATEDie Abfrage wird verwendet, um die vorhandenen Datensätze in einer Tabelle zu ändern. Sie können die WHERE-Klausel mit der UPDATE-Abfrage verwenden, um die ausgewählten Zeilen zu aktualisieren. Andernfalls würden alle Zeilen aktualisiert.

Syntax

Die grundlegende Syntax der UPDATE-Abfrage mit der WHERE-Klausel lautet wie folgt:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Sie können N Bedingungen mit UND- oder ODER-Operatoren kombinieren.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit den folgenden Aufzeichnungen:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel veranschaulicht die ADRESSE für einen Kunden mit der ID 6 -

testdb=# UPDATE COMPANY SET SALARY = 15000 WHERE ID = 3;

Die Tabelle COMPANY würde nun die folgenden Datensätze enthalten:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  3 | Teddy |  23 | Norway     |  15000
(7 rows)

Wenn Sie alle ADDRESS- und SALARY-Spaltenwerte in der COMPANY-Tabelle ändern möchten, müssen Sie die WHERE-Klausel nicht verwenden, und die UPDATE-Abfrage lautet wie folgt:

testdb=# UPDATE COMPANY SET ADDRESS = 'Texas', SALARY=20000;

Die Tabelle COMPANY enthält nun die folgenden Datensätze:

id | name  | age | address | salary
----+-------+-----+---------+--------
  1 | Paul  |  32 | Texas   |  20000
  2 | Allen |  25 | Texas   |  20000
  4 | Mark  |  25 | Texas   |  20000
  5 | David |  27 | Texas   |  20000
  6 | Kim   |  22 | Texas   |  20000
  7 | James |  24 | Texas   |  20000
  3 | Teddy |  23 | Texas   |  20000
(7 rows)

Das PostgreSQL DELETEDie Abfrage wird verwendet, um die vorhandenen Datensätze aus einer Tabelle zu löschen. Sie können die WHERE-Klausel mit der DELETE-Abfrage verwenden, um die ausgewählten Zeilen zu löschen. Andernfalls würden alle Datensätze gelöscht.

Syntax

Die grundlegende Syntax der DELETE-Abfrage mit der WHERE-Klausel lautet wie folgt:

DELETE FROM table_name
WHERE [condition];

Sie können N Bedingungen mit UND- oder ODER-Operatoren kombinieren.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit den folgenden Aufzeichnungen:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das Folgende ist ein Beispiel, das einen Kunden mit einer ID von 7 LÖSCHEN würde -

testdb=# DELETE FROM COMPANY WHERE ID = 2;

Die Tabelle COMPANY enthält nun die folgenden Datensätze:

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
(6 rows)

Wenn Sie alle Datensätze aus der Tabelle COMPANY LÖSCHEN möchten, müssen Sie die WHERE-Klausel nicht für DELETE-Abfragen verwenden.

testdb=# DELETE FROM COMPANY;

Die COMPANY-Tabelle enthält jetzt keinen Datensatz, da alle Datensätze durch die DELETE-Anweisung gelöscht wurden.

Das PostgreSQL LIKEDer Operator wird verwendet, um Textwerte mithilfe von Platzhaltern mit einem Muster abzugleichen. Wenn der Suchausdruck mit dem Musterausdruck abgeglichen werden kann, gibt der LIKE-Operator true zurück1.

In Verbindung mit dem Operator LIKE werden zwei Platzhalter verwendet.

  • Das Prozentzeichen (%)
  • Der Unterstrich (_)

Das Prozentzeichen steht für null, eins oder mehrere Zahlen oder Zeichen. Der Unterstrich steht für eine einzelne Zahl oder ein einzelnes Zeichen. Diese Symbole können in Kombinationen verwendet werden.

Wenn eines dieser beiden Zeichen nicht in Verbindung mit der LIKE-Klausel verwendet wird, verhält sich das LIKE wie der Gleichheitsoperator.

Syntax

Die grundlegende Syntax von% und _ lautet wie folgt:

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Sie können N Bedingungen mit UND- oder ODER-Operatoren kombinieren. Hier kann XXXX ein beliebiger numerischer Wert oder ein Zeichenfolgenwert sein.

Beispiel

Hier einige Beispiele, die zeigen, wo ein WHERE-Teil eine andere LIKE-Klausel mit den Operatoren '%' und '_' hat -

S. Nr. Aussage & Beschreibung
1

WHERE SALARY::text LIKE '200%'

Findet alle Werte, die mit 200 beginnen

2

WHERE SALARY::text LIKE '%200%'

Findet alle Werte mit 200 an einer beliebigen Position

3

WHERE SALARY::text LIKE '_00%'

Findet alle Werte mit 00 an der zweiten und dritten Position

4

WHERE SALARY::text LIKE '2_%_%'

Findet alle Werte, die mit 2 beginnen und mindestens 3 Zeichen lang sind

5

WHERE SALARY::text LIKE '%2'

Findet alle Werte, die mit 2 enden

6

WHERE SALARY::text LIKE '_2%3'

Findet alle Werte, bei denen 2 an zweiter Stelle steht und die mit einer 3 enden

7

WHERE SALARY::text LIKE '2___3'

Findet alle Werte in einer fünfstelligen Zahl, die mit 2 beginnen und mit 3 enden

Postgres LIKE ist nur String-Vergleich. Daher müssen wir die Ganzzahlspalte wie in den obigen Beispielen explizit in einen String umwandeln.

Nehmen wir ein reales Beispiel, betrachten wir die Tabelle UNTERNEHMEN mit den folgenden Aufzeichnungen:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel zeigt alle Datensätze aus der COMPANY-Tabelle, in der AGE mit 2 beginnt.

testdb=# SELECT * FROM COMPANY WHERE AGE::text LIKE '2%';

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  8 | Paul  |  24 | Houston     |  20000
(7 rows)

Das folgende Beispiel zeigt alle Datensätze aus der COMPANY-Tabelle an, in denen ADDRESS einen Bindestrich (-) im Text enthält.

testdb=# SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

Dies würde das folgende Ergebnis erzeugen -

id | name | age |                      address              | salary
----+------+-----+-------------------------------------------+--------
  4 | Mark |  25 | Rich-Mond                                 |  65000
  6 | Kim  |  22 | South-Hall                                |  45000
(2 rows)

Das PostgreSQL LIMIT Klausel wird verwendet, um die von der SELECT-Anweisung zurückgegebene Datenmenge zu begrenzen.

Syntax

Die grundlegende Syntax der SELECT-Anweisung mit der LIMIT-Klausel lautet wie folgt:

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

Das Folgende ist die Syntax der LIMIT-Klausel, wenn sie zusammen mit der OFFSET-Klausel verwendet wird:

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows] OFFSET [row num]

Mit LIMIT und OFFSET können Sie nur einen Teil der Zeilen abrufen, die vom Rest der Abfrage generiert werden.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel begrenzt die Zeile in der Tabelle entsprechend der Anzahl der Zeilen, die Sie aus der Tabelle abrufen möchten.

testdb=# SELECT * FROM COMPANY LIMIT 4;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
(4 rows)

In bestimmten Situationen müssen Sie jedoch möglicherweise eine Reihe von Datensätzen von einem bestimmten Versatz abholen. Hier ist ein Beispiel, das drei Datensätze ab der dritten Position aufnimmt -

testdb=# SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
(3 rows)

Das PostgreSQL ORDER BY Klausel wird verwendet, um die Daten in aufsteigender oder absteigender Reihenfolge basierend auf einer oder mehreren Spalten zu sortieren.

Syntax

Die grundlegende Syntax der ORDER BY-Klausel lautet wie folgt:

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Sie können mehr als eine Spalte in der ORDER BY-Klausel verwenden. Stellen Sie sicher, dass jede Spalte, die Sie zum Sortieren verwenden, in der Spaltenliste verfügbar sein sollte.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel zeigt das Ergebnis in aufsteigender Reihenfolge nach GEHALT -

testdb=# SELECT * FROM COMPANY ORDER BY AGE ASC;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address    | salary
 ----+-------+-----+------------+--------
   6 | Kim   |  22 | South-Hall |  45000
   3 | Teddy |  23 | Norway     |  20000
   7 | James |  24 | Houston    |  10000
   8 | Paul  |  24 | Houston    |  20000
   4 | Mark  |  25 | Rich-Mond  |  65000
   2 | Allen |  25 | Texas      |  15000
   5 | David |  27 | Texas      |  85000
   1 | Paul  |  32 | California |  20000
   9 | James |  44 | Norway     |   5000
  10 | James |  45 | Texas      |   5000
(10 rows)

Das folgende Beispiel zeigt das Ergebnis in aufsteigender Reihenfolge nach NAME und SALARY -

testdb=# SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address      | salary
----+-------+-----+--------------+--------
  2 | Allen |  25 | Texas        |  15000
  5 | David |  27 | Texas        |  85000
 10 | James |  45 | Texas        |   5000
  9 | James |  44 | Norway       |   5000
  7 | James |  24 | Houston      |  10000
  6 | Kim   |  22 | South-Hall   |  45000
  4 | Mark  |  25 | Rich-Mond    |  65000
  1 | Paul  |  32 | California   |  20000
  8 | Paul  |  24 | Houston      |  20000
  3 | Teddy |  23 | Norway       |  20000
(10 rows)

Das folgende Beispiel zeigt das Ergebnis in absteigender Reihenfolge nach NAME -

testdb=# SELECT * FROM COMPANY ORDER BY NAME DESC;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  3 | Teddy |  23 | Norway     |  20000
  1 | Paul  |  32 | California |  20000
  8 | Paul  |  24 | Houston    |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  9 | James |  44 | Norway     |   5000
 10 | James |  45 | Texas      |   5000
  5 | David |  27 | Texas      |  85000
  2 | Allen |  25 | Texas      |  15000
(10 rows)

Das PostgreSQL GROUP BYDie Klausel wird in Zusammenarbeit mit der SELECT-Anweisung verwendet, um die Zeilen in einer Tabelle mit identischen Daten zu gruppieren. Dies geschieht, um Redundanz in der Ausgabe zu beseitigen und / oder Aggregate zu berechnen, die für diese Gruppen gelten.

Die GROUP BY-Klausel folgt der WHERE-Klausel in einer SELECT-Anweisung und steht vor der ORDER BY-Klausel.

Syntax

Die grundlegende Syntax der GROUP BY-Klausel ist unten angegeben. Die GROUP BY-Klausel muss den Bedingungen in der WHERE-Klausel entsprechen und der ORDER BY-Klausel vorangehen, falls eine verwendet wird.

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

Sie können mehr als eine Spalte in der GROUP BY-Klausel verwenden. Stellen Sie sicher, dass jede Spalte, die Sie zum Gruppieren verwenden, in der Spaltenliste verfügbar sein sollte.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Wenn Sie den Gesamtlohn jedes Kunden wissen möchten, lautet die GROUP BY-Abfrage wie folgt:

testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

Dies würde das folgende Ergebnis erzeugen -

name  |  sum
 -------+-------
  Teddy | 20000
  Paul  | 20000
  Mark  | 65000
  David | 85000
  Allen | 15000
  Kim   | 45000
  James | 10000
(7 rows)

Lassen Sie uns nun drei weitere Datensätze in der COMPANY-Tabelle mit den folgenden INSERT-Anweisungen erstellen:

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00);
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00);
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);

Unsere Tabelle enthält nun die folgenden Datensätze mit doppelten Namen:

id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

Verwenden wir wieder dieselbe Anweisung, um alle Datensätze mithilfe der NAME-Spalte wie folgt zu gruppieren:

testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

Dies würde das folgende Ergebnis erzeugen -

name  |  sum
-------+-------
 Allen | 15000
 David | 85000
 James | 20000
 Kim   | 45000
 Mark  | 65000
 Paul  | 40000
 Teddy | 20000
(7 rows)

Verwenden wir die ORDER BY-Klausel zusammen mit der GROUP BY-Klausel wie folgt:

testdb=#  SELECT NAME, SUM(SALARY)
         FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

Dies würde das folgende Ergebnis erzeugen -

name  |  sum
-------+-------
 Teddy | 20000
 Paul  | 40000
 Mark  | 65000
 Kim   | 45000
 James | 20000
 David | 85000
 Allen | 15000
(7 rows)

In PostgreSQL bietet die WITH-Abfrage eine Möglichkeit, Hilfsanweisungen zur Verwendung in einer größeren Abfrage zu schreiben. Es hilft dabei, komplizierte und große Abfragen in einfachere Formen zu zerlegen, die leicht lesbar sind. Diese Anweisungen, die häufig als Common Table Expressions oder CTEs bezeichnet werden, können als Definition temporärer Tabellen angesehen werden, die nur für eine Abfrage vorhanden sind.

Die WITH-Abfrage als CTE-Abfrage ist besonders nützlich, wenn die Unterabfrage mehrmals ausgeführt wird. Es ist ebenso hilfreich anstelle von temporären Tabellen. Es berechnet die Aggregation einmal und ermöglicht es uns, sie in den Abfragen anhand ihres Namens (möglicherweise mehrmals) zu referenzieren.

Die WITH-Klausel muss definiert werden, bevor sie in der Abfrage verwendet wird.

Syntax

Die grundlegende Syntax der WITH-Abfrage lautet wie folgt:

WITH
   name_for_summary_data AS (
      SELECT Statement)
   SELECT columns
   FROM name_for_summary_data
   WHERE conditions <=> (
      SELECT column
      FROM name_for_summary_data)
   [ORDER BY columns]

Wobei name_for_summary_data der Name der WITH-Klausel ist. Der Name_für_Zusammenfassung_Daten kann mit einem vorhandenen Tabellennamen identisch sein und hat Vorrang.

Sie können datenmodifizierende Anweisungen (INSERT, UPDATE oder DELETE) in WITH verwenden. Auf diese Weise können Sie mehrere verschiedene Vorgänge in derselben Abfrage ausführen.

Rekursiv MIT

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Schreiben wir nun eine Abfrage mit der WITH-Klausel, um die Datensätze aus der obigen Tabelle wie folgt auszuwählen:

With CTE AS
(Select
 ID
, NAME
, AGE
, ADDRESS
, SALARY
FROM COMPANY )
Select * From CTE;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Schreiben wir nun eine Abfrage mit dem Schlüsselwort RECURSIVE zusammen mit der WITH-Klausel, um die Summe der Gehälter unter 20000 wie folgt zu ermitteln:

WITH RECURSIVE t(n) AS (
   VALUES (0)
   UNION ALL
   SELECT SALARY FROM COMPANY WHERE SALARY < 20000
)
SELECT sum(n) FROM t;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

sum
-------
 25000
(1 row)

Schreiben wir eine Abfrage mit datenmodifizierenden Anweisungen zusammen mit der WITH-Klausel, wie unten gezeigt.

Erstellen Sie zunächst eine Tabelle COMPANY1 ähnlich der Tabelle COMPANY. Die Abfrage im Beispiel verschiebt effektiv Zeilen von UNTERNEHMEN nach UNTERNEHMEN1. Das DELETE in WITH löscht die angegebenen Zeilen aus COMPANY und gibt ihren Inhalt mithilfe seiner RETURNING-Klausel zurück. und dann liest die primäre Abfrage diese Ausgabe und fügt sie in COMPANY1 TABLE - ein.

CREATE TABLE COMPANY1(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

WITH moved_rows AS (
   DELETE FROM COMPANY
   WHERE
      SALARY >= 30000
   RETURNING *
)
INSERT INTO COMPANY1 (SELECT * FROM moved_rows);

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

INSERT 0 3

Die Datensätze in den Tabellen COMPANY und COMPANY1 lauten nun wie folgt:

testdb=# SELECT * FROM COMPANY;
 id | name  | age |  address   | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  7 | James |  24 | Houston    |  10000
(4 rows)


testdb=# SELECT * FROM COMPANY1;
 id | name  | age | address | salary
----+-------+-----+-------------+--------
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
(3 rows)

Mit der HAVING-Klausel können wir bestimmte Zeilen auswählen, in denen das Ergebnis der Funktion eine bestimmte Bedingung erfüllt.

Mit der WHERE-Klausel werden Bedingungen für die ausgewählten Spalten festgelegt, während mit der HAVING-Klausel Bedingungen für Gruppen festgelegt werden, die mit der GROUP BY-Klausel erstellt wurden.

Syntax

Das Folgende ist die Position der HAVING-Klausel in einer SELECT-Abfrage -

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

Die HAVING-Klausel muss in einer Abfrage der GROUP BY-Klausel folgen und bei Verwendung auch der ORDER BY-Klausel vorangehen. Das Folgende ist die Syntax der SELECT-Anweisung, einschließlich der HAVING-Klausel -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Das folgende Beispiel zeigt einen Datensatz an, für den die Anzahl der Namen weniger als 2 beträgt.

testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) < 2;

Dies würde das folgende Ergebnis erzeugen -

name
 -------
  Teddy
  Paul
  Mark
  David
  Allen
  Kim
  James
(7 rows)

Lassen Sie uns nun drei weitere Datensätze in der COMPANY-Tabelle mit den folgenden INSERT-Anweisungen erstellen:

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00);
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00);
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);

Unsere Tabelle enthält nun die folgenden Datensätze mit doppelten Namen:

id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

Das folgende Beispiel zeigt einen Datensatz an, für den die Anzahl der Namen größer als 1 ist.

testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) > 1;

Dies würde das folgende Ergebnis erzeugen -

name
-------
 Paul
 James
(2 rows)

Das PostgreSQL DISTINCT Das Schlüsselwort wird in Verbindung mit der SELECT-Anweisung verwendet, um alle doppelten Datensätze zu entfernen und nur eindeutige Datensätze abzurufen.

Es kann vorkommen, dass eine Tabelle mehrere doppelte Datensätze enthält. Beim Abrufen solcher Datensätze ist es sinnvoller, nur eindeutige Datensätze abzurufen, anstatt doppelte Datensätze abzurufen.

Syntax

Die grundlegende Syntax des DISTINCT-Schlüsselworts zum Entfernen doppelter Datensätze lautet wie folgt:

SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Fügen wir dieser Tabelle zwei weitere Datensätze wie folgt hinzu:

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (8, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (9, 'Allen', 25, 'Texas', 15000.00 );

Nun wären die Datensätze in der COMPANY-Tabelle -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  8 | Paul  |  32 | California |  20000
  9 | Allen |  25 | Texas      |  15000
(9 rows)

Lassen Sie uns zunächst sehen, wie die folgende SELECT-Abfrage doppelte Gehaltsdatensätze zurückgibt.

testdb=# SELECT name FROM COMPANY;

Dies würde das folgende Ergebnis erzeugen -

name
-------
 Paul
 Allen
 Teddy
 Mark
 David
 Kim
 James
 Paul
 Allen
(9 rows)

Lassen Sie uns jetzt verwenden DISTINCT Schlüsselwort mit der obigen SELECT-Abfrage und sehen Sie das Ergebnis -

testdb=# SELECT DISTINCT name FROM COMPANY;

Dies würde das folgende Ergebnis erzeugen, wenn wir keinen doppelten Eintrag haben -

name
-------
 Teddy
 Paul
 Mark
 David
 Allen
 Kim
 James
(7 rows)

Einschränkungen sind die Regeln, die für Datenspalten in der Tabelle gelten. Diese werden verwendet, um zu verhindern, dass ungültige Daten in die Datenbank eingegeben werden. Dies stellt die Genauigkeit und Zuverlässigkeit der Daten in der Datenbank sicher.

Einschränkungen können Spalten- oder Tabellenebene sein. Einschränkungen auf Spaltenebene werden nur auf eine Spalte angewendet, während Einschränkungen auf Tabellenebene auf die gesamte Tabelle angewendet werden. Das Definieren eines Datentyps für eine Spalte ist eine Einschränkung für sich. Beispielsweise beschränkt eine Spalte vom Typ DATE die Spalte auf gültige Daten.

Die folgenden Einschränkungen werden häufig in PostgreSQL verwendet.

  • NOT NULL Constraint - Stellt sicher, dass eine Spalte keinen NULL-Wert haben kann.

  • UNIQUE Constraint - Stellt sicher, dass alle Werte in einer Spalte unterschiedlich sind.

  • PRIMARY Key - Identifiziert jede Zeile / jeden Datensatz in einer Datenbanktabelle eindeutig.

  • FOREIGN Key - Beschränkt Daten basierend auf Spalten in anderen Tabellen.

  • CHECK Constraint - Die CHECK-Einschränkung stellt sicher, dass alle Werte in einer Spalte bestimmte Bedingungen erfüllen.

  • EXCLUSION Constraint - Die EXCLUDE-Einschränkung stellt sicher, dass beim Vergleich von zwei Zeilen in den angegebenen Spalten oder Ausdrücken mit den angegebenen Operatoren nicht alle diese Vergleiche TRUE zurückgeben.

NICHT NULL Einschränkung

Standardmäßig kann eine Spalte NULL-Werte enthalten. Wenn Sie nicht möchten, dass eine Spalte einen NULL-Wert hat, müssen Sie eine solche Einschränkung für diese Spalte definieren und angeben, dass NULL für diese Spalte jetzt nicht zulässig ist. Eine NOT NULL-Einschränkung wird immer als Spalteneinschränkung geschrieben.

Ein NULL ist nicht dasselbe wie keine Daten. Vielmehr handelt es sich um unbekannte Daten.

Beispiel

Die folgende PostgreSQL-Anweisung erstellt beispielsweise eine neue Tabelle mit dem Namen COMPANY1 und fügt fünf Spalten hinzu, von denen drei, ID und NAME und AGE, angeben, dass NULL-Werte nicht akzeptiert werden sollen.

CREATE TABLE COMPANY1(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Einzigartige Beschränkung

Die UNIQUE-Einschränkung verhindert, dass zwei Datensätze in einer bestimmten Spalte identische Werte haben. In der Tabelle UNTERNEHMEN möchten Sie beispielsweise verhindern, dass zwei oder mehr Personen das gleiche Alter haben.

Beispiel

Mit der folgenden PostgreSQL-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY3 erstellt und fünf Spalten hinzugefügt. Hier ist die Spalte AGE auf EINZIGARTIG gesetzt, sodass Sie nicht zwei Datensätze mit demselben Alter haben können -

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

PRIMARY KEY-Einschränkung

Die PRIMARY KEY-Einschränkung identifiziert jeden Datensatz in einer Datenbanktabelle eindeutig. Es können mehrere EINZIGARTIGE Spalten vorhanden sein, jedoch nur ein Primärschlüssel in einer Tabelle. Primärschlüssel sind beim Entwerfen der Datenbanktabellen wichtig. Primärschlüssel sind eindeutige IDs.

Wir verwenden sie, um auf Tabellenzeilen zu verweisen. Primärschlüssel werden beim Erstellen von Beziehungen zwischen Tabellen zu Fremdschlüsseln in anderen Tabellen. Aufgrund einer langjährigen Codierungsüberwachung können Primärschlüssel in SQLite NULL sein. Dies ist bei anderen Datenbanken nicht der Fall

Ein Primärschlüssel ist ein Feld in einer Tabelle, das jede Zeile / jeden Datensatz in einer Datenbanktabelle eindeutig identifiziert. Primärschlüssel müssen eindeutige Werte enthalten. Eine Primärschlüsselspalte darf keine NULL-Werte haben.

Eine Tabelle kann nur einen Primärschlüssel haben, der aus einzelnen oder mehreren Feldern bestehen kann. Wenn mehrere Felder als Primärschlüssel verwendet werden, werden sie als a bezeichnetcomposite key.

Wenn für eine Tabelle in einem oder mehreren Feldern ein Primärschlüssel definiert ist, können nicht zwei Datensätze mit demselben Wert für diese Felder vorhanden sein.

Beispiel

Sie haben oben bereits verschiedene Beispiele gesehen, in denen wir die Tabelle COMAPNY4 mit der ID als Primärschlüssel erstellt haben.

CREATE TABLE COMPANY4(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

AUSLÄNDISCHE SCHLÜSSELBESCHRÄNKUNG

Eine Fremdschlüsseleinschränkung gibt an, dass die Werte in einer Spalte (oder einer Gruppe von Spalten) mit den Werten in einer Zeile einer anderen Tabelle übereinstimmen müssen. Wir sagen, dies behält die referenzielle Integrität zwischen zwei verwandten Tabellen bei. Sie werden als Fremdschlüssel bezeichnet, da die Einschränkungen fremd sind. das heißt, außerhalb des Tisches. Fremdschlüssel werden manchmal als Referenzschlüssel bezeichnet.

Beispiel

Mit der folgenden PostgreSQL-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY5 erstellt und fünf Spalten hinzugefügt.

CREATE TABLE COMPANY6(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Mit der folgenden PostgreSQL-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen DEPARTMENT1 erstellt, die drei Spalten hinzufügt. Die Spalte EMP_ID ist der Fremdschlüssel und verweist auf das ID-Feld der Tabelle COMPANY6.

CREATE TABLE DEPARTMENT1(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      references COMPANY6(ID)
);

Einschränkung prüfen

Die CHECK-Einschränkung ermöglicht es einer Bedingung, den in einen Datensatz eingegebenen Wert zu überprüfen. Wenn die Bedingung als falsch ausgewertet wird, verletzt der Datensatz die Einschränkung und wird nicht in die Tabelle eingetragen.

Beispiel

Mit der folgenden PostgreSQL-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY5 erstellt und fünf Spalten hinzugefügt. Hier fügen wir eine Spalte CHECK with SALARY hinzu, damit Sie kein SALARY als Null haben können.

CREATE TABLE COMPANY5(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

AUSSCHLUSS Einschränkung

Ausschlussbeschränkungen stellen sicher, dass beim Vergleich von zwei Zeilen in den angegebenen Spalten oder Ausdrücken mit den angegebenen Operatoren mindestens einer dieser Operatorvergleiche false oder null zurückgibt.

Beispiel

Mit der folgenden PostgreSQL-Anweisung wird beispielsweise eine neue Tabelle mit dem Namen COMPANY7 erstellt und fünf Spalten hinzugefügt. Hier fügen wir eine EXCLUDE-Einschränkung hinzu -

CREATE TABLE COMPANY7(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT,
   AGE            INT  ,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   EXCLUDE USING gist
   (NAME WITH =,
   AGE WITH <>)
);

Hier ist USING gist die Art von Index, die erstellt und für die Durchsetzung verwendet werden soll.

Sie müssen den Befehl CREATE EXTENSION btree_gist einmal pro Datenbank ausführen . Dadurch wird die Erweiterung btree_gist installiert, die die Ausschlussbeschränkungen für einfache skalare Datentypen definiert.

Da wir durchgesetzt haben, dass das Alter gleich sein muss, lassen Sie uns dies sehen, indem wir Datensätze in die Tabelle einfügen -

INSERT INTO COMPANY7 VALUES(1, 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY7 VALUES(2, 'Paul', 32, 'Texas', 20000.00 );
INSERT INTO COMPANY7 VALUES(3, 'Paul', 42, 'California', 20000.00 );

Für die ersten beiden INSERT-Anweisungen werden die Datensätze zur Tabelle COMPANY7 hinzugefügt. Für die dritte INSERT-Anweisung wird der folgende Fehler angezeigt:

ERROR:  conflicting key value violates exclusion constraint "company7_name_age_excl"
DETAIL:  Key (name, age)=(Paul, 42) conflicts with existing key (name, age)=(Paul, 32).

Einschränkungen fallen lassen

Um eine Einschränkung zu entfernen, müssen Sie ihren Namen kennen. Wenn der Name bekannt ist, kann er leicht gelöscht werden. Andernfalls müssen Sie den vom System generierten Namen herausfinden. Der Tabellenname des Befehls psql \ d kann hier hilfreich sein. Die allgemeine Syntax lautet -

ALTER TABLE table_name DROP CONSTRAINT some_name;

Das PostgreSQL JoinsKlausel wird verwendet, um Datensätze aus zwei oder mehr Tabellen in einer Datenbank zu kombinieren. Ein JOIN ist ein Mittel zum Kombinieren von Feldern aus zwei Tabellen unter Verwendung gemeinsamer Werte.

Join-Typen in PostgreSQL sind -

  • Das CROSS JOIN
  • Der INNERE JOIN
  • Die linke linke Verbindung
  • Der rechte äußere Beitritt
  • Der VOLLSTÄNDIGE OUTER JOIN

Bevor wir fortfahren, betrachten wir zwei Tabellen, UNTERNEHMEN und ABTEILUNG. Wir haben bereits INSERT-Anweisungen zum Auffüllen der COMPANY-Tabelle gesehen. Nehmen wir also einfach die Liste der in der COMPANY-Tabelle verfügbaren Datensätze an -

id | name  | age | address   | salary | join_date
----+-------+-----+-----------+--------+-----------
  1 | Paul  |  32 | California|  20000 | 2001-07-13
  3 | Teddy |  23 | Norway    |  20000 |
  4 | Mark  |  25 | Rich-Mond |  65000 | 2007-12-13
  5 | David |  27 | Texas     |  85000 | 2007-12-13
  2 | Allen |  25 | Texas     |        | 2007-12-13
  8 | Paul  |  24 | Houston   |  20000 | 2005-07-13
  9 | James |  44 | Norway    |   5000 | 2005-07-13
 10 | James |  45 | Texas     |   5000 | 2005-07-13

Eine andere Tabelle ist DEPARTMENT, hat die folgende Definition -

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Hier ist die Liste der INSERT-Anweisungen zum Auffüllen der DEPARTMENT-Tabelle:

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

Schließlich haben wir die folgende Liste von Datensätzen in der Tabelle DEPARTMENT -

id | dept        | emp_id
----+-------------+--------
  1 | IT Billing  |  1
  2 | Engineering |  2
  3 | Finance     |  7

Das CROSS JOIN

Ein CROSS JOIN vergleicht jede Zeile der ersten Tabelle mit jeder Zeile der zweiten Tabelle. Wenn die Eingabetabellen x- bzw. y-Spalten enthalten, enthält die resultierende Tabelle x + y-Spalten. Da CROSS JOINs das Potenzial haben, extrem große Tabellen zu generieren, muss darauf geachtet werden, diese nur bei Bedarf zu verwenden.

Das Folgende ist die Syntax von CROSS JOIN -

SELECT ... FROM table1 CROSS JOIN table2 ...

Basierend auf den obigen Tabellen können wir einen CROSS JOIN wie folgt schreiben:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

Die oben angegebene Abfrage führt zu folgendem Ergebnis:

emp_id| name  |  dept
------|-------|--------------
    1 | Paul  | IT Billing
    1 | Teddy | IT Billing
    1 | Mark  | IT Billing
    1 | David | IT Billing
    1 | Allen | IT Billing
    1 | Paul  | IT Billing
    1 | James | IT Billing
    1 | James | IT Billing
    2 | Paul  | Engineering
    2 | Teddy | Engineering
    2 | Mark  | Engineering
    2 | David | Engineering
    2 | Allen | Engineering
    2 | Paul  | Engineering
    2 | James | Engineering
    2 | James | Engineering
    7 | Paul  | Finance
    7 | Teddy | Finance
    7 | Mark  | Finance
    7 | David | Finance
    7 | Allen | Finance
    7 | Paul  | Finance
    7 | James | Finance
    7 | James | Finance

Der INNERE JOIN

Ein INNER JOIN erstellt eine neue Ergebnistabelle, indem Spaltenwerte von zwei Tabellen (Tabelle1 und Tabelle2) basierend auf dem Join-Prädikat kombiniert werden. Die Abfrage vergleicht jede Zeile von Tabelle1 mit jeder Zeile von Tabelle2, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen. Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte für jedes übereinstimmende Zeilenpaar von Tabelle1 und Tabelle2 zu einer Ergebniszeile kombiniert.

Ein INNER JOIN ist der häufigste Join-Typ und der Standard-Join-Typ. Sie können das Schlüsselwort INNER optional verwenden.

Das Folgende ist die Syntax von INNER JOIN -

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;

Basierend auf den obigen Tabellen können wir einen INNER JOIN wie folgt schreiben:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
        ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die oben angegebene Abfrage führt zu folgendem Ergebnis:

emp_id | name  | dept
--------+-------+------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering

Die linke linke Verbindung

Der OUTER JOIN ist eine Erweiterung des INNER JOIN. Der SQL-Standard definiert drei Arten von OUTER JOINs: LEFT, RIGHT und FULL, und PostgreSQL unterstützt all diese.

Bei LEFT OUTER JOIN wird zuerst eine innere Verknüpfung durchgeführt. Dann wird für jede Zeile in Tabelle T1, die die Verknüpfungsbedingung mit keiner Zeile in Tabelle T2 erfüllt, eine verknüpfte Zeile mit Nullwerten in Spalten von T2 hinzugefügt. Somit hat die verknüpfte Tabelle immer mindestens eine Zeile für jede Zeile in T1.

Das Folgende ist die Syntax von LEFT OUTER JOIN -

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

Basierend auf den obigen Tabellen können wir einen inneren Join wie folgt schreiben:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die oben angegebene Abfrage führt zu folgendem Ergebnis:

emp_id | name  | dept
--------+-------+------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
        | James |
        | David |
        | Paul  |
        | Mark  |
        | Teddy |
        | James |

Der rechte äußere Beitritt

Zunächst wird eine innere Verknüpfung durchgeführt. Dann wird für jede Zeile in Tabelle T2, die die Verknüpfungsbedingung mit keiner Zeile in Tabelle T1 erfüllt, eine verknüpfte Zeile mit Nullwerten in Spalten von T1 hinzugefügt. Dies ist die Umkehrung einer linken Verknüpfung; Die Ergebnistabelle enthält immer eine Zeile für jede Zeile in T2.

Das Folgende ist die Syntax von RIGHT OUTER JOIN -

SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...

Basierend auf den obigen Tabellen können wir einen inneren Join wie folgt schreiben:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die oben angegebene Abfrage führt zu folgendem Ergebnis:

emp_id | name  | dept
--------+-------+--------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 |       | Finance

Der VOLLSTÄNDIGE OUTER JOIN

Zunächst wird eine innere Verknüpfung durchgeführt. Dann wird für jede Zeile in Tabelle T1, die die Verknüpfungsbedingung mit keiner Zeile in Tabelle T2 erfüllt, eine verknüpfte Zeile mit Nullwerten in Spalten von T2 hinzugefügt. Zusätzlich wird für jede Zeile von T2, die die Verknüpfungsbedingung mit keiner Zeile in T1 erfüllt, eine verknüpfte Zeile mit Nullwerten in den Spalten von T1 hinzugefügt.

Das Folgende ist die Syntax von FULL OUTER JOIN -

SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...

Basierend auf den obigen Tabellen können wir einen inneren Join wie folgt schreiben:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

Die oben angegebene Abfrage führt zu folgendem Ergebnis:

emp_id | name  | dept
--------+-------+---------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 |       | Finance
        | James |
        | David |
        | Paul  |
        | Mark  |
        | Teddy |
        | James |

Das PostgreSQL UNION Klausel / Operator wird verwendet, um die Ergebnisse von zwei oder mehr SELECT-Anweisungen zu kombinieren, ohne doppelte Zeilen zurückzugeben.

Um UNION verwenden zu können, muss für jedes SELECT die gleiche Anzahl von Spalten ausgewählt, die gleiche Anzahl von Spaltenausdrücken, der gleiche Datentyp und die gleiche Reihenfolge angegeben werden, sie müssen jedoch nicht dieselbe Länge haben.

Syntax

Die grundlegende Syntax von UNION ist wie folgt -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann eine bestimmte Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen: (a) Die Tabelle COMPANY lautet wie folgt:

testdb=# SELECT * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

(b) Eine andere Tabelle ist ABTEILUNG wie folgt -

testdb=# SELECT * from DEPARTMENT;
 id | dept        | emp_id
----+-------------+--------
  1 | IT Billing  |      1
  2 | Engineering |      2
  3 | Finance     |      7
  4 | Engineering |      3
  5 | Finance     |      4
  6 | Engineering |      5
  7 | Finance     |      6
(7 rows)

Lassen Sie uns nun diese beiden Tabellen mit der SELECT-Anweisung zusammen mit der UNION-Klausel wie folgt verbinden:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID
   UNION
      SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Dies würde das folgende Ergebnis erzeugen -

emp_id | name  |  dept
--------+-------+--------------
      5 | David | Engineering
      6 | Kim   | Finance
      2 | Allen | Engineering
      3 | Teddy | Engineering
      4 | Mark  | Finance
      1 | Paul  | IT Billing
      7 | James | Finance
(7 rows)

Die UNION ALL-Klausel

Der Operator UNION ALL wird verwendet, um die Ergebnisse von zwei SELECT-Anweisungen einschließlich doppelter Zeilen zu kombinieren. Die gleichen Regeln, die für UNION gelten, gelten auch für den Operator UNION ALL.

Syntax

Die grundlegende Syntax von UNION ALL ist wie folgt -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann eine bestimmte Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Lassen Sie uns nun die beiden oben genannten Tabellen in unserer SELECT-Anweisung wie folgt verbinden:

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID
   UNION ALL
      SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

Dies würde das folgende Ergebnis erzeugen -

emp_id | name  | dept
--------+-------+--------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
      3 | Teddy | Engineering
      4 | Mark  | Finance
      5 | David | Engineering
      6 | Kim   | Finance
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
      3 | Teddy | Engineering
      4 | Mark  | Finance
      5 | David | Engineering
      6 | Kim   | Finance
(14 rows)

Das PostgreSQL NULList der Begriff, der verwendet wird, um einen fehlenden Wert darzustellen. Ein NULL-Wert in einer Tabelle ist ein Wert in einem Feld, der leer zu sein scheint.

Ein Feld mit einem NULL-Wert ist ein Feld ohne Wert. Es ist sehr wichtig zu verstehen, dass sich ein NULL-Wert von einem Nullwert oder einem Feld mit Leerzeichen unterscheidet.

Syntax

Die grundlegende Syntax der Verwendung NULL beim Erstellen einer Tabelle ist wie folgt:

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Hier, NOT NULLbedeutet, dass die Spalte immer einen expliziten Wert des angegebenen Datentyps akzeptieren sollte. Es gibt zwei Spalten, in denen wir NOT NULL nicht verwendet haben. Dies bedeutet also, dass diese Spalten NULL sein können.

Ein Feld mit einem NULL-Wert wurde während der Datensatzerstellung leer gelassen.

Beispiel

Der NULL-Wert kann Probleme bei der Auswahl von Daten verursachen, da beim Vergleich eines unbekannten Werts mit einem anderen Wert das Ergebnis immer unbekannt ist und nicht in den Endergebnissen enthalten ist. Betrachten Sie die folgende Tabelle: UNTERNEHMEN mit den folgenden Datensätzen:

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

Verwenden wir die UPDATE-Anweisung, um einige nullwertfähige Werte wie folgt auf NULL zu setzen:

testdb=# UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

Jetzt sollte die COMPANY-Tabelle die folgenden Datensätze enthalten:

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 |             |
  7 | James |  24 |             |
(7 rows)

Lassen Sie uns als nächstes die Verwendung von sehen IS NOT NULL Operator, um alle Datensätze aufzulisten, bei denen SALARY nicht NULL ist -

testdb=#  SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM COMPANY
   WHERE SALARY IS NOT NULL;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(5 rows)

Das Folgende ist die Verwendung von IS NULL Operator, der alle Datensätze auflistet, bei denen SALARY NULL ist -

testdb=#  SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age | address | salary
----+-------+-----+---------+--------
  6 | Kim   |  22 |         |
  7 | James |  24 |         |
(2 rows)

Sie können eine Tabelle oder eine Spalte vorübergehend umbenennen, indem Sie einen anderen Namen angeben, der als bezeichnet wird ALIAS. Die Verwendung von Tabellenaliasnamen bedeutet, dass eine Tabelle in einer bestimmten PostgreSQL-Anweisung umbenannt wird. Das Umbenennen ist eine vorübergehende Änderung, und der tatsächliche Tabellenname ändert sich in der Datenbank nicht.

Die Spaltenaliasnamen werden verwendet, um die Spalten einer Tabelle für den Zweck einer bestimmten PostgreSQL-Abfrage umzubenennen.

Syntax

Die grundlegende Syntax von table Alias ​​ist wie folgt -

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

Die grundlegende Syntax von column Alias ​​ist wie folgt -

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Beispiel

Betrachten Sie die folgenden zwei Tabellen: (a) Die Tabelle COMPANY lautet wie folgt:

testdb=# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

(b) Eine andere Tabelle ist ABTEILUNG wie folgt -

id | dept         | emp_id
----+--------------+--------
  1 | IT Billing   |      1
  2 | Engineering  |      2
  3 | Finance      |      7
  4 | Engineering  |      3
  5 | Finance      |      4
  6 | Engineering  |      5
  7 | Finance      |      6
(7 rows)

Im Folgenden wird die Verwendung von beschrieben TABLE ALIAS wo wir C und D als Aliase für COMPANY- bzw. DEPARTMENT-Tabellen verwenden -

testdb=# SELECT C.ID, C.NAME, C.AGE, D.DEPT
   FROM COMPANY AS C, DEPARTMENT AS D
   WHERE  C.ID = D.EMP_ID;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

id | name  | age |  dept
----+-------+-----+------------
  1 | Paul  |  32 | IT Billing
  2 | Allen |  25 | Engineering
  7 | James |  24 | Finance
  3 | Teddy |  23 | Engineering
  4 | Mark  |  25 | Finance
  5 | David |  27 | Engineering
  6 | Kim   |  22 | Finance
(7 rows)

Lassen Sie uns ein Beispiel für die Verwendung von sehen COLUMN ALIAS Dabei ist COMPANY_ID ein Alias ​​der ID-Spalte und COMPANY_NAME ein Alias ​​der Namensspalte -

testdb=# SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
   FROM COMPANY AS C, DEPARTMENT AS D
   WHERE  C.ID = D.EMP_ID;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

company_id | company_name | age | dept
------------+--------------+-----+------------
      1     | Paul         |  32 | IT Billing
      2     | Allen        |  25 | Engineering
      7     | James        |  24 | Finance
      3     | Teddy        |  23 | Engineering
      4     | Mark         |  25 | Finance
      5     | David        |  27 | Engineering
      6     | Kim          |  22 | Finance
(7 rows)

PostgreSQL Triggers sind Datenbank-Rückruffunktionen, die automatisch ausgeführt / aufgerufen werden, wenn ein bestimmtes Datenbankereignis auftritt.

Das Folgende sind wichtige Punkte zu PostgreSQL-Triggern:

  • Der PostgreSQL-Trigger kann zum Auslösen angegeben werden

    • Bevor die Operation für eine Zeile versucht wird (bevor Einschränkungen überprüft und INSERT, UPDATE oder DELETE versucht werden)

    • Nach Abschluss des Vorgangs (nachdem die Einschränkungen überprüft und INSERT, UPDATE oder DELETE abgeschlossen wurden)

    • Anstelle der Operation (bei Einfügungen, Aktualisierungen oder Löschungen in einer Ansicht)

  • Ein Trigger, der für JEDE REIHE markiert ist, wird einmal für jede Zeile aufgerufen, die die Operation ändert. Im Gegensatz dazu wird ein Trigger, der mit FOR EACH STATEMENT markiert ist, für eine bestimmte Operation nur einmal ausgeführt, unabhängig davon, wie viele Zeilen er ändert.

  • Sowohl die WHEN-Klausel als auch die Triggeraktionen können unter Verwendung von Verweisen auf das Formular auf Elemente der Zeile zugreifen, die eingefügt, gelöscht oder aktualisiert werden NEW.column-name und OLD.column-nameDabei ist Spaltenname der Name einer Spalte aus der Tabelle, der der Trigger zugeordnet ist.

  • Wenn eine WHEN-Klausel angegeben wird, werden die angegebenen PostgreSQL-Anweisungen nur für Zeilen ausgeführt, für die die WHEN-Klausel wahr ist. Wenn keine WHEN-Klausel angegeben wird, werden die PostgreSQL-Anweisungen für alle Zeilen ausgeführt.

  • Wenn mehrere Auslöser derselben Art für dasselbe Ereignis definiert sind, werden sie in alphabetischer Reihenfolge nach Namen ausgelöst.

  • Das Schlüsselwort BEFORE, AFTER oder INSTEAD OF bestimmt, wann die Triggeraktionen in Bezug auf das Einfügen, Ändern oder Entfernen der zugehörigen Zeile ausgeführt werden.

  • Trigger werden automatisch gelöscht, wenn die Tabelle, der sie zugeordnet sind, gelöscht wird.

  • Die zu ändernde Tabelle muss in derselben Datenbank vorhanden sein wie die Tabelle oder Ansicht, an die der Trigger angehängt ist, und muss nur verwendet werden tablenamenicht database.tablename.

  • Wenn eine CONSTRAINT-Option angegeben wird, wird ein Constraint-Trigger erstellt . Dies ist dasselbe wie bei einem normalen Auslöser, außer dass der Zeitpunkt des Auslösers mit SET CONSTRAINTS eingestellt werden kann. Es wird erwartet, dass Constraint-Trigger eine Ausnahme auslösen, wenn die von ihnen implementierten Constraints verletzt werden.

Syntax

Die grundlegende Syntax zum Erstellen von a trigger ist wie folgt -

CREATE  TRIGGER trigger_name [BEFORE|AFTER|INSTEAD OF] event_name
ON table_name
[
 -- Trigger logic goes here....
];

Hier, event_namekönnte sein , INSERT, DELETE, UPDATE und TRUNCATE Datenbankbetrieb auf der genannten Tabelletable_name. Sie können optional FÜR JEDE REIHE nach dem Tabellennamen angeben.

Das Folgende ist die Syntax zum Erstellen eines Triggers für eine UPDATE-Operation für eine oder mehrere angegebene Spalten einer Tabelle wie folgt:

CREATE  TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name
ON table_name
[
 -- Trigger logic goes here....
];

Beispiel

Betrachten wir einen Fall, in dem wir für jeden Datensatz, der in die COMPANY-Tabelle eingefügt wird, einen Audit-Test durchführen möchten, den wir wie folgt neu erstellen (Drop COMPANY-Tabelle, falls Sie sie bereits haben).

testdb=# CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Um den Audit-Test fortzusetzen, erstellen wir eine neue Tabelle mit dem Namen AUDIT, in die Protokollnachrichten eingefügt werden, wenn in der COMPANY-Tabelle ein Eintrag für einen neuen Datensatz vorhanden ist.

testdb=# CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

Hier ist ID die AUDIT-Datensatz-ID und EMP_ID die ID, die aus der COMPANY-Tabelle stammt, und DATE behält den Zeitstempel bei, wenn der Datensatz in der COMPANY-Tabelle erstellt wird. Lassen Sie uns nun einen Trigger für die COMPANY-Tabelle wie folgt erstellen:

testdb=# CREATE TRIGGER example_trigger AFTER INSERT ON COMPANY
FOR EACH ROW EXECUTE PROCEDURE auditlogfunc();

Wobei auditlogfunc () ein PostgreSQL ist procedure und hat die folgende Definition -

CREATE OR REPLACE FUNCTION auditlogfunc() RETURNS TRIGGER AS $example_table$
   BEGIN
      INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, current_timestamp);
      RETURN NEW;
   END;
$example_table$ LANGUAGE plpgsql;

Jetzt beginnen wir mit der eigentlichen Arbeit. Beginnen wir mit dem Einfügen eines Datensatzes in die COMPANY-Tabelle, der zur Erstellung eines Überwachungsprotokolldatensatzes in der AUDIT-Tabelle führen soll. Erstellen wir also einen Datensatz in der COMPANY-Tabelle wie folgt:

testdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

Dadurch wird ein Datensatz in der COMPANY-Tabelle erstellt, der wie folgt lautet:

id | name | age | address      | salary
----+------+-----+--------------+--------
  1 | Paul |  32 | California   |  20000

Gleichzeitig wird ein Datensatz in der AUDIT-Tabelle erstellt. Dieser Datensatz ist das Ergebnis eines Triggers, den wir bei der INSERT-Operation in der COMPANY-Tabelle erstellt haben. Ebenso können Sie Ihre Trigger für UPDATE- und DELETE-Vorgänge basierend auf Ihren Anforderungen erstellen.

emp_id |          entry_date
--------+-------------------------------
      1 | 2013-05-05 15:49:59.968+05:30
(1 row)

Listing TRIGGERS

Sie können alle Trigger in der aktuellen Datenbank von auflisten pg_trigger Tabelle wie folgt -

testdb=# SELECT * FROM pg_trigger;

Die oben angegebene PostgreSQL-Anweisung listet alle Trigger auf.

Wenn Sie die Trigger in einer bestimmten Tabelle auflisten möchten, verwenden Sie die AND-Klausel mit dem Tabellennamen wie folgt:

testdb=# SELECT tgname FROM pg_trigger, pg_class WHERE tgrelid=pg_class.oid AND relname='company';

Die oben angegebene PostgreSQL-Anweisung listet auch nur einen Eintrag wie folgt auf:

tgname
-----------------
 example_trigger
(1 row)

TRIGGERS fallen lassen

Das Folgende ist der DROP-Befehl, mit dem ein vorhandener Trigger gelöscht werden kann:

testdb=# DROP TRIGGER trigger_name;

Indizes sind spezielle Nachschlagetabellen, mit denen die Datenbanksuchmaschine den Datenabruf beschleunigen kann. Einfach ausgedrückt ist ein Index ein Zeiger auf Daten in einer Tabelle. Ein Index in einer Datenbank ist einem Index auf der Rückseite eines Buches sehr ähnlich.

Wenn Sie beispielsweise auf alle Seiten in einem Buch verweisen möchten, in dem ein bestimmtes Thema behandelt wird, müssen Sie zuerst auf den Index verweisen, in dem alle Themen alphabetisch aufgelistet sind, und dann auf eine oder mehrere bestimmte Seitenzahlen verweisen.

Ein Index beschleunigt SELECT-Abfragen und WHERE-Klauseln. Mit den Anweisungen UPDATE und INSERT wird jedoch die Dateneingabe verlangsamt. Indizes können ohne Auswirkung auf die Daten erstellt oder gelöscht werden.

Das Erstellen eines Index umfasst die Anweisung CREATE INDEX, mit der Sie den Index benennen, die Tabelle und die zu indizierenden Spalten angeben und angeben können, ob der Index in aufsteigender oder absteigender Reihenfolge vorliegt.

Indizes können auch eindeutig sein, ähnlich wie bei der UNIQUE-Einschränkung, da der Index doppelte Einträge in der Spalte oder einer Kombination von Spalten verhindert, für die ein Index vorhanden ist.

Der Befehl CREATE INDEX

Die grundlegende Syntax von CREATE INDEX ist wie folgt -

CREATE INDEX index_name ON table_name;

Indextypen

PostgreSQL bietet verschiedene Indextypen: B-Tree, Hash, GiST, SP-GiST und GIN. Jeder Indextyp verwendet einen anderen Algorithmus, der für verschiedene Abfragetypen am besten geeignet ist. Standardmäßig erstellt der Befehl CREATE INDEX B-Tree-Indizes, die den häufigsten Situationen entsprechen.

Einspaltige Indizes

Ein einspaltiger Index wird basierend auf nur einer Tabellenspalte erstellt. Die grundlegende Syntax lautet wie folgt:

CREATE INDEX index_name
ON table_name (column_name);

Mehrspaltige Indizes

Ein mehrspaltiger Index wird für mehr als eine Spalte einer Tabelle definiert. Die grundlegende Syntax lautet wie folgt:

CREATE INDEX index_name
ON table_name (column1_name, column2_name);

Berücksichtigen Sie beim Erstellen eines einspaltigen Index oder eines mehrspaltigen Index die Spalte (n), die Sie möglicherweise sehr häufig in der WHERE-Klausel einer Abfrage als Filterbedingungen verwenden.

Sollte nur eine Spalte verwendet werden, sollte ein einspaltiger Index die Wahl sein. Sollten in der WHERE-Klausel häufig zwei oder mehr Spalten als Filter verwendet werden, ist der mehrspaltige Index die beste Wahl.

Einzigartige Indizes

Eindeutige Indizes werden nicht nur für die Leistung, sondern auch für die Datenintegrität verwendet. Mit einem eindeutigen Index können keine doppelten Werte in die Tabelle eingefügt werden. Die grundlegende Syntax lautet wie folgt:

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Teilindizes

Ein Teilindex ist ein Index, der über einer Teilmenge einer Tabelle erstellt wird. Die Teilmenge wird durch einen bedingten Ausdruck definiert (Prädikat des Teilindex genannt). Der Index enthält nur Einträge für die Tabellenzeilen, die das Prädikat erfüllen. Die grundlegende Syntax lautet wie folgt:

CREATE INDEX index_name
on table_name (conditional_expression);

Implizite Indizes

Implizite Indizes sind Indizes, die vom Datenbankserver automatisch erstellt werden, wenn ein Objekt erstellt wird. Indizes werden automatisch für Primärschlüsseleinschränkungen und eindeutige Einschränkungen erstellt.

Beispiel

Das folgende Beispiel zeigt einen Index für die COMPANY- Tabelle für die Gehaltsspalte:

# CREATE INDEX salary_index ON COMPANY (salary);

Lassen Sie uns nun alle in der COMPANY-Tabelle verfügbaren Indizes mit auflisten \d company Befehl.

# \d company

Dies führt zu folgendem Ergebnis, wobei company_pkey ein impliziter Index ist, der beim Erstellen der Tabelle erstellt wurde.

Table "public.company"
 Column  |     Type      | Modifiers
---------+---------------+-----------
 id      | integer       | not null
 name    | text          | not null
 age     | integer       | not null
 address | character(50) |
 salary  | real          |
Indexes:
    "company_pkey" PRIMARY KEY, btree (id)
    "salary_index" btree (salary)

Sie können die gesamte Indexdatenbank mit der Liste auflisten \di Befehl -

Der Befehl DROP INDEX

Ein Index kann mit PostgreSQL gelöscht werden DROPBefehl. Beim Löschen eines Index ist Vorsicht geboten, da die Leistung möglicherweise verlangsamt oder verbessert wird.

Die grundlegende Syntax lautet wie folgt:

DROP INDEX index_name;

Mit der folgenden Anweisung können Sie zuvor erstellte Indizes löschen:

# DROP INDEX salary_index;

Wann sollten Indizes vermieden werden?

Obwohl Indizes die Leistung einer Datenbank verbessern sollen, sollten sie manchmal vermieden werden. Die folgenden Richtlinien geben an, wann die Verwendung eines Index überdacht werden sollte -

  • Indizes sollten nicht für kleine Tabellen verwendet werden.

  • Tabellen mit häufigen Aktualisierungs- oder Einfügevorgängen für große Stapel.

  • Indizes sollten nicht für Spalten verwendet werden, die eine hohe Anzahl von NULL-Werten enthalten.

  • Häufig manipulierte Spalten sollten nicht indiziert werden.

Das PostgreSQL ALTER TABLE Mit diesem Befehl können Sie Spalten in einer vorhandenen Tabelle hinzufügen, löschen oder ändern.

Sie würden auch den Befehl ALTER TABLE verwenden, um verschiedene Einschränkungen für eine vorhandene Tabelle hinzuzufügen und zu löschen.

Syntax

Die grundlegende Syntax von ALTER TABLE Das Hinzufügen einer neuen Spalte zu einer vorhandenen Tabelle lautet wie folgt:

ALTER TABLE table_name ADD column_name datatype;

Die grundlegende Syntax von ALTER TABLE to DROP COLUMN in einer vorhandenen Tabelle ist wie folgt -

ALTER TABLE table_name DROP COLUMN column_name;

Die grundlegende Syntax von ALTER TABLE zum Ändern der DATA TYPE einer Spalte in einer Tabelle ist wie folgt -

ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;

Die grundlegende Syntax von ALTER TABLE zum Hinzufügen von a NOT NULL Die Einschränkung für eine Spalte in einer Tabelle lautet wie folgt:

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

Die grundlegende Syntax von ALTER TABLE to ADD UNIQUE CONSTRAINT zu einer Tabelle ist wie folgt -

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

Die grundlegende Syntax von ALTER TABLE to ADD CHECK CONSTRAINT zu einer Tabelle ist wie folgt -

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

Die grundlegende Syntax von ALTER TABLE to ADD PRIMARY KEY Die Einschränkung für eine Tabelle lautet wie folgt:

ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

Die grundlegende Syntax von ALTER TABLE to DROP CONSTRAINT aus einer Tabelle ist wie folgt -

ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;

Wenn Sie MySQL verwenden, lautet der Code wie folgt:

ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;

Die grundlegende Syntax von ALTER TABLE to DROP PRIMARY KEY Die Einschränkung aus einer Tabelle lautet wie folgt:

ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;

Wenn Sie MySQL verwenden, lautet der Code wie folgt:

ALTER TABLE table_name
DROP PRIMARY KEY;

Beispiel

Beachten Sie, dass unsere COMPANY- Tabelle die folgenden Datensätze enthält:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Das folgende Beispiel fügt eine neue Spalte in eine vorhandene Tabelle hinzu:

testdb=# ALTER TABLE COMPANY ADD GENDER char(1);

Jetzt wird die COMPANY-Tabelle geändert und das Folgende wäre die Ausgabe der SELECT-Anweisung -

id | name  | age | address     | salary | gender
----+-------+-----+-------------+--------+--------
  1 | Paul  |  32 | California  |  20000 |
  2 | Allen |  25 | Texas       |  15000 |
  3 | Teddy |  23 | Norway      |  20000 |
  4 | Mark  |  25 | Rich-Mond   |  65000 |
  5 | David |  27 | Texas       |  85000 |
  6 | Kim   |  22 | South-Hall  |  45000 |
  7 | James |  24 | Houston     |  10000 |
(7 rows)

Das folgende Beispiel zeigt die Spalte DROP gender aus der vorhandenen Tabelle:

testdb=# ALTER TABLE COMPANY DROP GENDER;

Jetzt wird die COMPANY-Tabelle geändert und das Folgende wäre die Ausgabe der SELECT-Anweisung -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Das PostgreSQL TRUNCATE TABLEMit dem Befehl werden vollständige Daten aus einer vorhandenen Tabelle gelöscht. Sie können auch den Befehl DROP TABLE verwenden, um eine vollständige Tabelle zu löschen. Dadurch wird jedoch die vollständige Tabellenstruktur aus der Datenbank entfernt, und Sie müssen diese Tabelle erneut erstellen, wenn Sie einige Daten speichern möchten.

Es hat den gleichen Effekt wie LÖSCHEN für jede Tabelle, aber da es die Tabellen nicht tatsächlich scannt, ist es schneller. Darüber hinaus wird sofort Speicherplatz zurückgewonnen, anstatt eine nachfolgende VACUUM-Operation zu erfordern. Dies ist am nützlichsten bei großen Tabellen.

Syntax

Die grundlegende Syntax von TRUNCATE TABLE ist wie folgt -

TRUNCATE TABLE  table_name;

Beispiel

Angenommen, die COMPANY-Tabelle enthält die folgenden Datensätze:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(7 rows)

Das folgende Beispiel ist das Abschneiden von -

testdb=# TRUNCATE TABLE COMPANY;

Jetzt wird die COMPANY-Tabelle abgeschnitten und das Folgende wäre die Ausgabe der SELECT-Anweisung -

testdb=# SELECT * FROM CUSTOMERS;
 id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)

Ansichten sind Pseudotabellen. Das heißt, sie sind keine echten Tische; erscheinen dennoch als gewöhnliche Tabellen zu SELECT. Eine Ansicht kann eine Teilmenge einer realen Tabelle darstellen und bestimmte Spalten oder bestimmte Zeilen aus einer normalen Tabelle auswählen. Eine Ansicht kann sogar verknüpfte Tabellen darstellen. Da Ansichten separate Berechtigungen zugewiesen werden, können Sie sie verwenden, um den Tabellenzugriff einzuschränken, sodass die Benutzer nur bestimmte Zeilen oder Spalten einer Tabelle sehen.

Eine Ansicht kann alle Zeilen einer Tabelle oder ausgewählte Zeilen aus einer oder mehreren Tabellen enthalten. Eine Ansicht kann aus einer oder mehreren Tabellen erstellt werden. Dies hängt von der geschriebenen PostgreSQL-Abfrage ab, um eine Ansicht zu erstellen.

Mit Ansichten, bei denen es sich um virtuelle Tabellen handelt, können Benutzer Folgendes tun:

  • Strukturieren Sie Daten so, dass Benutzer oder Benutzerklassen sie natürlich oder intuitiv finden.

  • Beschränken Sie den Zugriff auf die Daten so, dass ein Benutzer nur begrenzte Daten anstelle einer vollständigen Tabelle sehen kann.

  • Fassen Sie Daten aus verschiedenen Tabellen zusammen, mit denen Berichte erstellt werden können.

Da Ansichten keine gewöhnlichen Tabellen sind, können Sie möglicherweise keine DELETE-, INSERT- oder UPDATE-Anweisung für eine Ansicht ausführen. Sie können jedoch eine REGEL erstellen, um dieses Problem bei der Verwendung von DELETE, INSERT oder UPDATE in einer Ansicht zu beheben.

Ansichten erstellen

Die PostgreSQL-Ansichten werden mit dem erstellt CREATE VIEWErklärung. Die PostgreSQL-Ansichten können aus einer einzelnen Tabelle, mehreren Tabellen oder einer anderen Ansicht erstellt werden.

Die grundlegende CREATE VIEW-Syntax lautet wie folgt:

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Sie können mehrere Tabellen in Ihre SELECT-Anweisung auf sehr ähnliche Weise aufnehmen, wie Sie sie in normalen PostgreSQL SELECT-Abfragen verwenden. Wenn das optionale Schlüsselwort TEMP oder TEMPORARY vorhanden ist, wird die Ansicht im temporären Bereich erstellt. Temporäre Ansichten werden am Ende der aktuellen Sitzung automatisch gelöscht.

Beispiel

Beachten Sie, dass die COMPANY- Tabelle die folgenden Datensätze enthält:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000

Im Folgenden finden Sie ein Beispiel zum Erstellen einer Ansicht aus der COMPANY-Tabelle. Diese Ansicht würde verwendet, um nur wenige Spalten aus der COMPANY-Tabelle zu haben -

testdb=# CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

Jetzt können Sie COMPANY_VIEW auf ähnliche Weise abfragen wie eine tatsächliche Tabelle. Es folgt das Beispiel -

testdb=# SELECT * FROM COMPANY_VIEW;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age
----+-------+-----
  1 | Paul  |  32
  2 | Allen |  25
  3 | Teddy |  23
  4 | Mark  |  25
  5 | David |  27
  6 | Kim   |  22
  7 | James |  24
(7 rows)

Ansichten löschen

Verwenden Sie zum Löschen einer Ansicht einfach die Anweisung DROP VIEW mit der view_name. Die grundlegende DROP VIEW-Syntax lautet wie folgt:

testdb=# DROP VIEW view_name;

Der folgende Befehl löscht die Ansicht COMPANY_VIEW, die wir im letzten Abschnitt erstellt haben:

testdb=# DROP VIEW COMPANY_VIEW;

Eine Transaktion ist eine Arbeitseinheit, die für eine Datenbank ausgeführt wird. Transaktionen sind Einheiten oder Abfolgen von Arbeiten, die in einer logischen Reihenfolge ausgeführt werden, entweder manuell von einem Benutzer oder automatisch von einer Art Datenbankprogramm.

Eine Transaktion ist die Weitergabe einer oder mehrerer Änderungen an der Datenbank. Wenn Sie beispielsweise einen Datensatz erstellen, einen Datensatz aktualisieren oder einen Datensatz aus der Tabelle löschen, führen Sie eine Transaktion für die Tabelle aus. Es ist wichtig, Transaktionen zu steuern, um die Datenintegrität sicherzustellen und Datenbankfehler zu behandeln.

In der Praxis werden Sie viele PostgreSQL-Abfragen zu einer Gruppe zusammenfassen und alle zusammen als Teil einer Transaktion ausführen.

Eigenschaften von Transaktionen

Transaktionen haben die folgenden vier Standardeigenschaften, die normalerweise mit dem Akronym ACID bezeichnet werden:

  • Atomicity- stellt sicher, dass alle Vorgänge innerhalb der Arbeitseinheit erfolgreich abgeschlossen wurden; Andernfalls wird die Transaktion zum Zeitpunkt des Ausfalls abgebrochen und frühere Vorgänge werden auf ihren vorherigen Status zurückgesetzt.

  • Consistency - Stellt sicher, dass die Datenbank bei einer erfolgreich festgeschriebenen Transaktion den Status ordnungsgemäß ändert.

  • Isolation - Ermöglicht den unabhängigen und transparenten Betrieb von Transaktionen.

  • Durability - Stellt sicher, dass das Ergebnis oder die Wirkung einer festgeschriebenen Transaktion bei einem Systemausfall bestehen bleibt.

Transaktionskontrolle

Die folgenden Befehle werden zur Steuerung von Transaktionen verwendet:

  • BEGIN TRANSACTION - Um eine Transaktion zu starten.

  • COMMIT - Um die Änderungen zu speichern, können Sie sie alternativ verwenden END TRANSACTION Befehl.

  • ROLLBACK - Um die Änderungen rückgängig zu machen.

Transaktionssteuerbefehle werden nur mit den DML-Befehlen INSERT, UPDATE und DELETE verwendet. Sie können beim Erstellen oder Löschen von Tabellen nicht verwendet werden, da diese Vorgänge automatisch in der Datenbank festgeschrieben werden.

Der Befehl BEGIN TRANSACTION

Transaktionen können mit BEGIN TRANSACTION oder einfach mit dem Befehl BEGIN gestartet werden. Solche Transaktionen bleiben normalerweise bestehen, bis der nächste Befehl COMMIT oder ROLLBACK auftritt. Eine Transaktion wird jedoch auch rückgängig gemacht, wenn die Datenbank geschlossen wird oder wenn ein Fehler auftritt.

Das Folgende ist die einfache Syntax zum Starten einer Transaktion:

BEGIN;

or

BEGIN TRANSACTION;

Der Befehl COMMIT

Der Befehl COMMIT ist der Transaktionsbefehl, mit dem Änderungen, die von einer Transaktion aufgerufen werden, in der Datenbank gespeichert werden.

Der Befehl COMMIT speichert alle Transaktionen in der Datenbank seit dem letzten Befehl COMMIT oder ROLLBACK.

Die Syntax für den Befehl COMMIT lautet wie folgt:

COMMIT;

or

END TRANSACTION;

Der ROLLBACK-Befehl

Der Befehl ROLLBACK ist der Transaktionsbefehl, mit dem Transaktionen rückgängig gemacht werden, die noch nicht in der Datenbank gespeichert wurden.

Der Befehl ROLLBACK kann nur zum Rückgängigmachen von Transaktionen verwendet werden, seit der letzte Befehl COMMIT oder ROLLBACK ausgegeben wurde.

Die Syntax für den Befehl ROLLBACK lautet wie folgt:

ROLLBACK;

Beispiel

Angenommen, die COMPANY- Tabelle enthält die folgenden Datensätze:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Lassen Sie uns nun eine Transaktion starten und Datensätze aus der Tabelle mit dem Alter = 25 löschen. Schließlich verwenden wir den Befehl ROLLBACK, um alle Änderungen rückgängig zu machen.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
ROLLBACK;

Wenn Sie überprüfen, ob die COMPANY-Tabelle noch die folgenden Datensätze enthält:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Lassen Sie uns nun eine weitere Transaktion starten und Datensätze aus der Tabelle mit dem Alter = 25 löschen. Schließlich verwenden wir den Befehl COMMIT, um alle Änderungen festzuschreiben.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
COMMIT;

Wenn Sie die COMPANY-Tabelle überprüfen, enthält sie noch die folgenden Datensätze:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  3 | Teddy |  23 | Norway     |  20000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(5 rows)

Sperren oder exklusive Sperren oder Schreibsperren verhindern, dass Benutzer eine Zeile oder eine gesamte Tabelle ändern. Durch UPDATE und DELETE geänderte Zeilen werden dann ausschließlich für die Dauer der Transaktion automatisch gesperrt. Dies verhindert, dass andere Benutzer die Zeile ändern, bis die Transaktion entweder festgeschrieben oder zurückgesetzt wird.

Benutzer müssen nur dann auf andere Benutzer warten, wenn sie versuchen, dieselbe Zeile zu ändern. Wenn sie unterschiedliche Zeilen ändern, ist kein Warten erforderlich. SELECT-Abfragen müssen nie warten.

Die Datenbank führt die Sperrung automatisch durch. In bestimmten Fällen muss die Verriegelung jedoch manuell gesteuert werden. Die manuelle Verriegelung kann mit dem Befehl LOCK erfolgen. Es ermöglicht die Angabe des Sperrtyps und -bereichs einer Transaktion.

Syntax für den Befehl LOCK

Die grundlegende Syntax für den Befehl LOCK lautet wie folgt:

LOCK [ TABLE ]
name
 IN
lock_mode
  • name- Der Name (optional schemaqualifiziert) einer vorhandenen Tabelle, die gesperrt werden soll. Wenn NUR vor dem Tabellennamen angegeben wird, ist nur diese Tabelle gesperrt. Wenn NUR nicht angegeben ist, werden die Tabelle und alle ihre Nachkommen-Tabellen (falls vorhanden) gesperrt.

  • lock_mode- Der Sperrmodus gibt an, mit welchen Sperren diese Sperre in Konflikt steht. Wenn kein Sperrmodus angegeben ist, wird ACCESS EXCLUSIVE, der restriktivste Modus, verwendet. Mögliche Werte sind: ACCESS SHARE, ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE, EXCLUSIVE, ACCESS EXCLUSIVE.

Nach Erhalt wird die Sperre für den Rest der aktuellen Transaktion beibehalten. Es gibt keinen Befehl UNLOCK TABLE. Sperren werden immer am Transaktionsende freigegeben.

DeadLocks

Deadlocks können auftreten, wenn zwei Transaktionen aufeinander warten, um ihre Operationen abzuschließen. Während PostgreSQL sie erkennen und mit einem ROLLBACK beenden kann, können Deadlocks immer noch unpraktisch sein. Um zu verhindern, dass Ihre Anwendungen auf dieses Problem stoßen, stellen Sie sicher, dass sie so gestaltet sind, dass sie Objekte in derselben Reihenfolge sperren.

Hinweisschlösser

PostgreSQL bietet Mittel zum Erstellen von Sperren mit anwendungsdefinierten Bedeutungen. Diese werden als Beratungsschlösser bezeichnet . Da das System ihre Verwendung nicht erzwingt, ist es Sache der Anwendung, sie korrekt zu verwenden. Beratungssperren können nützlich sein, um Strategien zu sperren, die für das MVCC-Modell unangenehm sind.

Beispielsweise besteht eine häufige Verwendung von Beratungssperren darin, pessimistische Sperrstrategien zu emulieren, die für die sogenannten "Flat File" -Datenverwaltungssysteme typisch sind. Während ein in einer Tabelle gespeichertes Flag für denselben Zweck verwendet werden kann, sind Beratungssperren schneller, vermeiden das Aufblähen von Tabellen und werden am Ende der Sitzung automatisch vom Server bereinigt.

Beispiel

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Im folgenden Beispiel wird die COMPANY-Tabelle in der testdb-Datenbank im ACCESS EXCLUSIVE-Modus gesperrt. Die LOCK-Anweisung funktioniert nur in einem Transaktionsmodus -

testdb=#BEGIN;
LOCK TABLE company1 IN ACCESS EXCLUSIVE MODE;

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

LOCK TABLE

Die obige Meldung zeigt an, dass die Tabelle bis zum Ende der Transaktion gesperrt ist. Um die Transaktion abzuschließen, müssen Sie die Transaktion entweder zurücksetzen oder festschreiben.

Eine Unterabfrage oder innere Abfrage oder verschachtelte Abfrage ist eine Abfrage in einer anderen PostgreSQL-Abfrage und eingebettet in die WHERE-Klausel.

Eine Unterabfrage wird verwendet, um Daten zurückzugeben, die in der Hauptabfrage als Bedingung verwendet werden, um die abzurufenden Daten weiter einzuschränken.

Unterabfragen können mit den Anweisungen SELECT, INSERT, UPDATE und DELETE zusammen mit den Operatoren wie =, <,>,> =, <=, IN usw. verwendet werden.

Es gibt einige Regeln, denen Unterabfragen folgen müssen -

  • Unterabfragen müssen in Klammern stehen.

  • Eine Unterabfrage kann nur eine Spalte in der SELECT-Klausel enthalten, es sei denn, die Hauptabfrage enthält mehrere Spalten, damit die Unterabfrage ihre ausgewählten Spalten vergleicht.

  • Ein ORDER BY kann nicht in einer Unterabfrage verwendet werden, obwohl die Hauptabfrage ein ORDER BY verwenden kann. Mit GROUP BY kann dieselbe Funktion wie mit ORDER BY in einer Unterabfrage ausgeführt werden.

  • Unterabfragen, die mehr als eine Zeile zurückgeben, können nur mit mehreren Wertoperatoren verwendet werden, z. B. dem Operator IN, EXISTS, NOT IN, ANY / SOME, ALL.

  • Der Operator BETWEEN kann nicht mit einer Unterabfrage verwendet werden. Das ZWISCHEN kann jedoch innerhalb der Unterabfrage verwendet werden.

Unterabfragen mit der SELECT-Anweisung

Unterabfragen werden am häufigsten mit der SELECT-Anweisung verwendet. Die grundlegende Syntax lautet wie folgt:

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
      (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

Beispiel

Betrachten Sie die COMPANY- Tabelle mit den folgenden Datensätzen:

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Lassen Sie uns nun die folgende Unterabfrage mit der SELECT-Anweisung überprüfen:

testdb=# SELECT *
   FROM COMPANY
   WHERE ID IN (SELECT ID
      FROM COMPANY
      WHERE SALARY > 45000) ;

Dies würde das folgende Ergebnis erzeugen -

id | name  | age |  address    | salary
----+-------+-----+-------------+--------
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
(2 rows)

Unterabfragen mit der INSERT-Anweisung

Unterabfragen können auch mit INSERT-Anweisungen verwendet werden. Die INSERT-Anweisung verwendet die von der Unterabfrage zurückgegebenen Daten, um sie in eine andere Tabelle einzufügen. Die ausgewählten Daten in der Unterabfrage können mit einer beliebigen Zeichen-, Datums- oder Zahlenfunktion geändert werden.

Die grundlegende Syntax lautet wie folgt:

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ] ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Beispiel

Stellen Sie sich eine Tabelle COMPANY_BKP mit einer ähnlichen Struktur wie die Tabelle COMPANY vor, die mit derselben CREATE TABLE unter Verwendung von COMPANY_BKP als Tabellenname erstellt werden kann. Um nun die vollständige COMPANY-Tabelle in COMPANY_BKP zu kopieren, folgt die folgende Syntax:

testdb=# INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY
   WHERE ID IN (SELECT ID
      FROM COMPANY) ;

Unterabfragen mit der UPDATE-Anweisung

Die Unterabfrage kann in Verbindung mit der UPDATE-Anweisung verwendet werden. Bei Verwendung einer Unterabfrage mit der UPDATE-Anweisung können entweder einzelne oder mehrere Spalten in einer Tabelle aktualisiert werden.

Die grundlegende Syntax lautet wie folgt:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben die Tabelle COMPANY_BKP zur Verfügung, bei der es sich um eine Sicherung der Tabelle COMPANY handelt.

Im folgenden Beispiel wird das Gehalt in der COMPANY-Tabelle für alle Kunden, deren ALTER größer oder gleich 27 ist, um das 0,50-fache aktualisiert.

testdb=# UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Dies würde zwei Zeilen betreffen und schließlich würde die COMPANY-Tabelle die folgenden Datensätze enthalten:

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  1 | Paul  |  32 | California  |  10000
  5 | David |  27 | Texas       |  42500
(7 rows)

Unterabfragen mit der DELETE-Anweisung

Die Unterabfrage kann in Verbindung mit der DELETE-Anweisung wie bei allen anderen oben genannten Anweisungen verwendet werden.

Die grundlegende Syntax lautet wie folgt:

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben die Tabelle COMPANY_BKP zur Verfügung, die eine Sicherung der Tabelle COMPANY ist.

Im folgenden Beispiel werden Datensätze aus der COMPANY-Tabelle für alle Kunden gelöscht, deren ALTER größer oder gleich 27 ist.

testdb=# DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE > 27 );

Dies würde zwei Zeilen betreffen und schließlich würde die COMPANY-Tabelle die folgenden Datensätze enthalten:

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  5 | David |  27 | Texas       |  42500
(6 rows)

PostgreSQL hat die Datentypen smallserial , serial und bigserial . Dies sind keine echten Typen, sondern lediglich eine Annehmlichkeit zum Erstellen eindeutiger Bezeichnerspalten. Diese ähneln der Eigenschaft AUTO_INCREMENT, die von einigen anderen Datenbanken unterstützt wird.

Wenn Sie möchten, dass eine serielle Spalte eine eindeutige Einschränkung aufweist oder ein Primärschlüssel ist, muss sie jetzt wie jeder andere Datentyp angegeben werden.

Der Typname serial erstellt eine Ganzzahlspalte . Der Typname bigserial erstellt eine bigint- Spalte. bigserial sollte verwendet werden, wenn Sie die Verwendung von mehr als 2 31 Bezeichnern über die Lebensdauer der Tabelle erwarten . Der Typname smallserial erstellt eine smallint- Spalte.

Syntax

Die grundlegende Verwendung von SERIAL dataype ist wie folgt -

CREATE TABLE tablename (
   colname SERIAL
);

Beispiel

Betrachten Sie die zu erstellende COMPANY-Tabelle wie folgt:

testdb=# CREATE TABLE COMPANY(
   ID  SERIAL PRIMARY KEY,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Fügen Sie nun die folgenden Datensätze in die Tabelle COMPANY ein -

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );


INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );

Dadurch werden sieben Tupel in die Tabelle COMPANY eingefügt, und COMPANY verfügt über die folgenden Datensätze:

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000

Immer wenn ein Objekt in einer Datenbank erstellt wird, wird ihm ein Eigentümer zugewiesen. Der Eigentümer ist normalerweise derjenige, der die Erstellungsanweisung ausgeführt hat. Für die meisten Arten von Objekten ist der Ausgangszustand, dass nur der Eigentümer (oder ein Superuser) das Objekt ändern oder löschen kann. Damit andere Rollen oder Benutzer es verwenden können, müssen Berechtigungen oder Berechtigungen erteilt werden.

Verschiedene Arten von Berechtigungen in PostgreSQL sind -

  • SELECT,
  • INSERT,
  • UPDATE,
  • DELETE,
  • TRUNCATE,
  • REFERENCES,
  • TRIGGER,
  • CREATE,
  • CONNECT,
  • TEMPORARY,
  • AUSFÜHREN und
  • USAGE

Abhängig vom Objekttyp (Tabelle, Funktion usw.) werden Berechtigungen auf das Objekt angewendet. Um den Benutzern Berechtigungen zuzuweisen, wird der Befehl GRANT verwendet.

Syntax für GRANT

Die grundlegende Syntax für den Befehl GRANT lautet wie folgt:

GRANT privilege [, ...]
ON object [, ...]
TO { PUBLIC | GROUP group | username }
  • privilege - Werte können sein: SELECT, INSERT, UPDATE, DELETE, RULE, ALL.

  • object- Der Name eines Objekts, auf das Zugriff gewährt werden soll. Die möglichen Objekte sind: Tabelle, Ansicht, Sequenz

  • PUBLIC - Eine Kurzform, die alle Benutzer repräsentiert.

  • GRUPPE group - Eine Gruppe, der Berechtigungen gewährt werden sollen.

  • username- Der Name eines Benutzers, dem Berechtigungen erteilt werden sollen. PUBLIC ist eine Kurzform, die alle Benutzer repräsentiert.

Die Berechtigungen können mit dem Befehl REVOKE widerrufen werden.

Syntax für REVOKE

Die grundlegende Syntax für den Befehl REVOKE lautet wie folgt:

REVOKE privilege [, ...]
ON object [, ...]
FROM { PUBLIC | GROUP groupname | username }
  • privilege - Werte können sein: SELECT, INSERT, UPDATE, DELETE, RULE, ALL.

  • object- Der Name eines Objekts, auf das Zugriff gewährt werden soll. Die möglichen Objekte sind: Tabelle, Ansicht, Sequenz

  • PUBLIC - Eine Kurzform, die alle Benutzer repräsentiert.

  • GRUPPE group - Eine Gruppe, der Berechtigungen gewährt werden sollen.

  • username- Der Name eines Benutzers, dem Berechtigungen erteilt werden sollen. PUBLIC ist eine Kurzform, die alle Benutzer repräsentiert.

Beispiel

Um die Berechtigungen zu verstehen, erstellen wir zunächst einen USER wie folgt:

testdb=# CREATE USER manisha WITH PASSWORD 'password';
CREATE ROLE

Die Meldung CREATE ROLE zeigt an, dass der USER "manisha" erstellt wurde.

Betrachten Sie die Tabelle UNTERNEHMEN mit Aufzeichnungen wie folgt:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Als nächstes gewähren wir dem Benutzer "manisha" alle Berechtigungen für eine Tabelle COMPANY wie folgt:

testdb=# GRANT ALL ON COMPANY TO manisha;
GRANT

Die Nachricht GRANT zeigt an, dass dem USER alle Berechtigungen zugewiesen sind.

Als nächstes widerrufen wir die Privilegien der USER "manisha" wie folgt:

testdb=# REVOKE ALL ON COMPANY FROM manisha;
REVOKE

Die Meldung REVOKE zeigt an, dass alle Berechtigungen vom USER widerrufen werden.

Sie können den Benutzer sogar wie folgt löschen:

testdb=# DROP USER manisha;
DROP ROLE

Die Meldung DROP ROLE zeigt an, dass USER 'Manisha' aus der Datenbank gelöscht wurde.

Wir hatten die Datentypen Datum / Uhrzeit im Kapitel Datentypen besprochen . Lassen Sie uns nun die Datums- / Zeitoperatoren und Funktionen sehen.

In der folgenden Tabelle sind die Verhaltensweisen der grundlegenden arithmetischen Operatoren aufgeführt.

Operator Beispiel Ergebnis
+ Datum '28.09.2001' + Ganzzahl '7' Datum '2001-10-05'
+ Datum '2001-09-28' + Intervall '1 Stunde' Zeitstempel '2001-09-28 01:00:00'
+ Datum '28.09.2001' + Uhrzeit '03: 00 ' Zeitstempel '2001-09-28 03:00:00'
+ Intervall '1 Tag' + Intervall '1 Stunde' Intervall '1 Tag 01:00:00'
+ Zeitstempel '2001-09-28 01:00' + Intervall '23 Stunden ' Zeitstempel '2001-09-29 00:00:00'
+ Zeit '01: 00 '+ Intervall' 3 Stunden ' Zeit '04: 00: 00 '
- - - Intervall '23 Stunden ' Intervall '-23: 00: 00'
- - Datum '2001-10-01' - Datum '2001-09-28' Ganzzahl '3' (Tage)
- - Datum '2001-10-01' - Ganzzahl '7' Datum '2001-09-24'
- - Datum '2001-09-28' - Intervall '1 Stunde' Zeitstempel '2001-09-27 23:00:00'
- - Zeit '05: 00 '- Zeit '03: 00' Intervall '02: 00: 00 '
- - Zeit '05: 00 '- Intervall' 2 Stunden ' Zeit '03: 00: 00 '
- - Zeitstempel '2001-09-28 23:00' - Intervall '23 Stunden ' Zeitstempel '2001-09-28 00:00:00'
- - Intervall '1 Tag' - Intervall '1 Stunde' Intervall '1 Tag -01: 00: 00'
- - Zeitstempel '2001-09-29 03:00' - Zeitstempel '2001-09-27 12:00' Intervall '1 Tag 15:00:00'
* * 900 * Intervall '1 Sekunde' Intervall '00: 15: 00 '
* * 21 * Intervall '1 Tag' Intervall '21 Tage '
* * doppelte Genauigkeit '3,5' * Intervall '1 Stunde' Intervall '03: 30: 00 '
/. Intervall '1 Stunde' / doppelte Genauigkeit '1,5' Intervall '00: 40: 00 '

Im Folgenden finden Sie eine Liste aller wichtigen verfügbaren Funktionen für Datum und Uhrzeit.

S. Nr. Bedienungsanleitung
1 ALTER()

Argumente subtrahieren

2 AKTUELLES DATUM / ZEIT ()

Aktuelles Datum und Uhrzeit

3 DATE_PART ()

Unterfeld abrufen (entspricht Extrahieren)

4 EXTRAKT()

Unterfeld abrufen

5 ISFINITE ()

Test auf endliches Datum, Uhrzeit und Intervall (nicht +/- unendlich)

6 RECHTFERTIGEN

Intervall anpassen

AGE (Zeitstempel, Zeitstempel), AGE (Zeitstempel)

S. Nr. Bedienungsanleitung
1

AGE(timestamp, timestamp)

Beim Aufrufen mit der TIMESTAMP-Form des zweiten Arguments subtrahiert AGE () Argumente und erzeugt ein "symbolisches" Ergebnis, das Jahre und Monate verwendet und vom Typ INTERVAL ist.

2

AGE(timestamp)

Wenn AGE () nur mit dem Argument TIMESTAMP als Argument aufgerufen wird, subtrahiert es vom aktuellen Datum (um Mitternacht).

Beispiel für die Funktion AGE (Zeitstempel, Zeitstempel) ist -

testdb=# SELECT AGE(timestamp '2001-04-10', timestamp '1957-06-13');

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

age
-------------------------
 43 years 9 mons 27 days

Beispiel für die Funktion AGE (Zeitstempel) ist -

testdb=# select age(timestamp '1957-06-13');

Die oben angegebene PostgreSQL-Anweisung führt zu folgendem Ergebnis:

age
--------------------------
 55 years 10 mons 22 days

AKTUELLES DATUM / ZEIT ()

PostgreSQL bietet eine Reihe von Funktionen, die Werte für das aktuelle Datum und die aktuelle Uhrzeit zurückgeben. Es folgen einige Funktionen -

S. Nr. Bedienungsanleitung
1

CURRENT_DATE

Liefert das aktuelle Datum.

2

CURRENT_TIME

Liefert Werte mit Zeitzone.

3

CURRENT_TIMESTAMP

Liefert Werte mit Zeitzone.

4

CURRENT_TIME(precision)

Optional wird ein Präzisionsparameter verwendet, der bewirkt, dass das Ergebnis im Sekundenfeld auf so viele Bruchstellen gerundet wird.

5

CURRENT_TIMESTAMP(precision)

Optional wird ein Präzisionsparameter verwendet, der bewirkt, dass das Ergebnis im Sekundenfeld auf so viele Bruchstellen gerundet wird.

6

LOCALTIME

Liefert Werte ohne Zeitzone.

7

LOCALTIMESTAMP

Liefert Werte ohne Zeitzone.

8

LOCALTIME(precision)

Optional wird ein Präzisionsparameter verwendet, der bewirkt, dass das Ergebnis im Sekundenfeld auf so viele Bruchstellen gerundet wird.

9

LOCALTIMESTAMP(precision)

Optional wird ein Präzisionsparameter verwendet, der bewirkt, dass das Ergebnis im Sekundenfeld auf so viele Bruchstellen gerundet wird.

Beispiele mit den Funktionen aus der obigen Tabelle -

testdb=# SELECT CURRENT_TIME;
       timetz
--------------------
 08:01:34.656+05:30
(1 row)


testdb=# SELECT CURRENT_DATE;
    date
------------
 2013-05-05
(1 row)


testdb=# SELECT CURRENT_TIMESTAMP;
              now
-------------------------------
 2013-05-05 08:01:45.375+05:30
(1 row)


testdb=# SELECT CURRENT_TIMESTAMP(2);
         timestamptz
------------------------------
 2013-05-05 08:01:50.89+05:30
(1 row)


testdb=# SELECT LOCALTIMESTAMP;
       timestamp
------------------------
 2013-05-05 08:01:55.75
(1 row)

PostgreSQL bietet auch Funktionen, die die Startzeit der aktuellen Anweisung sowie die tatsächliche aktuelle Zeit zum Zeitpunkt des Aufrufs der Funktion zurückgeben. Diese Funktionen sind -

S. Nr. Bedienungsanleitung
1

transaction_timestamp()

Es entspricht CURRENT_TIMESTAMP, wird jedoch so benannt, dass es deutlich widerspiegelt, was es zurückgibt.

2

statement_timestamp()

Es gibt die Startzeit der aktuellen Anweisung zurück.

3

clock_timestamp()

Es gibt die aktuelle Uhrzeit zurück und daher ändert sich sein Wert auch innerhalb eines einzelnen SQL-Befehls.

4

timeofday()

Es gibt die aktuelle Uhrzeit zurück, jedoch als formatierte Textzeichenfolge und nicht als Zeitstempel mit Zeitzonenwert.

5

now()

Es ist ein traditionelles PostgreSQL-Äquivalent zu transaction_timestamp ().

DATE_PART (Text, Zeitstempel), DATE_PART (Text, Intervall), DATE_TRUNC (Text, Zeitstempel)

S. Nr. Bedienungsanleitung
1

DATE_PART('field', source)

Diese Funktionen erhalten die Unterfelder. Das Feld Parameter muss ein String - Wert sein, kein Name.

Die gültigen Feldnamen sind: Jahrhundert, Tag, Jahrzehnt, Dow, Doy, Epoche, Stunde, Isodow, Isoyear, Mikrosekunden, Millennium, Millisekunden, Minute, Monat, Viertel, Sekunde, Zeitzone, Zeitzone_Stunde, Zeitzone_Minute, Woche, Jahr.

2

DATE_TRUNC('field', source)

Diese Funktion ähnelt konzeptionell der Trunk- Funktion für Zahlen. Quelle ist ein Wertausdruck vom Typ Zeitstempel oder Intervall. Feld wählt aus, mit welcher Genauigkeit der Eingabewert abgeschnitten werden soll. Der Rückgabewert ist vom Typ Zeitstempel oder Intervall .

Die gültigen Werte für das Feld sind: Mikrosekunden, Millisekunden, Sekunde, Minute, Stunde, Tag, Woche, Monat, Quartal, Jahr, Jahrzehnt, Jahrhundert, Jahrtausend

Das Folgende sind Beispiele für DATE_PART-Funktionen ( 'Feld' , Quelle) -

testdb=# SELECT date_part('day', TIMESTAMP '2001-02-16 20:38:40');
 date_part
-----------
        16
(1 row)


testdb=# SELECT date_part('hour', INTERVAL '4 hours 3 minutes');
 date_part
-----------
         4
(1 row)

Das Folgende sind Beispiele für DATE_TRUNC-Funktionen ( 'Feld' , Quelle) -

testdb=# SELECT date_trunc('hour', TIMESTAMP '2001-02-16 20:38:40');
     date_trunc
---------------------
 2001-02-16 20:00:00
(1 row)


testdb=# SELECT date_trunc('year', TIMESTAMP '2001-02-16 20:38:40');
     date_trunc
---------------------
 2001-01-01 00:00:00
(1 row)

EXTRACT (Feld vom Zeitstempel), EXTRACT (Feld vom Intervall)

Das EXTRACT(field FROM source)Die Funktion ruft Unterfelder wie Jahr oder Stunde von Datums- / Zeitwerten ab. Die Quelle muss ein Wertausdruck vom Typ Zeitstempel, Zeit oder Intervall sein . Das Feld ist ein Bezeichner oder eine Zeichenfolge, die auswählt, welches Feld aus dem Quellwert extrahiert werden soll. Die EXTRACT-Funktion gibt Werte vom Typ doppelte Genauigkeit zurück .

Die folgenden sind gültige Feldnamen (ähnlich den DATE_PART-Funktionsfeldnamen): Jahrhundert, Tag, Jahrzehnt, Dow, Doy, Epoche, Stunde, Isodow, Isoyear, Mikrosekunden, Millennium, Millisekunden, Minute, Monat, Viertel, Sekunde, Zeitzone, Zeitzone_Stunde , timezone_minute, Woche, Jahr.

Das Folgende sind Beispiele für EXTRACT-Funktionen ( 'Feld' , Quelle) -

testdb=# SELECT EXTRACT(CENTURY FROM TIMESTAMP '2000-12-16 12:21:13');
 date_part
-----------
        20
(1 row)


testdb=# SELECT EXTRACT(DAY FROM TIMESTAMP '2001-02-16 20:38:40');
 date_part
-----------
        16
(1 row)

ISFINITE (Datum), ISFINITE (Zeitstempel), ISFINITE (Intervall)

S. Nr. Bedienungsanleitung
1

ISFINITE(date)

Tests für endliches Datum.

2

ISFINITE(timestamp)

Testet auf endlichen Zeitstempel.

3

ISFINITE(interval)

Tests für endliche Intervalle.

Das Folgende sind die Beispiele der ISFINITE () -Funktionen -

testdb=# SELECT isfinite(date '2001-02-16');
 isfinite
----------
 t
(1 row)


testdb=# SELECT isfinite(timestamp '2001-02-16 21:28:30');
 isfinite
----------
 t
(1 row)


testdb=# SELECT isfinite(interval '4 hours');
 isfinite
----------
 t
(1 row)

JUSTIFY_DAYS (Intervall), JUSTIFY_HOURS (Intervall), JUSTIFY_INTERVAL (Intervall)

S. Nr. Bedienungsanleitung
1

JUSTIFY_DAYS(interval)

Passt das Intervall so an, dass 30-Tage-Zeiträume als Monate dargestellt werden. Gib die ... wiederinterval Art

2

JUSTIFY_HOURS(interval)

Passt das Intervall so an, dass 24-Stunden-Zeiträume als Tage dargestellt werden. Gib die ... wiederinterval Art

3

JUSTIFY_INTERVAL(interval)

Passt das Intervall mit JUSTIFY_DAYS und JUSTIFY_HOURS mit zusätzlichen Vorzeichenanpassungen an. Gib die ... wiederinterval Art

Das Folgende sind die Beispiele für die ISFINITE () -Funktionen -

testdb=# SELECT justify_days(interval '35 days');
 justify_days
--------------
 1 mon 5 days
(1 row)


testdb=# SELECT justify_hours(interval '27 hours');
 justify_hours
----------------
 1 day 03:00:00
(1 row)


testdb=# SELECT justify_interval(interval '1 mon -1 hour');
 justify_interval
------------------
 29 days 23:00:00
(1 row)

PostgreSQL functionsMit der Option "Gespeicherte Prozeduren" können Sie Vorgänge ausführen, für die normalerweise mehrere Abfragen und Roundtrips in einer einzigen Funktion in der Datenbank erforderlich sind. Funktionen ermöglichen die Wiederverwendung von Datenbanken, da andere Anwendungen direkt mit Ihren gespeicherten Prozeduren interagieren können, anstatt einen Code der mittleren Ebene oder zu duplizieren.

Funktionen können in einer Sprache Ihrer Wahl wie SQL, PL / pgSQL, C, Python usw. erstellt werden.

Syntax

Die grundlegende Syntax zum Erstellen einer Funktion lautet wie folgt:

CREATE [OR REPLACE] FUNCTION function_name (arguments) 
RETURNS return_datatype AS $variable_name$
   DECLARE
      declaration;
      [...]
   BEGIN
      < function_body >
      [...]
      RETURN { variable_name | value }
   END; LANGUAGE plpgsql;

Wo,

  • function-name Gibt den Namen der Funktion an.

  • Mit der Option [ODER ERSETZEN] können Sie eine vorhandene Funktion ändern.

  • Die Funktion muss a enthalten return Erklärung.

  • RETURNKlausel gibt den Datentyp an, den Sie von der Funktion zurückgeben möchten. Dasreturn_datatype kann ein Basis-, Verbund- oder Domänentyp sein oder auf den Typ einer Tabellenspalte verweisen.

  • function-body enthält den ausführbaren Teil.

  • Das Schlüsselwort AS wird zum Erstellen einer eigenständigen Funktion verwendet.

  • plpgsqlist der Name der Sprache, in der die Funktion implementiert ist. Hier verwenden wir diese Option für PostgreSQL. Dies kann SQL, C, intern oder der Name einer benutzerdefinierten prozeduralen Sprache sein. Aus Gründen der Abwärtskompatibilität kann der Name in einfache Anführungszeichen gesetzt werden.

Beispiel

Das folgende Beispiel zeigt das Erstellen und Aufrufen einer eigenständigen Funktion. Diese Funktion gibt die Gesamtzahl der Datensätze in der COMPANY-Tabelle zurück. Wir werden die COMPANY- Tabelle verwenden, die die folgenden Datensätze enthält:

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Die Funktion totalRecords () lautet wie folgt:

CREATE OR REPLACE FUNCTION totalRecords ()
RETURNS integer AS $total$
declare
	total integer;
BEGIN
   SELECT count(*) into total FROM COMPANY;
   RETURN total;
END;
$total$ LANGUAGE plpgsql;

Wenn die obige Abfrage ausgeführt wird, wäre das Ergebnis -

testdb# CREATE FUNCTION

Lassen Sie uns nun diese Funktion aufrufen und die Datensätze in der Tabelle COMPANY überprüfen

testdb=# select totalRecords();

Wenn die obige Abfrage ausgeführt wird, wäre das Ergebnis -

totalrecords
--------------
      7
(1 row)

In PostgreSQL integrierte Funktionen, auch als Aggregatfunktionen bezeichnet, werden zum Verarbeiten von Zeichenfolgen oder numerischen Daten verwendet.

Das Folgende ist die Liste aller in PostgreSQL integrierten Allzweckfunktionen -

  • PostgreSQL COUNT-Funktion - Mit der PostgreSQL COUNT-Aggregatfunktion wird die Anzahl der Zeilen in einer Datenbanktabelle gezählt.

  • PostgreSQL MAX-Funktion - Mit der PostgreSQL MAX-Aggregatfunktion können wir den höchsten (maximalen) Wert für eine bestimmte Spalte auswählen.

  • PostgreSQL MIN-Funktion - Mit der PostgreSQL MIN-Aggregatfunktion können wir den niedrigsten (minimalen) Wert für eine bestimmte Spalte auswählen.

  • PostgreSQL AVG-Funktion - Die PostgreSQL AVG-Aggregatfunktion wählt den Durchschnittswert für eine bestimmte Tabellenspalte aus.

  • PostgreSQL SUM-Funktion - Mit der PostgreSQL SUM-Aggregatfunktion können Sie die Summe für eine numerische Spalte auswählen.

  • PostgreSQL ARRAY-Funktionen - Die Aggregatfunktion PostgreSQL ARRAY fügt Eingabewerte, einschließlich Nullen, in ein Array ein.

  • Numerische PostgreSQL-Funktionen - Vollständige Liste der PostgreSQL-Funktionen, die zum Bearbeiten von Zahlen in SQL erforderlich sind.

  • PostgreSQL- Zeichenfolgenfunktionen - Vollständige Liste der PostgreSQL-Funktionen, die zum Bearbeiten von Zeichenfolgen in PostgreSQL erforderlich sind.

Dieses Tutorial wird verwendet libpqxxBibliothek, die offizielle C ++ - Client-API für PostgreSQL. Der Quellcode für libpqxx ist unter der BSD-Lizenz verfügbar. Sie können ihn also kostenlos herunterladen, an andere weitergeben, ändern, verkaufen, in Ihren eigenen Code aufnehmen und Ihre Änderungen an andere Personen weitergeben.

Installation

Die neueste Version von libpqxx kann über den Link Download Libpqxx heruntergeladen werden . Laden Sie also die neueste Version herunter und befolgen Sie die folgenden Schritte:

wget http://pqxx.org/download/software/libpqxx/libpqxx-4.0.tar.gz
tar xvfz libpqxx-4.0.tar.gz
cd libpqxx-4.0
./configure
make
make install

Bevor Sie mit der Verwendung der C / C ++ PostgreSQL-Schnittstelle beginnen, suchen Sie die pg_hba.conf Datei in Ihrem PostgreSQL-Installationsverzeichnis und fügen Sie die folgende Zeile hinzu:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Sie können den Postgres-Server starten / neu starten, falls er nicht mit dem folgenden Befehl ausgeführt wird:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

C / C ++ - Schnittstellen-APIs

Im Folgenden finden Sie wichtige Schnittstellenroutinen, die Ihre Anforderungen für die Arbeit mit der PostgreSQL-Datenbank in Ihrem C / C ++ - Programm erfüllen können. Wenn Sie nach einer komplexeren Anwendung suchen, können Sie in der offiziellen libpqxx-Dokumentation nachsehen oder handelsübliche APIs verwenden.

S. Nr. API & Beschreibung
1

pqxx::connection C( const std::string & dbstring )

Dies ist ein typedef, mit dem eine Verbindung zur Datenbank hergestellt wird. Hier bietet dbstring beispielsweise die erforderlichen Parameter, um eine Verbindung zur Datenbank herzustellendbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432.

Wenn die Verbindung erfolgreich hergestellt wurde, wird C mit dem Verbindungsobjekt erstellt, das verschiedene nützliche Funktionen für die öffentliche Funktion bereitstellt.

2

C.is_open()

Die Methode is_open () ist eine öffentliche Methode für ein Verbindungsobjekt und gibt einen booleschen Wert zurück. Wenn die Verbindung aktiv ist, gibt diese Methode true zurück, andernfalls false.

3

C.disconnect()

Diese Methode wird verwendet, um eine geöffnete Datenbankverbindung zu trennen.

4

pqxx::work W( C )

Dies ist ein typedef, mit dem ein Transaktionsobjekt über die Verbindung C erstellt wird, mit dem letztendlich SQL-Anweisungen im Transaktionsmodus ausgeführt werden.

Wenn das Transaktionsobjekt erfolgreich erstellt wurde, wird es der Variablen W zugewiesen, die für den Zugriff auf öffentliche Methoden für das Transaktionsobjekt verwendet wird.

5

W.exec(const std::string & sql)

Diese öffentliche Methode aus dem Transaktionsobjekt wird zum Ausführen der SQL-Anweisung verwendet.

6

W.commit()

Diese öffentliche Methode aus dem Transaktionsobjekt wird zum Festschreiben der Transaktion verwendet.

7

W.abort()

Diese öffentliche Methode aus dem Transaktionsobjekt wird verwendet, um die Transaktion zurückzusetzen.

8

pqxx::nontransaction N( C )

Dies ist ein typedef, der verwendet wird, um ein nicht transaktionales Objekt unter Verwendung von Verbindung C zu erstellen, das letztendlich verwendet wird, um SQL-Anweisungen im nicht transaktionalen Modus auszuführen.

Wenn das Transaktionsobjekt erfolgreich erstellt wurde, wird es der Variablen N zugewiesen, die für den Zugriff auf öffentliche Methoden für nicht-transaktionale Objekte verwendet wird.

9

N.exec(const std::string & sql)

Diese öffentliche Methode aus einem nicht transaktionalen Objekt wird zum Ausführen einer SQL-Anweisung verwendet und gibt ein Ergebnisobjekt zurück, das tatsächlich ein Interator ist, der alle zurückgegebenen Datensätze enthält.

Verbindung zur Datenbank herstellen

Das folgende C-Codesegment zeigt, wie eine Verbindung zu einer vorhandenen Datenbank hergestellt wird, die auf einem lokalen Computer an Port 5432 ausgeführt wird. Hier habe ich Backslash \ für die Zeilenfortsetzung verwendet.

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }
}

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um eine Verbindung zu unserer Datenbank herzustellen testdb, die bereits in Ihrem Schema verfügbar ist und mit dem Benutzer postgres und dem Kennwort pass123 aufgerufen werden kann .

Sie können die Benutzer-ID und das Kennwort basierend auf Ihrer Datenbankeinstellung verwenden. Denken Sie daran, die -lpqxx und -lpq in der angegebenen Reihenfolge zu halten! Andernfalls beschwert sich der Linker bitter über die fehlenden Funktionen mit Namen, die mit "PQ" beginnen.

$g++ test.cpp -lpqxx -lpq $./a.out
Opened database successfully: testdb

Erstellen Sie eine Tabelle

Das folgende C-Codesegment wird verwendet, um eine Tabelle in einer zuvor erstellten Datenbank zu erstellen:

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Table created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Wenn das oben angegebene Programm kompiliert und ausgeführt wird, erstellt es eine COMPANY-Tabelle in Ihrer testdb-Datenbank und zeigt die folgenden Anweisungen an:

Opened database successfully: testdb
Table created successfully

INSERT-Betrieb

Das folgende C-Codesegment zeigt, wie wir Datensätze in unserer im obigen Beispiel erstellten COMPANY-Tabelle erstellen können -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Wenn das oben angegebene Programm kompiliert und ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully: testdb
Records created successfully

SELECT-Betrieb

Das folgende C-Codesegment zeigt, wie wir Datensätze aus unserer im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Wenn das oben angegebene Programm kompiliert und ausgeführt wird, führt es zu folgendem Ergebnis:

Opened database successfully: testdb
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 20000
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
Operation done successfully

UPDATE-Betrieb

Das folgende C-Codesegment zeigt, wie wir mit der UPDATE-Anweisung jeden Datensatz aktualisieren und dann aktualisierte Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL UPDATE statement */
      sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records updated successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Wenn das oben angegebene Programm kompiliert und ausgeführt wird, führt es zu folgendem Ergebnis:

Opened database successfully: testdb
Records updated successfully
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully

DELETE-Betrieb

Das folgende C-Codesegment zeigt, wie wir mit der DELETE-Anweisung jeden Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL DELETE statement */
      sql = "DELETE from COMPANY where ID = 2";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records deleted successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Wenn das oben angegebene Programm kompiliert und ausgeführt wird, führt es zu folgendem Ergebnis:

Opened database successfully: testdb
Records deleted successfully
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully

Installation

Bevor wir PostgreSQL in unseren Java-Programmen verwenden, müssen wir sicherstellen, dass PostgreSQL JDBC und Java auf dem Computer eingerichtet sind. Sie können das Java-Tutorial für die Java-Installation auf Ihrem Computer überprüfen. Lassen Sie uns nun überprüfen, wie der PostgreSQL-JDBC-Treiber eingerichtet wird.

  • Laden Sie die neueste Version von postgresql- (VERSION) .jdbc.jar aus dem postgresql-jdbc- Repository herunter .

  • Fügen Sie die heruntergeladene JAR-Datei postgresql- (VERSION) .jdbc.jar in Ihren Klassenpfad ein, oder verwenden Sie sie zusammen mit der Option -classpath, wie unten in den Beispielen erläutert.

Im folgenden Abschnitt wird davon ausgegangen, dass Sie nur wenig über Java JDBC-Konzepte wissen. Wenn dies nicht der Fall ist, wird empfohlen, eine halbe Stunde mit dem JDBC-Lernprogramm zu verbringen , um sich mit den unten erläuterten Konzepten vertraut zu machen.

Verbindung zur Datenbank herstellen

Der folgende Java-Code zeigt, wie Sie eine Verbindung zu einer vorhandenen Datenbank herstellen. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

import java.sql.Connection;
import java.sql.DriverManager;

public class PostgreSQLJDBC {
   public static void main(String args[]) {
      Connection c = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "postgres", "123");
      } catch (Exception e) {
         e.printStackTrace();
         System.err.println(e.getClass().getName()+": "+e.getMessage());
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

Bevor Sie das obige Programm kompilieren und ausführen, suchen Sie pg_hba.conf Datei in Ihrem PostgreSQL-Installationsverzeichnis und fügen Sie die folgende Zeile hinzu:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Sie können den Postgres-Server starten / neu starten, falls er nicht mit dem folgenden Befehl ausgeführt wird:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um eine Verbindung mit testdb herzustellen. Hier verwenden wirpostgres als Benutzer-ID und 123als Passwort für den Zugriff auf die Datenbank. Sie können dies gemäß Ihrer Datenbankkonfiguration und -einrichtung ändern. Wir gehen auch von einer aktuellen Version des JDBC-Treibers auspostgresql-9.2-1002.jdbc3.jar ist im aktuellen Pfad verfügbar.

C:\JavaPostgresIntegration>javac PostgreSQLJDBC.java
C:\JavaPostgresIntegration>java -cp c:\tools\postgresql-9.2-1002.jdbc3.jar;C:\JavaPostgresIntegration PostgreSQLJDBC
Open database successfully

Erstellen Sie eine Tabelle

Das folgende Java-Programm wird verwendet, um eine Tabelle in einer zuvor geöffneten Datenbank zu erstellen. Stellen Sie sicher, dass Sie diese Tabelle noch nicht in Ihrer Zieldatenbank haben.

import java.sql.*;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "CREATE TABLE COMPANY " +
            "(ID INT PRIMARY KEY     NOT NULL," +
            " NAME           TEXT    NOT NULL, " +
            " AGE            INT     NOT NULL, " +
            " ADDRESS        CHAR(50), " +
            " SALARY         REAL)";
         stmt.executeUpdate(sql);
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName()+": "+ e.getMessage() );
         System.exit(0);
      }
      System.out.println("Table created successfully");
   }
}

Wenn ein Programm kompiliert und ausgeführt wird, wird die COMPANY-Tabelle in erstellt testdb Datenbank und zeigt die folgenden zwei Zeilen an -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende Java-Programm zeigt, wie wir Datensätze in unserer im obigen Beispiel erstellten COMPANY-Tabelle erstellen können:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class PostgreSQLJDBC {
   public static void main(String args[]) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "
            + "VALUES (1, 'Paul', 32, 'California', 20000.00 );";
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "
            + "VALUES (2, 'Allen', 25, 'Texas', 15000.00 );";
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "
            + "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );";
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "
            + "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";
         stmt.executeUpdate(sql);

         stmt.close();
         c.commit();
         c.close();
      } catch (Exception e) {
         System.err.println( e.getClass().getName()+": "+ e.getMessage() );
         System.exit(0);
      }
      System.out.println("Records created successfully");
   }
}

Wenn das obige Programm kompiliert und ausgeführt wird, erstellt es bestimmte Datensätze in der COMPANY-Tabelle und zeigt die folgenden zwei Zeilen an:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Java-Programm zeigt, wie wir Datensätze aus unserer im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         while ( rs.next() ) {
            int id = rs.getInt("id");
            String  name = rs.getString("name");
            int age  = rs.getInt("age");
            String  address = rs.getString("address");
            float salary = rs.getFloat("salary");
            System.out.println( "ID = " + id );
            System.out.println( "NAME = " + name );
            System.out.println( "AGE = " + age );
            System.out.println( "ADDRESS = " + address );
            System.out.println( "SALARY = " + salary );
            System.out.println();
         }
         rs.close();
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName()+": "+ e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

Wenn das Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

UPDATE-Betrieb

Der folgende Java-Code zeigt, wie wir mit der UPDATE-Anweisung jeden Datensatz aktualisieren und dann aktualisierte Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         while ( rs.next() ) {
            int id = rs.getInt("id");
            String  name = rs.getString("name");
            int age  = rs.getInt("age");
            String  address = rs.getString("address");
            float salary = rs.getFloat("salary");
            System.out.println( "ID = " + id );
            System.out.println( "NAME = " + name );
            System.out.println( "AGE = " + age );
            System.out.println( "ADDRESS = " + address );
            System.out.println( "SALARY = " + salary );
            System.out.println();
         }
         rs.close();
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName()+": "+ e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

Wenn das Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Operation done successfully

DELETE-Betrieb

Der folgende Java-Code zeigt, wie wir mit der DELETE-Anweisung jeden Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC6 {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "DELETE from COMPANY where ID = 2;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         while ( rs.next() ) {
            int id = rs.getInt("id");
            String  name = rs.getString("name");
            int age  = rs.getInt("age");
            String  address = rs.getString("address");
            float salary = rs.getFloat("salary");
            System.out.println( "ID = " + id );
            System.out.println( "NAME = " + name );
            System.out.println( "AGE = " + age );
            System.out.println( "ADDRESS = " + address );
            System.out.println( "SALARY = " + salary );
            System.out.println();
         }
         rs.close();
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName()+": "+ e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

Wenn das Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0
Operation done successfully

Installation

Die PostgreSQL-Erweiterung ist in den neuesten Versionen von PHP 5.3.x standardmäßig aktiviert. Es ist möglich, es mit zu deaktivieren--without-pgsqlzur Kompilierungszeit. Trotzdem können Sie den Befehl yum verwenden, um die PHP-PostgreSQL-Schnittstelle zu installieren.

yum install php-pgsql

Bevor Sie die PHP PostgreSQL-Schnittstelle verwenden, suchen Sie die pg_hba.conf Datei in Ihrem PostgreSQL-Installationsverzeichnis und fügen Sie die folgende Zeile hinzu:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Sie können den Postgres-Server mit dem folgenden Befehl starten / neu starten, falls er nicht ausgeführt wird:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Windows-Benutzer müssen php_pgsql.dll aktivieren, um diese Erweiterung verwenden zu können. Diese DLL ist in Windows-Distributionen in den neuesten Versionen von PHP 5.3.x enthalten

Detaillierte Anweisungen zur Installation finden Sie in unserem PHP-Tutorial und auf der offiziellen Website.

PHP-Schnittstellen-APIs

Das Folgende sind wichtige PHP-Routinen, die ausreichen können, um mit der PostgreSQL-Datenbank Ihres PHP-Programms zu arbeiten. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie in der offiziellen PHP-Dokumentation nachsehen.

S. Nr. API & Beschreibung
1

resource pg_connect ( string $connection_string [, int $connect_type ] )

Dadurch wird eine Verbindung zu einer PostgreSQL-Datenbank hergestellt, die durch den Verbindungsstring angegeben wird.

Wenn PGSQL_CONNECT_FORCE_NEW als connect_type übergeben wird, wird bei einem zweiten Aufruf von pg_connect () eine neue Verbindung erstellt, auch wenn der connection_string mit einer vorhandenen Verbindung identisch ist.

2

bool pg_connection_reset ( resource $connection )

Diese Routine setzt die Verbindung zurück. Es ist nützlich für die Fehlerbehebung. Gibt bei Erfolg TRUE oder bei Misserfolg FALSE zurück.

3

int pg_connection_status ( resource $connection )

Diese Routine gibt den Status der angegebenen Verbindung zurück. Gibt PGSQL_CONNECTION_OK oder PGSQL_CONNECTION_BAD zurück.

4

string pg_dbname ([ resource $connection ] )

Diese Routine gibt den Namen der Datenbank zurück, die die angegebene PostgreSQL-Verbindungsressource enthält.

5

resource pg_prepare ([ resource $connection ], string $stmtname, string $query )

Dies sendet eine Anfrage zum Erstellen einer vorbereiteten Anweisung mit den angegebenen Parametern und wartet auf den Abschluss.

6

resource pg_execute ([ resource $connection ], string $stmtname, array $params )

Diese Routine sendet eine Anforderung zum Ausführen einer vorbereiteten Anweisung mit angegebenen Parametern und wartet auf das Ergebnis.

7

resource pg_query ([ resource $connection ], string $query )

Diese Routine führt die Abfrage für die angegebene Datenbankverbindung aus.

8

array pg_fetch_row ( resource $result [, int $row ] )

Diese Routine ruft eine Datenzeile aus dem Ergebnis ab, das der angegebenen Ergebnisressource zugeordnet ist.

9

array pg_fetch_all ( resource $result )

Diese Routine gibt ein Array zurück, das alle Zeilen (Datensätze) in der Ergebnisressource enthält.

10

int pg_affected_rows ( resource $result )

Diese Routine gibt die Anzahl der Zeilen zurück, die von INSERT-, UPDATE- und DELETE-Abfragen betroffen sind.

11

int pg_num_rows ( resource $result )

Diese Routine gibt die Anzahl der Zeilen in einer PostgreSQL-Ergebnisressource zurück, z. B. die Anzahl der von der SELECT-Anweisung zurückgegebenen Zeilen.

12

bool pg_close ([ resource $connection ] )

Diese Routine schließt die nicht persistente Verbindung zu einer PostgreSQL-Datenbank, die der angegebenen Verbindungsressource zugeordnet ist.

13

string pg_last_error ([ resource $connection ] )

Diese Routine gibt die letzte Fehlermeldung für eine bestimmte Verbindung zurück.

14

string pg_escape_literal ([ resource $connection ], string $data )

Diese Routine entgeht einem Literal zum Einfügen in ein Textfeld.

15

string pg_escape_string ([ resource $connection ], string $data )

Diese Routine entgeht einer Zeichenfolge zum Abfragen der Datenbank.

Verbindung zur Datenbank herstellen

Der folgende PHP-Code zeigt, wie eine Verbindung zu einer vorhandenen Datenbank auf einem lokalen Computer hergestellt wird und schließlich ein Datenbankverbindungsobjekt zurückgegeben wird.

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }
?>

Lassen Sie uns nun das oben angegebene Programm ausführen, um unsere Datenbank zu öffnen testdb: Wenn die Datenbank erfolgreich geöffnet wurde, wird die folgende Meldung angezeigt:

Opened database successfully

Erstellen Sie eine Tabelle

Das folgende PHP-Programm wird verwendet, um eine Tabelle in einer zuvor erstellten Datenbank zu erstellen -

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }
   
   $sql =<<<EOF CREATE TABLE COMPANY (ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), SALARY REAL); EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
   } else {
      echo "Table created successfully\n";
   }
   pg_close($db);
?>

Wenn das oben angegebene Programm ausgeführt wird, wird eine COMPANY-Tabelle in Ihrem erstellt testdb und es werden die folgenden Meldungen angezeigt -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende PHP-Programm zeigt, wie wir Datensätze in unserer im obigen Beispiel erstellten COMPANY-Tabelle erstellen können -

<?php
   $host        = "host=127.0.0.1";
   $port = "port=5432"; $dbname      = "dbname = testdb";
   $credentials = "user = postgres password=pass123"; $db = pg_connect( "$host $port $dbname $credentials"  );
   if(!$db) { echo "Error : Unable to open database\n"; } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
      VALUES (1, 'Paul', 32, 'California', 20000.00 );

      INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

      INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

      INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );
EOF;

   $ret = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); } else { echo "Records created successfully\n"; } pg_close($db);
?>

Wenn das oben angegebene Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende PHP-Programm zeigt, wie wir Datensätze aus unserer im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können -

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF SELECT * from COMPANY; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } 
   while($row = pg_fetch_row($ret)) {
      echo "ID = ". $row[0] . "\n"; echo "NAME = ". $row[1] ."\n";
      echo "ADDRESS = ". $row[2] ."\n"; echo "SALARY = ".$row[4] ."\n\n";
   }
   echo "Operation done successfully\n";
   pg_close($db);
?>

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt. Beachten Sie, dass Felder in der Reihenfolge zurückgegeben werden, in der sie beim Erstellen der Tabelle verwendet wurden.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

UPDATE-Betrieb

Der folgende PHP-Code zeigt, wie wir mit der UPDATE-Anweisung jeden Datensatz aktualisieren und dann aktualisierte Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

<?php
   $host        = "host=127.0.0.1";
   $port = "port=5432"; $dbname      = "dbname = testdb";
   $credentials = "user = postgres password=pass123"; $db = pg_connect( "$host $port $dbname $credentials"  );
   if(!$db) { echo "Error : Unable to open database\n"; } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      UPDATE COMPANY set SALARY = 25000.00 where ID=1;
EOF;
   $ret = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); exit; } else { echo "Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); exit; } while($row = pg_fetch_row($ret)) { echo "ID = ". $row[0] . "\n";
      echo "NAME = ". $row[1] ."\n"; echo "ADDRESS = ". $row[2] ."\n";
      echo "SALARY =  ".$row[4] ."\n\n"; } echo "Operation done successfully\n"; pg_close($db);
?>

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Record updated successfully
ID = 2
NAME = Allen
ADDRESS = 25
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = 23
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = 25
SALARY =  65000

ID = 1
NAME = Paul
ADDRESS = 32
SALARY =  25000

Operation done successfully

DELETE-Betrieb

Der folgende PHP-Code zeigt, wie wir mit der DELETE-Anweisung jeden Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID=2; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } else {
      echo "Record deleted successfully\n";
   }
   
   $sql =<<<EOF SELECT * from COMPANY; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } 
   while($row = pg_fetch_row($ret)) {
      echo "ID = ". $row[0] . "\n"; echo "NAME = ". $row[1] ."\n";
      echo "ADDRESS = ". $row[2] ."\n"; echo "SALARY = ".$row[4] ."\n\n";
   }
   echo "Operation done successfully\n";
   pg_close($db);
?>

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Record deleted successfully
ID = 3
NAME = Teddy
ADDRESS = 23
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = 25
SALARY =  65000

ID = 1
NAME = Paul
ADDRESS = 32
SALARY =  25000

Operation done successfully

Installation

PostgreSQL kann mithilfe des Perl-DBI-Moduls, einem Datenbankzugriffsmodul für die Programmiersprache Perl, in Perl integriert werden. Es definiert eine Reihe von Methoden, Variablen und Konventionen, die eine Standarddatenbankschnittstelle bereitstellen.

Hier sind einfache Schritte zum Installieren des DBI-Moduls auf Ihrem Linux / Unix-Computer:

$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz
$ tar xvfz DBI-1.625.tar.gz $ cd DBI-1.625
$ perl Makefile.PL $ make
$ make install

Wenn Sie den SQLite-Treiber für DBI installieren müssen, kann er wie folgt installiert werden:

$ wget http://search.cpan.org/CPAN/authors/id/T/TU/TURNSTEP/DBD-Pg-2.19.3.tar.gz
$ tar xvfz DBD-Pg-2.19.3.tar.gz $ cd DBD-Pg-2.19.3
$ perl Makefile.PL $ make
$ make install

Bevor Sie die Perl PostgreSQL-Schnittstelle verwenden, suchen Sie die pg_hba.conf Datei in Ihrem PostgreSQL-Installationsverzeichnis und fügen Sie die folgende Zeile hinzu:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Sie können den Postgres-Server mit dem folgenden Befehl starten / neu starten, falls er nicht ausgeführt wird:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

DBI-Schnittstellen-APIs

Im Folgenden finden Sie wichtige DBI-Routinen, die für die Arbeit mit der SQLite-Datenbank Ihres Perl-Programms ausreichen können. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie die offizielle Dokumentation von Perl DBI einsehen.

S. Nr. API & Beschreibung
1

DBI→connect($data_source, "userid", "password", \%attr)

Stellt eine Datenbankverbindung oder Sitzung zur angeforderten $ data_source her. Gibt ein Datenbankhandle-Objekt zurück, wenn die Verbindung erfolgreich ist.

Datenquelle hat die Form wie: DBI:Pg:dbname=$database;host=127.0.0.1;port=5432 Pg ist der Name des PostgreSQL-Treibers und testdb ist der Name der Datenbank.

2

$dbh→do($sql)

Diese Routine bereitet eine einzelne SQL-Anweisung vor und führt sie aus. Gibt die Anzahl der betroffenen oder bei einem Fehler nicht definierten Zeilen zurück. Ein Rückgabewert von -1 bedeutet, dass die Anzahl der Zeilen nicht bekannt, nicht zutreffend oder nicht verfügbar ist. Hier ist $ dbh ein Handle, das vom Aufruf DBI → connect () zurückgegeben wird.

3

$dbh→prepare($sql)

Diese Routine bereitet eine Anweisung für die spätere Ausführung durch das Datenbankmodul vor und gibt einen Verweis auf ein Anweisungshandle-Objekt zurück.

4

$sth→execute()

Diese Routine führt die erforderliche Verarbeitung aus, um die vorbereitete Anweisung auszuführen. Ein undef wird zurückgegeben, wenn ein Fehler auftritt. Eine erfolgreiche Ausführung gibt unabhängig von der Anzahl der betroffenen Zeilen immer true zurück. Hier$sth is a statement handle returned by $dbh → ($ sql) -Aufruf vorbereiten.

5

$sth→fetchrow_array()

Diese Routine ruft die nächste Datenzeile ab und gibt sie als Liste mit den Feldwerten zurück. Nullfelder werden als undef-Werte in der Liste zurückgegeben.

6

$DBI::err

Dies entspricht $ h → err, wobei $h is any of the handle types like $dbh, $sth, or $drh. Dies gibt den Fehlercode des nativen Datenbankmoduls von der zuletzt aufgerufenen Treibermethode zurück.

7

$DBI::errstr

Dies entspricht $ h → errstr, wobei $h is any of the handle types like $dbh, $sth, or $drh. Dies gibt die native Datenbankmodul-Fehlermeldung der zuletzt aufgerufenen DBI-Methode zurück.

8

$dbh->disconnect()

Diese Routine schließt eine Datenbankverbindung, die zuvor durch einen Aufruf von DBI → connect () geöffnet wurde.

Verbindung zur Datenbank herstellen

Der folgende Perl-Code zeigt, wie Sie eine Verbindung zu einer vorhandenen Datenbank herstellen. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#!/usr/bin/perl

use DBI;
use strict;

my $driver  = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

Lassen Sie uns nun das oben angegebene Programm ausführen, um unsere Datenbank zu öffnen testdb;; Wenn die Datenbank erfolgreich geöffnet wurde, wird die folgende Meldung angezeigt:

Open database successfully

Erstellen Sie eine Tabelle

Das folgende Perl-Programm wird verwendet, um eine Tabelle in einer zuvor erstellten Datenbank zu erstellen:

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname=$database;host=127.0.0.1;port=5432";
my $userid = "postgres"; my $password = "pass123";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL););
my $rv = $dbh->do($stmt); if($rv < 0) {
   print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();

Wenn das oben angegebene Programm ausgeführt wird, wird eine COMPANY-Tabelle in Ihrem erstellt testdb und es werden die folgenden Meldungen angezeigt -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende Perl-Programm zeigt, wie wir Datensätze in unserer im obigen Beispiel erstellten COMPANY-Tabelle erstellen können:

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "Pg"; my $database = "testdb";
my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432"; my $userid = "postgres";
my $password = "pass123"; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
   VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
   VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););
$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

Wenn das oben angegebene Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Perl-Programm zeigt, wie wir Datensätze aus unserer im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können:

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary  from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;
if($rv < 0) { print $DBI::errstr;
}
while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

UPDATE-Betrieb

Der folgende Perl-Code zeigt, wie wir mit der UPDATE-Anweisung jeden Datensatz aktualisieren und dann aktualisierte Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "Pg"; my $database = "testdb";
my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432"; my $userid = "postgres";
my $password = "pass123"; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
   print $DBI::errstr; }else{ print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
   print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
      print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

DELETE-Betrieb

Der folgende Perl-Code zeigt, wie wir mit der DELETE-Anweisung jeden Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID=2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;
if( $rv < 0 ) { print $DBI::errstr;
} else{
   print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary  from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;
if($rv < 0) { print $DBI::errstr;
}
while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

Installation

PostgreSQL kann mithilfe des Psycopg2-Moduls in Python integriert werden. sycopg2 ist ein PostgreSQL-Datenbankadapter für die Programmiersprache Python. psycopg2 wurde mit dem Ziel geschrieben, sehr klein und schnell und steinstabil zu sein. Sie müssen dieses Modul nicht separat installieren, da es standardmäßig zusammen mit Python Version 2.5.x ausgeliefert wird.

Wenn Sie es nicht auf Ihrem Computer installiert haben, können Sie es mit dem Befehl yum wie folgt installieren:

$yum install python-psycopg2

Um das psycopg2-Modul zu verwenden, müssen Sie zuerst ein Verbindungsobjekt erstellen, das die Datenbank darstellt. Anschließend können Sie optional ein Cursorobjekt erstellen, das Sie bei der Ausführung aller SQL-Anweisungen unterstützt.

Python-Psycopg2-Modul-APIs

Im Folgenden finden Sie wichtige Routinen für Psycopg2-Module, die für die Arbeit mit der PostgreSQL-Datenbank Ihres Python-Programms ausreichen können. Wenn Sie nach einer anspruchsvolleren Anwendung suchen, können Sie die offizielle Dokumentation des Python psycopg2-Moduls einsehen.

S. Nr. API & Beschreibung
1

psycopg2.connect(database="testdb", user="postgres", password="cohondob", host="127.0.0.1", port="5432")

Diese API öffnet eine Verbindung zur PostgreSQL-Datenbank. Wenn die Datenbank erfolgreich geöffnet wurde, wird ein Verbindungsobjekt zurückgegeben.

2

connection.cursor()

Diese Routine erstellt eine cursor Dies wird während Ihrer gesamten Datenbankprogrammierung mit Python verwendet.

3

cursor.execute(sql [, optional parameters])

Diese Routine führt eine SQL-Anweisung aus. Die SQL-Anweisung kann parametrisiert werden (dh Platzhalter anstelle von SQL-Literalen). Das psycopg2-Modul unterstützt Platzhalter mit% s-Zeichen

Zum Beispiel: cursor.execute ("In Personenwerte einfügen (% s,% s)", (wer, Alter))

4

cursor.executemany(sql, seq_of_parameters)

Diese Routine führt einen SQL-Befehl für alle Parametersequenzen oder Zuordnungen aus, die in der Sequenz sql gefunden werden.

5

cursor.callproc(procname[, parameters])

Diese Routine führt eine gespeicherte Datenbankprozedur mit dem angegebenen Namen aus. Die Folge von Parametern muss einen Eintrag für jedes Argument enthalten, das die Prozedur erwartet.

6

cursor.rowcount

Dieses schreibgeschützte Attribut gibt die Gesamtzahl der Datenbankzeilen zurück, die bis zur letzten Ausführung * () geändert, eingefügt oder gelöscht wurden.

7

connection.commit()

Diese Methode schreibt die aktuelle Transaktion fest. Wenn Sie diese Methode nicht aufrufen, ist alles, was Sie seit dem letzten Aufruf von commit () getan haben, für andere Datenbankverbindungen nicht sichtbar.

8

connection.rollback()

Diese Methode setzt alle Änderungen an der Datenbank seit dem letzten Aufruf von commit () zurück.

9

connection.close()

Diese Methode schließt die Datenbankverbindung. Beachten Sie, dass dies nicht automatisch commit () aufruft. Wenn Sie nur Ihre Datenbankverbindung schließen, ohne zuerst commit () aufzurufen, gehen Ihre Änderungen verloren!

10

cursor.fetchone()

Diese Methode ruft die nächste Zeile einer Abfrageergebnismenge ab und gibt eine einzelne Sequenz zurück oder Keine, wenn keine weiteren Daten verfügbar sind.

11

cursor.fetchmany([size=cursor.arraysize])

Diese Routine ruft den nächsten Satz von Zeilen eines Abfrageergebnisses ab und gibt eine Liste zurück. Eine leere Liste wird zurückgegeben, wenn keine Zeilen mehr verfügbar sind. Die Methode versucht, so viele Zeilen abzurufen, wie durch den Größenparameter angegeben.

12

cursor.fetchall()

Diese Routine ruft alle (verbleibenden) Zeilen eines Abfrageergebnisses ab und gibt eine Liste zurück. Eine leere Liste wird zurückgegeben, wenn keine Zeilen verfügbar sind.

Verbindung zur Datenbank herstellen

Der folgende Python-Code zeigt, wie Sie eine Verbindung zu einer vorhandenen Datenbank herstellen. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database="testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")

print "Opened database successfully"

Hier können Sie auch eine Datenbank angeben testdb als Name und wenn die Datenbank erfolgreich geöffnet wurde, wird die folgende Meldung angezeigt:

Open database successfully

Erstellen Sie eine Tabelle

Das folgende Python-Programm wird verwendet, um eine Tabelle in einer zuvor erstellten Datenbank zu erstellen:

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()
cur.execute('''CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL);''')
print "Table created successfully"

conn.commit()
conn.close()

Wenn das oben angegebene Programm ausgeführt wird, wird eine COMPANY-Tabelle in Ihrem erstellt test.db und es werden die folgenden Meldungen angezeigt -

Opened database successfully
Table created successfully

INSERT-Betrieb

Das folgende Python-Programm zeigt, wie wir Datensätze in unserer im obigen Beispiel erstellten COMPANY-Tabelle erstellen können:

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");

conn.commit()
print "Records created successfully";
conn.close()

Wenn das oben angegebene Programm ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Das folgende Python-Programm zeigt, wie wir Datensätze aus unserer im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können:

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
ID =  1
NAME =  Paul
ADDRESS =  California
SALARY =  20000.0

ID =  2
NAME =  Allen
ADDRESS =  Texas
SALARY =  15000.0

ID =  3
NAME =  Teddy
ADDRESS =  Norway
SALARY =  20000.0

ID =  4
NAME =  Mark
ADDRESS =  Rich-Mond
SALARY =  65000.0

Operation done successfully

UPDATE-Betrieb

Der folgende Python-Code zeigt, wie wir mit der UPDATE-Anweisung jeden Datensatz aktualisieren und dann aktualisierte Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", cur.rowcount

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Total number of rows updated : 1
ID =  1
NAME =  Paul
ADDRESS =  California
SALARY =  25000.0

ID =  2
NAME =  Allen
ADDRESS =  Texas
SALARY =  15000.0

ID =  3
NAME =  Teddy
ADDRESS =  Norway
SALARY =  20000.0

ID =  4
NAME =  Mark
ADDRESS =  Rich-Mond
SALARY =  65000.0

Operation done successfully

DELETE-Betrieb

Der folgende Python-Code zeigt, wie wir mit der DELETE-Anweisung jeden Datensatz löschen und dann die verbleibenden Datensätze aus unserer COMPANY-Tabelle abrufen und anzeigen können.

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("DELETE from COMPANY where ID=2;")
conn.commit()
print "Total number of rows deleted :", cur.rowcount

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Wenn das oben angegebene Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Opened database successfully
Total number of rows deleted : 1
ID =  1
NAME =  Paul
ADDRESS =  California
SALARY =  20000.0

ID =  3
NAME =  Teddy
ADDRESS =  Norway
SALARY =  20000.0

ID =  4
NAME =  Mark
ADDRESS =  Rich-Mond
SALARY =  65000.0

Operation done successfully