PostgreSQL - Guida rapida

PostgreSQL è un potente sistema di database relazionale a oggetti open source. Ha più di 15 anni di fase di sviluppo attivo e un'architettura collaudata che le ha guadagnato una solida reputazione per affidabilità, integrità dei dati e correttezza.

Questo tutorial ti darà un rapido inizio con PostgreSQL e ti metterà a tuo agio con la programmazione PostgreSQL.

Cos'è PostgreSQL?

PostgreSQL (pronunciato come post-gress-Q-L) è un sistema di gestione di database relazionali (DBMS) open source sviluppato da un team mondiale di volontari. PostgreSQL non è controllato da alcuna società o altra entità privata e il codice sorgente è disponibile gratuitamente.

Una breve storia di PostgreSQL

PostgreSQL, originariamente chiamato Postgres, è stato creato all'UCB da un professore di informatica di nome Michael Stonebraker. Stonebraker ha avviato Postgres nel 1986 come progetto successivo al suo predecessore, Ingres, ora di proprietà di Computer Associates.

1977-1985 - È stato sviluppato un progetto chiamato INGRES.
- Prova di concetto per database relazionali
- Ha fondato la società Ingres nel 1980
- Acquistato da Computer Associates nel 1994
1986-1994 - POSTGRES
- Sviluppo dei concetti in INGRES con particolare attenzione all'orientamento agli oggetti e al linguaggio di query - Quel
- Il codice base di INGRES non è stato utilizzato come base per POSTGRES
- Commercializzato come Illustra (acquistato da Informix, acquistato da IBM)
1994-1995 - Postgres95
- Il supporto per SQL è stato aggiunto nel 1994
- Rilasciato come Postgres95 nel 1995
- Ripubblicato come PostgreSQL 6.0 nel 1996
- Costituzione del team di sviluppo globale di PostgreSQL

Caratteristiche principali di PostgreSQL

PostgreSQL funziona su tutti i principali sistemi operativi, inclusi Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64) e Windows. Supporta testo, immagini, suoni e video e include interfacce di programmazione per C / C ++, Java, Perl, Python, Ruby, Tcl e Open Database Connectivity (ODBC).

PostgreSQL supporta gran parte dello standard SQL e offre molte funzionalità moderne, tra cui le seguenti:

Query SQL complesse
Sottoselezioni SQL
Chiavi esterne
Trigger
Views
Transactions
Controllo della concorrenza multiversione (MVCC)
Streaming Replication (a partire dalla 9.0)
Hot Standby (a partire dalla 9.0)

Puoi controllare la documentazione ufficiale di PostgreSQL per comprendere le funzionalità sopra menzionate. PostgreSQL può essere esteso dall'utente in molti modi. Ad esempio aggiungendo nuovo -

Tipi di dati
Functions
Operators
Funzioni aggregate
Metodi di indice

Supporto linguistico procedurale

PostgreSQL supporta quattro linguaggi procedurali standard, che consentono agli utenti di scrivere il proprio codice in uno qualsiasi dei linguaggi e può essere eseguito dal server di database PostgreSQL. Questi linguaggi procedurali sono: PL / pgSQL, PL / Tcl, PL / Perl e PL / Python. Inoltre, sono supportati anche altri linguaggi procedurali non standard come PL / PHP, PL / V8, PL / Ruby, PL / Java, ecc.

Per iniziare a comprendere le basi di PostgreSQL, installiamo prima PostgreSQL. Questo capitolo spiega come installare PostgreSQL su piattaforme Linux, Windows e Mac OS.

Installazione di PostgreSQL su Linux / Unix

Segui i passaggi indicati per installare PostgreSQL sulla tua macchina Linux. Assicurati di aver effettuato l'accesso comeroot prima di procedere con l'installazione.

Scegli il numero di versione di PostgreSQL che desideri e, nel modo più preciso possibile, la piattaforma che desideri da EnterpriseDB
ho scaricato postgresql-9.2.4-1-linux-x64.runper la mia macchina CentOS-6 a 64 bit. Ora, eseguiamolo come segue:

[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]:

Una volta avviato il programma di installazione, ti vengono poste alcune domande di base come la posizione dell'installazione, la password dell'utente che utilizzerà il database, il numero di porta, ecc. Quindi tieni tutti i valori predefiniti tranne la password, che puoi fornire la password secondo la tua scelta. Installerà PostgreSQL sulla tua macchina Linux e mostrerà il seguente messaggio:

Please wait while Setup installs PostgreSQL on your computer.

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

-----------------------------------------------------------------------
Setup has finished installing PostgreSQL on your computer.

Segui i seguenti passaggi di post-installazione per creare il tuo database:

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

test=#

È possibile avviare / riavviare il server postgres nel caso in cui non sia in esecuzione utilizzando il seguente comando:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Se la tua installazione è stata corretta, avrai il prompt di PotsgreSQL test=# come mostrato sopra.

Installazione di PostgreSQL su Windows

Segui i passaggi indicati per installare PostgreSQL sulla tua macchina Windows. Assicurati di aver disattivato l'antivirus di terze parti durante l'installazione.

Scegli il numero di versione di PostgreSQL che desideri e, nel modo più preciso possibile, la piattaforma che desideri da EnterpriseDB
Ho scaricato postgresql-9.2.4-1-windows.exe per il mio PC Windows in esecuzione in modalità a 32 bit, quindi eseguiamo postgresql-9.2.4-1-windows.execome amministratore per installare PostgreSQL. Seleziona la posizione in cui desideri installarlo. Per impostazione predefinita, viene installato nella cartella Programmi.

Il passaggio successivo del processo di installazione consiste nel selezionare la directory in cui verranno archiviati i dati. Per impostazione predefinita, viene memorizzato nella directory "dati".

Successivamente, la configurazione richiede la password, quindi puoi utilizzare la tua password preferita.

Il prossimo passo; mantenere la porta come predefinita.

Nel passaggio successivo, quando è stato chiesto "Impostazioni locali", ho selezionato "Inglese, Stati Uniti".
Ci vuole un po 'per installare PostgreSQL sul tuo sistema. Al termine del processo di installazione, apparirà la seguente schermata. Deseleziona la casella di controllo e fai clic sul pulsante Fine.

Una volta completato il processo di installazione, puoi accedere a pgAdmin III, StackBuilder e alla shell PostgreSQL dal menu del programma in PostgreSQL 9.2.

Installazione di PostgreSQL su Mac

Segui i passaggi indicati per installare PostgreSQL sul tuo computer Mac. Assicurati di aver effettuato l'accesso comeadministrator prima di procedere con l'installazione.

Scegli il numero di versione più recente di PostgreSQL per Mac OS disponibile su EnterpriseDB
ho scaricato postgresql-9.2.4-1-osx.dmgper il mio sistema operativo Mac con OS X versione 10.8.3. Ora, apriamo l'immagine dmg nel Finder e facciamo semplicemente doppio clic su di essa per ottenere il programma di installazione di PostgreSQL nella finestra seguente:

Quindi fare clic su postgres-9.2.4-1-osxicona, che darà un messaggio di avviso. Accetta l'avviso e procedi per un'ulteriore installazione. Chiederà la password dell'amministratore come mostrato nella finestra seguente:

Immettere la password, procedere con l'installazione e, dopo questo passaggio, riavviare il computer Mac. Se non vedi la seguente finestra, riavvia l'installazione.

Una volta avviato il programma di installazione, ti vengono poste alcune domande di base come la posizione dell'installazione, la password dell'utente che utilizzerà il database, il numero di porta ecc. Pertanto, tieni tutti i valori predefiniti tranne la password, che puoi fornire secondo la tua scelta. Installerà PostgreSQL sul tuo computer Mac nella cartella dell'applicazione che puoi controllare -

Ora puoi avviare qualsiasi programma con cui iniziare. Cominciamo con SQL Shell. Quando avvii SQL Shell, usa solo tutti i valori predefiniti che visualizza tranne, inserisci la tua password, che avevi selezionato al momento dell'installazione. Se tutto va bene, sarai nel database di postgres e in un filepostgress# verrà visualizzato come mostrato di seguito:

Congratulazioni!!! Ora hai il tuo ambiente pronto per iniziare con la programmazione del database PostgreSQL.

Questo capitolo fornisce un elenco dei comandi SQL di PostgreSQL, seguito dalle precise regole di sintassi per ciascuno di questi comandi. Questo set di comandi è preso dallo strumento della riga di comando psql. Ora che hai installato Postgres, apri psql come -

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

Usando psql, puoi generare un elenco completo di comandi usando il comando \ help. Per la sintassi di un comando specifico, utilizzare il seguente comando:

postgres-# \help <command_name>

L'istruzione SQL

Un'istruzione SQL è composta da token in cui ogni token può rappresentare una parola chiave, un identificatore, un identificatore tra virgolette, una costante o un simbolo di carattere speciale. La tabella riportata di seguito utilizza una semplice istruzione SELECT per illustrare un'istruzione SQL di base, ma completa, e i suoi componenti.

	SELEZIONARE	id, nome	A PARTIRE DAL	stati
Tipo di token	Parola chiave	Identificatori	Parola chiave	Identificatore
Descrizione	Comando	Colonne ID e nome	Clausola	Nome tabella

Comandi SQL PostgreSQL

ABORT

Interrompi la transazione corrente.

ABORT [ WORK | TRANSACTION ]

ALTER AGGREGATE

Modifica la definizione di una funzione aggregata.

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

ALTER CONVERSION

Modifica la definizione di una conversione.

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

ALTER DATABASE

Modificare un parametro specifico del database.

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

Modificare la definizione di un parametro specifico del dominio.

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

FUNZIONE ALTER

Modificare la definizione di una funzione.

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

ALTER GROUP

Modifica un gruppo di utenti.

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

ALTER INDEX

Modifica la definizione di un indice.

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

ALTER LANGUAGE

Modificare la definizione di un linguaggio procedurale.

ALTER LANGUAGE name RENAME TO new_name

ALTER OPERATOR

Modifica la definizione di un operatore.

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

ALTERARE LA CLASSE OPERATORE

Modificare la definizione di una classe di operatore.

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

ALTER SCHEMA

Modifica la definizione di uno schema.

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

ALTER SEQUENCE

Modifica la definizione di un generatore di sequenze.

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

ALTER TABLE

Modifica la definizione di una tabella.

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

Dove l' azione è una delle seguenti righe:

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

Modifica la definizione di un tablespace.

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

ALTER TRIGGER

Modifica la definizione di un trigger.

ALTER TRIGGER name ON table RENAME TO new_name

ALTER TYPE

Modifica la definizione di un tipo.

ALTER TYPE name OWNER TO new_owner

ALTER USER

Modifica un account utente del database.

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

Dove può essere l' opzione -

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

ANALIZZARE

Raccogli statistiche su un database.

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

INIZIO

Avvia un blocco delle transazioni.

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

Dove transaction_mode è uno di -

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

PUNTO DI CONTROLLO

Forza un checkpoint del log delle transazioni.

CHECKPOINT

VICINO

Chiudi un cursore.

CLOSE name

GRAPPOLO

Raggruppa una tabella in base a un indice.

CLUSTER index_name ON table_name
CLUSTER table_name
CLUSTER

COMMENTO

Definisci o modifica il commento di un oggetto.

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'

COMMETTERE

Effettua il commit della transazione corrente.

COMMIT [ WORK | TRANSACTION ]

COPIA

Copia i dati tra un file e una tabella.

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 [, ...] ]

CREA AGGREGATO

Definisci una nuova funzione di aggregazione.

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

CREA CAST

Definisci un nuovo cast.

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 ]

CREA UN ATTIVATORE DI VINCOLO

Definisci un nuovo trigger di vincolo.

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

CREA LA CONVERSIONE

Definisci una nuova conversione.

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

CREA DATABASE

Crea un nuovo database.

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

CREA DOMINIO

Definisci un nuovo dominio.

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

Dove il vincolo è -

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

CREA FUNZIONE

Definisci una nuova funzione.

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 [, ...] ) ]

CREARE UN GRUPPO

Definisci un nuovo gruppo di utenti.

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

CREA INDICE

Definisci un nuovo indice.

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

CREA LINGUA

Definisci un nuovo linguaggio procedurale.

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

CREA OPERATORE

Definisci un nuovo operatore.

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 ]
)

CREA UNA CLASSE OPERATORE

Definisci una nuova classe operatore.

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
} [, ... ]

CREA REGOLA

Definisci una nuova regola di riscrittura.

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

CREA SCHEMA

Definisci un nuovo schema.

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

CREA SEQUENZA

Definisci un nuovo generatore di sequenze.

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

CREA TABELLA

Definisci una nuova tabella.

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 ]

Dove column_constraint è -

[ 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 ]

E table_constraint è -

[ 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 ]

CREA TABELLA COME

Definisci una nuova tabella dai risultati di una query.

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

CREA SPAZIO TABELLA

Definisci un nuovo tablespace.

CREATE TABLESPACE tablespace_name [ OWNER username ] LOCATION 'directory'

CREA TRIGGER

Definisci un nuovo trigger.

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

CREA TIPO

Definisci un nuovo tipo di dati.

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 ]
)

CREARE UN UTENTE

Definisci un nuovo account utente del database.

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

Dove può essere l' opzione -

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

CREA VISTA

Definisci una nuova vista.

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

DEALLOCATE

Distribuire una dichiarazione preparata.

DEALLOCATE [ PREPARE ] plan_name

DICHIARARE

Definisci un cursore.

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

ELIMINA

Elimina le righe di una tabella.

DELETE FROM [ ONLY ] table [ WHERE condition ]

DROP AGGREGATE

Rimuovi una funzione aggregata.

DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]

DROP CAST

Rimuovi un cast.

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

CONVERSIONE DROP

Rimuovi una conversione.

DROP CONVERSION name [ CASCADE | RESTRICT ]

DROP DATABASE

Rimuovi un database.

DROP DATABASE name

DROP DOMAIN

Rimuovi un dominio.

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

FUNZIONE DROP

Rimuovi una funzione.

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

GRUPPO DROP

Rimuovi un gruppo di utenti.

DROP GROUP name

INDICE DI CADUTA

Rimuovi un indice.

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

LINGUA DROP

Rimuovi un linguaggio procedurale.

DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]

OPERATORE DROP

Rimuovi un operatore.

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

CLASSE DROP OPERATOR

Rimuovi una classe operatore.

DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]

REGOLA DROP

Rimuovi una regola di riscrittura.

DROP RULE name ON relation [ CASCADE | RESTRICT ]

DROP SCHEMA

Rimuovi uno schema.

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

SEQUENZA DROP

Rimuovi una sequenza.

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

TABELLA DI CADUTA

Rimuovi un tavolo.

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

DROP TABLESPACE

Rimuovi uno spazio tabella.

DROP TABLESPACE tablespace_name

GRILLETTO DI CADUTA

Rimuovi un trigger.

DROP TRIGGER name ON table [ CASCADE | RESTRICT ]

TIPO DI GOCCIA

Rimuovi un tipo di dati.

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

DROP USER

Rimuovere un account utente dal database.

DROP USER name

VISTA DROP

Rimuovi una vista.

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

FINE

Effettua il commit della transazione corrente.

END [ WORK | TRANSACTION ]

ESEGUIRE

Eseguire una dichiarazione preparata.

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

SPIEGARE

Mostra il piano di esecuzione di una dichiarazione.

EXPLAIN [ ANALYZE ] [ VERBOSE ] statement

FETCH

Recupera le righe da una query utilizzando un cursore.

FETCH [ direction { FROM | IN } ] cursor_name

Dove la direzione può essere vuota o una di -

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

CONCEDERE

Definisci i privilegi di accesso.

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 ]

INSERIRE

Crea nuove righe in una tabella.

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

ASCOLTA

Ascolta una notifica.

LISTEN name

CARICARE

Carica o ricarica un file di libreria condivisa.

LOAD 'filename'

SERRATURA

Blocca un tavolo.

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

Dove lock_mode è uno di -

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

MOSSA

Posiziona un cursore.

MOVE [ direction { FROM | IN } ] cursor_name

NOTIFICARE

Genera una notifica.

NOTIFY name

PREPARARE

Prepara una dichiarazione per l'esecuzione.

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

REINDICE

Ricostruisci gli indici.

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

RILASCIARE SAVEPOINT

Distruggi un punto di salvataggio definito in precedenza.

RELEASE [ SAVEPOINT ] savepoint_name

RIPRISTINA

Ripristina il valore di un parametro di runtime al valore predefinito.

RESET name
RESET ALL

REVOCARE

Rimuovi privilegi di accesso.

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

Interrompi la transazione corrente.

ROLLBACK [ WORK | TRANSACTION ]

ROLLBACK PER SAVEPOINT

Torna a un punto di salvataggio.

ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name

SAVEPOINT

Definisci un nuovo punto di salvataggio all'interno della transazione corrente.

SAVEPOINT savepoint_name

SELEZIONARE

Recupera righe da una tabella o da una vista.

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 [, ...] ) ]

SELEZIONA IN

Definisci una nuova tabella dai risultati di una query.

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 [, ...] ] ]

IMPOSTATO

Modificare un parametro di runtime.

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

IMPOSTARE I VINCOLI

Imposta le modalità di verifica dei vincoli per la transazione corrente.

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

IMPOSTA AUTORIZZAZIONE SESSIONE

Imposta l'identificativo utente della sessione e l'identificativo utente corrente della sessione corrente.

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

IMPOSTA LA TRANSAZIONE

Imposta le caratteristiche della transazione corrente.

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

Dove transaction_mode è uno di -

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

SPETTACOLO

Mostra il valore di un parametro di runtime.

SHOW name
SHOW ALL

INIZIA LA TRANSAZIONE

Avvia un blocco delle transazioni.

START TRANSACTION [ transaction_mode [, ...] ]

Dove transaction_mode è uno di -

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

TRONCARE

Svuota un tavolo.

TRUNCATE [ TABLE ] name

NON ASCOLTARE

Smetti di ascoltare una notifica.

UNLISTEN { name | * }

AGGIORNARE

Aggiorna le righe di una tabella.

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

VUOTO

Garbage-collect e facoltativamente analizza un database.

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

In questo capitolo, discuteremo dei tipi di dati usati in PostgreSQL. Durante la creazione della tabella, per ogni colonna, specifichi un tipo di dati, cioè il tipo di dati che desideri memorizzare nei campi della tabella.

Ciò consente diversi vantaggi:

Consistency - Le operazioni su colonne dello stesso tipo di dati danno risultati coerenti e di solito sono le più veloci.
Validation - L'uso corretto dei tipi di dati implica la convalida del formato dei dati e il rifiuto dei dati al di fuori dell'ambito del tipo di dati.
Compactness - Poiché una colonna può memorizzare un singolo tipo di valore, viene memorizzata in modo compatto.
Performance- L'uso corretto dei tipi di dati offre la memorizzazione più efficiente dei dati. I valori memorizzati possono essere elaborati rapidamente, il che migliora le prestazioni.

PostgreSQL supporta un'ampia gamma di tipi di dati. Inoltre, gli utenti possono creare il proprio tipo di dati personalizzato utilizzando il comando SQL CREATE TYPE . Esistono diverse categorie di tipi di dati in PostgreSQL. Sono discussi di seguito.

Tipi numerici

I tipi numerici sono costituiti da numeri interi a due, quattro e otto byte, numeri in virgola mobile a quattro e otto byte e decimali con precisione selezionabile. La tabella seguente elenca i tipi disponibili.

Nome	Dimensioni di archiviazione	Descrizione	Gamma
smallint	2 byte	numero intero di piccole dimensioni	Da -32768 a +32767
numero intero	4 byte	scelta tipica per intero	Da -2147483648 a +2147483647
bigint	8 byte	numero intero di ampia portata	-9223372036854775808 a 9223372036854775807
decimale	variabile	precisione specificata dall'utente, esatta	fino a 131072 cifre prima del punto decimale; fino a 16383 cifre dopo il punto decimale
numerico	variabile	precisione specificata dall'utente, esatta	fino a 131072 cifre prima del punto decimale; fino a 16383 cifre dopo il punto decimale
vero	4 byte	precisione variabile, inesatta	6 cifre decimali di precisione
doppia precisione	8 byte	precisione variabile, inesatta	Precisione di 15 cifre decimali
smallserial	2 byte	piccolo intero autoincrementante	Da 1 a 32767
seriale	4 byte	numero intero autoincrementante	1 fino a 2147483647
bigserial	8 byte	grande intero autoincrementante	1 fino a 9223372036854775807

Tipi monetari

Il tipo di denaro memorizza un importo in valuta con una precisione frazionaria fissa. I valori dei tipi di dati numerico, int e bigint possono essere convertiti in denaro . L'utilizzo di numeri in virgola mobile non è consigliato per gestire il denaro a causa della possibilità di errori di arrotondamento.

Nome	Dimensioni di archiviazione	Descrizione	Gamma
i soldi	8 byte	importo in valuta	-92233720368547758.08 a +92233720368547758.07

Tipi di carattere

La tabella riportata di seguito elenca i tipi di caratteri generici disponibili in PostgreSQL.

S. No.	Nome e descrizione
1	character varying(n), varchar(n) lunghezza variabile con limite
2	character(n), char(n) lunghezza fissa, imbottitura in bianco
3	text lunghezza illimitata variabile

Tipi di dati binari

Il tipo di dati bytea consente la memorizzazione di stringhe binarie come nella tabella riportata di seguito.

Nome	Dimensioni di archiviazione	Descrizione
bytea	1 o 4 byte più la stringa binaria effettiva	stringa binaria di lunghezza variabile

Tipi di data / ora

PostgreSQL supporta un set completo di tipi di data e ora SQL, come mostrato nella tabella seguente. Le date vengono conteggiate secondo il calendario gregoriano. Qui, tutti i tipi hanno una risoluzione di1 microsecond / 14 digits tranne date tipo, la cui risoluzione è day.

Nome	Dimensioni di archiviazione	Descrizione	Basso valore	Alto valore
timestamp [(p)] [senza fuso orario]	8 byte	sia la data che l'ora (nessun fuso orario)	4713 a.C.	294276 d.C.
TIMESTAMPTZ	8 byte	sia la data che l'ora, con il fuso orario	4713 a.C.	294276 d.C.
Data	4 byte	data (nessuna ora del giorno)	4713 a.C.	5874897 d.C.
ora [(p)] [senza fuso orario]	8 byte	ora del giorno (nessuna data)	00:00:00	24:00:00
ora [(p)] con fuso orario	12 byte	solo ore del giorno, con fuso orario	00: 00: 00 + 1459	24: 00: 00-1459
intervallo [campi] [(p)]	12 byte	Intervallo di tempo	-178000000 anni	178000000 anni

Tipo booleano

PostgreSQL fornisce il tipo SQL standard booleano. Il tipo di dati booleano può avere gli stati true , false e un terzo stato, unknown , rappresentato dal valore null SQL.

Nome	Dimensioni di archiviazione	Descrizione
booleano	1 byte	stato di vero o falso

Tipo enumerato

I tipi enumerati (enum) sono tipi di dati che comprendono un insieme di valori statico e ordinato. Sono equivalenti ai tipi enum supportati in numerosi linguaggi di programmazione.

A differenza di altri tipi, i tipi enumerati devono essere creati utilizzando il comando CREATE TYPE. Questo tipo viene utilizzato per memorizzare un insieme di valori statico e ordinato. Ad esempio le direzioni della bussola, ovvero NORD, SUD, EST e OVEST o giorni della settimana come mostrato di seguito -

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

Enumerato, una volta creato, può essere utilizzato come qualsiasi altro tipo.

Tipo geometrico

I tipi di dati geometrici rappresentano oggetti spaziali bidimensionali. Il tipo più fondamentale, il punto, costituisce la base per tutti gli altri tipi.

Nome	Dimensioni di archiviazione	Rappresentazione	Descrizione
punto	16 byte	Punto su un aereo	(x, y)
linea	32 byte	Linea infinita (non completamente implementata)	((x1, y1), (x2, y2))
lseg	32 byte	Segmento di linea finita	((x1, y1), (x2, y2))
scatola	32 byte	Scatola rettangolare	((x1, y1), (x2, y2))
sentiero	16 + 16n byte	Percorso chiuso (simile al poligono)	((x1, y1), ...)
sentiero	16 + 16n byte	Percorso aperto	[(x1, y1), ...]
poligono	40 + 16n	Poligono (simile al percorso chiuso)	((x1, y1), ...)
cerchio	24 byte	Cerchio	<(x, y), r> (punto centrale e raggio)

Tipo di indirizzo di rete

PostgreSQL offre tipi di dati per memorizzare indirizzi IPv4, IPv6 e MAC. È preferibile utilizzare questi tipi invece dei tipi di testo normale per memorizzare gli indirizzi di rete, poiché questi tipi offrono il controllo degli errori di input e operatori e funzioni specializzati.

Nome	Dimensioni di archiviazione	Descrizione
cidr	7 o 19 byte	Reti IPv4 e IPv6
inet	7 o 19 byte	Host e reti IPv4 e IPv6
macaddr	6 byte	Indirizzi MAC

Tipo di stringa di bit

I tipi di stringa di bit vengono utilizzati per memorizzare le maschere di bit. Possono essere 0 o 1. Esistono due tipi di bit SQL:bit(n) e bit varying(n), dove n è un numero intero positivo.

Tipo di ricerca del testo

Questo tipo supporta la ricerca full-text, ovvero l'attività di ricerca in una raccolta di documenti in linguaggio naturale per individuare quelli che corrispondono meglio a una query. Ci sono due tipi di dati per questo:

S. No.	Nome e descrizione
1	tsvector Questo è un elenco ordinato di parole distinte che sono state normalizzate per unire diverse varianti della stessa parola, chiamate "lessemi".
2	tsquery Memorizza i lessemi da cercare e li combina rispettando gli operatori booleani & (AND), \| (OR) e! (NON). Le parentesi possono essere utilizzate per imporre il raggruppamento degli operatori.

Tipo UUID

Un UUID (Universally Unique Identifiers) è scritto come una sequenza di cifre esadecimali minuscole, in diversi gruppi separati da trattini, in particolare un gruppo di otto cifre, seguito da tre gruppi di quattro cifre, seguito da un gruppo di 12 cifre, per un totale di 32 cifre che rappresentano i 128 bit.

Un esempio di UUID è - 550e8400-e29b-41d4-a716-446655440000

Tipo XML

Il tipo di dati XML può essere utilizzato per memorizzare i dati XML. Per memorizzare i dati XML, prima devi creare valori XML utilizzando la funzione xmlparse come segue:

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

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

Tipo JSON

Il tipo di dati json può essere utilizzato per memorizzare i dati JSON (JavaScript Object Notation). Tali dati possono anche essere archiviati come testo , ma il tipo di dati json ha il vantaggio di verificare che ogni valore memorizzato sia un valore JSON valido. Sono disponibili anche funzioni di supporto correlate, che possono essere utilizzate direttamente per gestire il tipo di dati JSON come segue.

Esempio	Risultato di esempio
array_to_json ('{{1,5}, {99,100}}' :: int [])	[[1,5], [99,100]]
row_to_json (row (1, 'foo'))	{"f1": 1, "f2": "foo"}

Tipo di array

PostgreSQL offre l'opportunità di definire una colonna di una tabella come un array multidimensionale di lunghezza variabile. È possibile creare array di qualsiasi tipo di base predefinito o definito dall'utente, tipo enum o tipo composto.

Dichiarazione di array

Il tipo di array può essere dichiarato come

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

o utilizzando la parola chiave "ARRAY" come

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

Inserimento di valori

I valori di matrice possono essere inseriti come costante letterale, racchiudendo i valori degli elementi tra parentesi graffe e separandoli con virgole. Di seguito è mostrato un esempio:

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

Accesso agli array

Di seguito è mostrato un esempio per l'accesso agli array. Il comando dato di seguito selezionerà le persone i cui risparmi sono maggiori nel secondo trimestre rispetto al quarto trimestre.

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

Modifica degli array

Un esempio di modifica degli array è mostrato di seguito.

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

o utilizzando la sintassi dell'espressione ARRAY -

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

Ricerca di array

Un esempio di ricerca negli array è mostrato di seguito.

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;

Se la dimensione dell'array è nota, è possibile utilizzare il metodo di ricerca indicato sopra. Altrimenti, il seguente esempio mostra come eseguire la ricerca quando la dimensione non è nota.

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

Tipi compositi

Questo tipo rappresenta un elenco di nomi di campo e dei relativi tipi di dati, ovvero la struttura di una riga o un record di una tabella.

Dichiarazione dei tipi compositi

L'esempio seguente mostra come dichiarare un tipo composto

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

Questo tipo di dati può essere utilizzato nelle tabelle di creazione come di seguito:

CREATE TABLE on_hand (
   item inventory_item,
   count integer
);

Input di valore composito

I valori compositi possono essere inseriti come costante letterale, racchiudendo i valori del campo tra parentesi e separandoli con virgole. Di seguito è mostrato un esempio:

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

Questo è valido per inventario_item definito sopra. La parola chiave ROW è in realtà facoltativa fintanto che hai più di un campo nell'espressione.

Accesso ai tipi compositi

Per accedere a un campo di una colonna composta, utilizzare un punto seguito dal nome del campo, proprio come selezionare un campo dal nome di una tabella. Ad esempio, per selezionare alcuni sottocampi dalla nostra tabella di esempio on_hand, la query sarà come mostrato di seguito:

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

Puoi anche usare anche il nome della tabella (ad esempio in una query multitabile), in questo modo:

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

Tipi di intervallo

I tipi di intervallo rappresentano i tipi di dati che utilizzano un intervallo di dati. Il tipo di intervallo può essere intervalli discreti (ad esempio, tutti i valori interi da 1 a 10) o intervalli continui (ad esempio, qualsiasi momento tra le 10:00 e le 11:00).

I tipi di gamma incorporati disponibili includono le seguenti gamme:

int4range - Intervallo di numeri interi
int8range - Gamma di bigint
numrange - Intervallo numerico
tsrange - Intervallo di timestamp senza fuso orario
tstzrange - Intervallo di timestamp con fuso orario
daterange - Intervallo di date

È possibile creare tipi di intervallo personalizzati per rendere disponibili nuovi tipi di intervalli, ad esempio intervalli di indirizzi IP utilizzando il tipo inet come base o intervalli float utilizzando il tipo di dati float come base.

I tipi di intervallo supportano limiti di intervallo inclusivi ed esclusivi utilizzando rispettivamente i caratteri [] e (). Ad esempio "[4,9)" rappresenta tutti i numeri interi a partire da e compreso 4 fino a 9 ma escluso.

Tipi di identificatori di oggetti

Gli identificatori di oggetti (OID) vengono utilizzati internamente da PostgreSQL come chiavi primarie per varie tabelle di sistema. Se WITH OIDS è specificato o la variabile di configurazione default_with_oids è abilitata, solo allora, in questi casi, gli OID vengono aggiunti alle tabelle create dall'utente. La tabella seguente elenca diversi tipi di alias. I tipi di alias OID non hanno operazioni proprie ad eccezione di routine di input e output specializzate.

Nome	Riferimenti	Descrizione	Esempio di valore
oid	qualunque	identificatore numerico di oggetto	564182
regproc	pg_proc	nome della funzione	somma
regprocedure	pg_proc	funzione con tipi di argomenti	somma (int4)
regoper	pg_operator	nome dell'operatore	+
registratore	pg_operator	operatore con tipi di argomenti	* (intero, intero) o - (NESSUNO, intero)
regclass	pg_class	nome della relazione	pg_type
regtype	pg_type	nome del tipo di dati	numero intero
regconfig	pg_ts_config	configurazione della ricerca di testo	Inglese
regdictionary	pg_ts_dict	dizionario di ricerca di testo	semplice

Pseudo tipi

Il sistema di tipi PostgreSQL contiene una serie di voci speciali che vengono chiamate collettivamente pseudo-tipi. Uno pseudo-tipo non può essere utilizzato come tipo di dati di colonna, ma può essere utilizzato per dichiarare l'argomento di una funzione o il tipo di risultato.

La tabella riportata di seguito elenca gli pseudo-tipi esistenti.

S. No.	Nome e descrizione
1	any Indica che una funzione accetta qualsiasi tipo di dati di input.
2	anyelement Indica che una funzione accetta qualsiasi tipo di dati.
3	anyarray Indica che una funzione accetta qualsiasi tipo di dati di matrice.
4	anynonarray Indica che una funzione accetta qualsiasi tipo di dati non array.
5	anyenum Indica che una funzione accetta qualsiasi tipo di dati enum.
6	anyrange Indica che una funzione accetta qualsiasi tipo di dati di intervallo.
7	cstring Indica che una funzione accetta o restituisce una stringa C con terminazione null.
8	internal Indica che una funzione accetta o restituisce un tipo di dati interno al server.
9	language_handler Un gestore di chiamate procedurali di linguaggio viene dichiarato per restituire language_handler.
10	fdw_handler Un gestore wrapper di dati esterni viene dichiarato per restituire fdw_handler.
11	record Identifica una funzione che restituisce un tipo di riga non specificato.
12	trigger Una funzione trigger viene dichiarata per restituire trigger.
13	void Indica che una funzione non restituisce alcun valore.

Questo capitolo discute su come creare un nuovo database nel tuo PostgreSQL. PostgreSQL offre due modi per creare un nuovo database:

Utilizzando CREATE DATABASE, un comando SQL.
Utilizzo di createdb un eseguibile da riga di comando.

Utilizzando CREATE DATABASE

Questo comando creerà un database dal prompt della shell di PostgreSQL, ma dovresti avere i privilegi appropriati per creare un database. Per impostazione predefinita, il nuovo database verrà creato clonando il modello di database di sistema standard1 .

Sintassi

La sintassi di base dell'istruzione CREATE DATABASE è la seguente:

CREATE DATABASE dbname;

dove dbname è il nome di un database da creare.

Esempio

Quello che segue è un semplice esempio, che creerà testdb nel tuo schema PostgreSQL

postgres=# CREATE DATABASE testdb;
postgres-#

Utilizzando il comando createdb

L'eseguibile della riga di comando di PostgreSQL createdb è un wrapper del comando SQL CREATE DATABASE . L'unica differenza tra questo comando e il comando SQL CREATE DATABASE è che il primo può essere eseguito direttamente dalla riga di comando e consente di aggiungere un commento al database, tutto in un comando.

Sintassi

La sintassi per createdb è come mostrato di seguito:

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

Parametri

La tabella riportata di seguito elenca i parametri con le relative descrizioni.

S. No.	Parametro e descrizione
1	dbname Il nome di un database da creare.
2	description Specifica un commento da associare al database appena creato.
3	options argomenti della riga di comando, che createdb accetta.

Opzioni

La tabella seguente elenca gli argomenti della riga di comando createdb accetta -

S. No.	Opzione e descrizione
1	-D tablespace Specifica lo spazio tabelle predefinito per il database.
2	-e Fai eco ai comandi che createdb genera e invia al server.
3	-E encoding Specifica lo schema di codifica dei caratteri da utilizzare in questo database.
4	-l locale Specifica la locale da utilizzare in questo database.
5	-T template Specifica il database modello da cui creare questo database.
6	--help Mostra la guida sugli argomenti della riga di comando di createdb ed esci.
7	-h host Specifica il nome host della macchina su cui è in esecuzione il server.
8	-p port Specifica la porta TCP o l'estensione del file socket del dominio Unix locale su cui il server è in ascolto per le connessioni.
9	-U username Nome utente con cui connettersi.
10	-w Non emettere mai una richiesta di password.
11	-W Forza createdb a richiedere una password prima di connettersi a un database.

Apri il prompt dei comandi e vai alla directory in cui è installato PostgreSQL. Vai alla directory bin ed esegui il seguente comando per creare un database.

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

Il comando sopra indicato ti chiederà la password dell'utente amministratore di PostgreSQL, che è postgres, per impostazione predefinita. Quindi, fornire una password e procedere alla creazione del nuovo database

Dopo aver creato un database utilizzando uno dei metodi sopra menzionati, è possibile controllarlo nell'elenco dei database che utilizzano \l, ovvero il comando backslash el come segue:

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-#

Questo capitolo spiega i vari metodi di accesso al database. Supponiamo di aver già creato un database nel nostro capitolo precedente. È possibile selezionare il database utilizzando uno dei seguenti metodi:

Prompt SQL del database
Prompt dei comandi del sistema operativo

Prompt SQL del database

Supponi di aver già avviato il tuo client PostgreSQL e di essere arrivato al seguente prompt SQL:

postgres=#

È possibile controllare l'elenco dei database disponibili utilizzando \l, ovvero il comando backslash el come segue:

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-#

Ora, digita il seguente comando per connetterti / selezionare un database desiderato; qui ci collegheremo al database testdb .

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

Prompt dei comandi del sistema operativo

È possibile selezionare il database dal prompt dei comandi stesso nel momento in cui si accede al database. Di seguito è riportato un semplice esempio:

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=#

Ora sei connesso a PostgreSQL testdb e sei pronto per eseguire i tuoi comandi all'interno di testdb. Per uscire dal database, puoi usare il comando \ q.

In questo capitolo, discuteremo come eliminare il database in PostgreSQL. Ci sono due opzioni per eliminare un database:

Utilizzando DROP DATABASE, un comando SQL.
Utilizzando dropdb un eseguibile da riga di comando.

Prestare attenzione prima di utilizzare questa operazione perché l'eliminazione di un database esistente comporterebbe la perdita di informazioni complete memorizzate nel database.

Utilizzando DROP DATABASE

Questo comando rilascia un database. Rimuove le voci di catalogo per il database ed elimina la directory contenente i dati. Può essere eseguito solo dal proprietario del database. Questo comando non può essere eseguito mentre tu o qualcun altro è connesso al database di destinazione (connettiti a postgres o qualsiasi altro database per emettere questo comando).

Sintassi

La sintassi per DROP DATABASE è fornita di seguito:

DROP DATABASE [ IF EXISTS ] name

Parametri

La tabella elenca i parametri con le relative descrizioni.

S. No.	Parametro e descrizione
1	IF EXISTS Non generare un errore se il database non esiste. In questo caso viene emesso un avviso.
2	name Il nome del database da rimuovere.

Non possiamo eliminare un database che ha connessioni aperte, inclusa la nostra connessione da psql o pgAdmin III . Dobbiamo passare a un altro database o template1 se vogliamo eliminare il database a cui siamo attualmente connessi. Pertanto, potrebbe essere più conveniente utilizzare invece il programma dropdb , che è un wrapper attorno a questo comando.

Esempio

Quello che segue è un semplice esempio, che eliminerà testdb dal tuo schema PostgreSQL -

postgres=# DROP DATABASE testdb;
postgres-#

Utilizzando dropdb Command

Eseguibile della riga di comando di PostgresSQL dropdbè un wrapper della riga di comando attorno al comando SQL DROP DATABASE . Non vi è alcuna differenza effettiva tra l'eliminazione dei database tramite questa utility e altri metodi per accedere al server. dropdb distrugge un database PostgreSQL esistente. L'utente che esegue questo comando deve essere un super utente del database o il proprietario del database.

Sintassi

La sintassi per dropdb è come mostrato di seguito:

dropdb  [option...] dbname

Parametri

La tabella seguente elenca i parametri con le relative descrizioni

S. No.	Parametro e descrizione
1	dbname Il nome di un database da eliminare.
2	option argomenti della riga di comando, che dropdb accetta.

Opzioni

La tabella seguente elenca gli argomenti della riga di comando che dropdb accetta:

S. No.	Opzione e descrizione
1	-e Mostra i comandi inviati al server.
2	-i Emette una richiesta di verifica prima di eseguire qualsiasi operazione distruttiva.
3	-V Stampa la versione dropdb ed esci.
4	--if-exists Non generare un errore se il database non esiste. In questo caso viene emesso un avviso.
5	--help Mostra la guida sugli argomenti della riga di comando dropdb ed esce.
6	-h host Specifica il nome host della macchina su cui è in esecuzione il server.
7	-p port Specifica la porta TCP o l'estensione del file socket del dominio UNIX locale su cui il server è in ascolto per le connessioni.
8	-U username Nome utente con cui connettersi.
9	-w Non emettere mai una richiesta di password.
10	-W Forza dropdb a richiedere una password prima di connettersi a un database.
11	--maintenance-db=dbname Specifica il nome del database a cui connettersi per eliminare il database di destinazione.

Esempio

L'esempio seguente mostra l'eliminazione di un database dal prompt dei comandi del sistema operativo:

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

Il comando precedente elimina il database testdb. Qui ho usato il filepostgres (trovato sotto pg_roles di template1) nome utente per rilasciare il database.

L'istruzione PostgreSQL CREATE TABLE viene utilizzata per creare una nuova tabella in uno qualsiasi dei database forniti.

Sintassi

La sintassi di base dell'istruzione CREATE TABLE è la seguente:

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

CREATE TABLE è una parola chiave che dice al sistema di database di creare una nuova tabella. Il nome o l'identificatore univoco per la tabella segue l'istruzione CREATE TABLE. Inizialmente, la tabella vuota nel database corrente è di proprietà dell'utente che emette il comando.

Quindi, tra parentesi, viene visualizzato l'elenco, che definisce ciascuna colonna nella tabella e di che tipo di dati si tratta. La sintassi diventerà chiara con un esempio fornito di seguito.

Esempi

Il seguente è un esempio, che crea una tabella COMPANY con ID come chiave primaria e NOT NULL sono i vincoli che mostrano che questi campi non possono essere NULL durante la creazione di record in questa tabella -

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

Creiamo un'altra tabella, che useremo nei nostri esercizi nei capitoli successivi -

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

Puoi verificare se la tua tabella è stata creata correttamente utilizzando \d comando, che verrà utilizzato per elencare tutte le tabelle in un database allegato.

testdb-# \d

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

Uso \d tablename per descrivere ciascuna tabella come mostrato di seguito -

testdb-# \d company

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

L'istruzione PostgreSQL DROP TABLE viene utilizzata per rimuovere una definizione di tabella e tutti i dati, gli indici, le regole, i trigger e i vincoli associati per quella tabella.

Devi stare attento quando usi questo comando perché una volta che una tabella viene eliminata, anche tutte le informazioni disponibili nella tabella andranno perse per sempre.

Sintassi

La sintassi di base dell'istruzione DROP TABLE è la seguente:

DROP TABLE table_name;

Esempio

Avevamo creato le tabelle DEPARTMENT e COMPANY nel capitolo precedente. Innanzitutto, verifica queste tabelle (usa\d per elencare le tabelle) -

testdb-# \d

Ciò produrrebbe il seguente risultato:

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

Ciò significa che sono presenti le tabelle REPARTO e AZIENDA. Quindi lasciateli cadere come segue:

testdb=# drop table department, company;

Ciò produrrebbe il seguente risultato:

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

Il messaggio restituito DROP TABLE indica che il comando drop è stato eseguito correttamente.

UN schemaè una raccolta denominata di tabelle. Uno schema può anche contenere viste, indici, sequenze, tipi di dati, operatori e funzioni. Gli schemi sono analoghi alle directory a livello di sistema operativo, tranne per il fatto che gli schemi non possono essere annidati. L'istruzione PostgreSQL CREATE SCHEMA crea uno schema.

Sintassi

La sintassi di base di CREATE SCHEMA è la seguente:

CREATE SCHEMA name;

Dove nome è il nome dello schema.

Sintassi per creare una tabella nello schema

La sintassi di base per creare una tabella nello schema è la seguente:

CREATE TABLE myschema.mytable (
...
);

Esempio

Vediamo un esempio per la creazione di uno schema. Connettiti al database testdb e crea uno schema myschema come segue:

testdb=# create schema myschema;
CREATE SCHEMA

Il messaggio "CREATE SCHEMA" indica che lo schema è stato creato correttamente.

Ora, creiamo una tabella nello schema sopra come segue:

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)
);

Questo creerà una tabella vuota. Puoi verificare la tabella creata con il comando dato di seguito -

testdb=# select * from myschema.company;

Ciò produrrebbe il seguente risultato:

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

Sintassi per eliminare lo schema

Per eliminare uno schema se è vuoto (tutti gli oggetti in esso sono stati eliminati), utilizzare il comando -

DROP SCHEMA myschema;

Per eliminare uno schema che includa tutti gli oggetti contenuti, utilizzare il comando -

DROP SCHEMA myschema CASCADE;

Vantaggi dell'utilizzo di uno schema

Consente a molti utenti di utilizzare un database senza interferire tra loro.
Organizza gli oggetti del database in gruppi logici per renderli più gestibili.
Le applicazioni di terze parti possono essere inserite in schemi separati in modo che non entrino in conflitto con i nomi di altri oggetti.

Il PostgreSQL INSERT INTOl'istruzione consente di inserire nuove righe in una tabella. È possibile inserire una singola riga alla volta o più righe come risultato di una query.

Sintassi

La sintassi di base dell'istruzione INSERT INTO è la seguente:

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

Qui, colonna1, colonna2, ... colonnaN sono i nomi delle colonne nella tabella in cui si desidera inserire i dati.
I nomi delle colonne di destinazione possono essere elencati in qualsiasi ordine. I valori forniti dalla clausola o query VALUES sono associati all'elenco di colonne esplicito o implicito da sinistra a destra.

Potrebbe non essere necessario specificare il nome delle colonne nella query SQL se si stanno aggiungendo valori per tutte le colonne della tabella. Tuttavia, assicurati che l'ordine dei valori sia nello stesso ordine delle colonne nella tabella. La sintassi SQL INSERT INTO sarebbe la seguente:

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

Produzione

La tabella seguente riassume i messaggi di output e il loro significato:

S. No.	Messaggio di output e descrizione
1	INSERT oid 1 Messaggio restituito se è stata inserita solo una riga. oid è l'OID numerico della riga inserita.
2	INSERT 0 # Messaggio restituito se sono state inserite più righe. # è il numero di righe inserite.

Esempi

Creiamo la tabella AZIENDA in formato testdb come segue -

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
);

L'esempio seguente inserisce una riga nella tabella COMPANY -

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

L'esempio seguente consiste nell'inserire una riga; qui la colonna dello stipendio è omessa e quindi avrà il valore di default -

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

L'esempio seguente utilizza la clausola DEFAULT per la colonna JOIN_DATE anziché specificare un valore:

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

L'esempio seguente inserisce più righe utilizzando la sintassi VALUES a più righe:

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');

Tutte le dichiarazioni di cui sopra creerebbero i seguenti record nella tabella AZIENDA. Il prossimo capitolo ti insegnerà come visualizzare tutti questi record da una tabella.

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 SELECTviene utilizzata per recuperare i dati da una tabella di database, che restituisce i dati sotto forma di tabella dei risultati. Queste tabelle dei risultati sono chiamate set di risultati.

Sintassi

La sintassi di base dell'istruzione SELECT è la seguente:

SELECT column1, column2, columnN FROM table_name;

Qui, colonna1, colonna2 ... sono i campi di una tabella di cui vuoi recuperare i valori. Se desideri recuperare tutti i campi disponibili nel campo, puoi utilizzare la seguente sintassi:

SELECT * FROM table_name;

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

Il seguente è un esempio, che recupera i campi ID, Nome e Salario dei clienti disponibili nella tabella CLIENTI -

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

Ciò produrrebbe il seguente risultato:

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)

Se desideri recuperare tutti i campi della tabella CLIENTI, utilizza la seguente query:

testdb=# SELECT * FROM COMPANY;

Ciò produrrebbe il seguente risultato:

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)

Cos'è un operatore in PostgreSQL?

Un operatore è una parola riservata o un carattere utilizzato principalmente nella clausola WHERE di un'istruzione PostgreSQL per eseguire operazioni, come confronti e operazioni aritmetiche.

Gli operatori vengono utilizzati per specificare le condizioni in un'istruzione PostgreSQL e per servire come congiunzioni per più condizioni in un'istruzione.

Operatori aritmetici
Operatori di confronto
Operatori logici
Operatori bit per bit

Operatori aritmetici PostgreSQL

Assumi variabile a detiene 2 e variabile b tiene 3, quindi -

Esempio

Operatore	Descrizione	Esempio
+	Addizione: aggiunge valori su entrambi i lati dell'operatore	a + b darà 5
-	Sottrazione: sottrae l'operando destro dall'operando sinistro	a - b darà -1
*	Moltiplicazione: moltiplica i valori su entrambi i lati dell'operatore	a * b darà 6
/	Divisione: divide l'operando di sinistra per l'operando di destra	b / a darà 1
%	Modulo: divide l'operando sinistro per l'operando destro e restituisce il resto	b% a darà 1
^	Esponenziazione: fornisce il valore dell'esponente dell'operando di destra	a ^ b darà 8
\| /	radice quadrata	\| / 25.0 restituirà 5
\|\| /	radice cubica	\|\| / 27.0 darà 3
!	fattoriale	5! darà 120
!!	fattoriale (operatore prefisso)	!! 5 darà 120

Operatori di confronto PostgreSQL

Supponiamo che la variabile a contenga 10 e la variabile b ne contenga 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
=	Controlla se i valori di due operandi sono uguali o meno, in caso affermativo la condizione diventa vera.	(a = b) non è vero.
! =	Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(a! = b) è vero.
<>	Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(a <> b) è vero.
>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a> b) non è vero.
<	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a <b) è vero.
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a> = b) non è vero.
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a <= b) è vero.

Operatori logici PostgreSQL

Di seguito è riportato un elenco di tutti gli operatori logici disponibili in PostgresSQL.

Mostra esempi

S. No.	Operatore e descrizione
1	AND L'operatore AND consente l'esistenza di più condizioni nella clausola WHERE di un'istruzione PostgresSQL.
2	NOT L'operatore NOT inverte il significato dell'operatore logico con cui viene utilizzato. Per esempio. NON ESISTE, NON TRA, NON IN ecc.This is negate operator.
3	OR L'operatore OR viene utilizzato per combinare più condizioni nella clausola WHERE di un'istruzione PostgresSQL.

Operatori di stringa di bit PostgreSQL

L'operatore bit per bit lavora sui bit ed esegue operazioni bit per bit. La tabella della verità per & e | è il seguente -

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

Assumiamo se A = 60; e B = 13; ora in formato binario saranno i seguenti -

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Mostra esempi

Gli operatori bit per bit supportati da PostgreSQL sono elencati nella seguente tabella:

Operatore	Descrizione	Esempio
&	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(A e B) darà 12 che è 0000 1100
\|	L'operatore OR binario copia un bit se esiste in uno degli operandi.	(A \| B) darà 61 che è 0011 1101
~	Binary Ones Complement Operator è unario e ha l'effetto di "ribaltare" i bit.	(~ A) darà -61 che è 1100 0011 in forma di complemento a 2 a causa di un numero binario con segno.
<<	Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra.	Un << 2 darà 240 che è 1111 0000
>>	Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra.	Un >> 2 darà 15 che è 0000 1111
#	bit per bit XOR.	A # B darà 49 che è 0100 1001

Un'espressione è una combinazione di uno o più valori, operatori e funzioni PostgresSQL che restituiscono un valore.

Le ESPRESSIONI di PostgreSQL sono come le formule e sono scritte nel linguaggio delle query. È inoltre possibile utilizzare per interrogare il database per un set di dati specifico.

Sintassi

Considera la sintassi di base dell'istruzione SELECT come segue:

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

Esistono diversi tipi di espressioni PostgreSQL, menzionate di seguito:

PostgreSQL - Espressioni booleane

Le espressioni booleane di PostgreSQL recuperano i dati sulla base di un singolo valore corrispondente. La seguente è la sintassi:

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

Considera la tabella AZIENDA che ha i record come segue:

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)

Ecco il semplice esempio che mostra l'utilizzo delle espressioni booleane di PostgreSQL:

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

PostgreSQL - Espressione numerica

Queste espressioni vengono utilizzate per eseguire qualsiasi operazione matematica in qualsiasi query. La seguente è la sintassi:

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

Qui numerical_expression viene utilizzato per l'espressione matematica o qualsiasi formula. Di seguito è riportato un semplice esempio che mostra l'utilizzo delle espressioni numeriche SQL:

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

Esistono diverse funzioni incorporate come avg (), sum (), count () per eseguire ciò che è noto come calcoli di dati aggregati su una tabella o una colonna di tabella specifica.

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

PostgreSQL - Espressioni di data

Le espressioni di data restituiscono i valori di data e ora del sistema corrente e queste espressioni vengono utilizzate in varie manipolazioni dei dati.

testdb=#  SELECT CURRENT_TIMESTAMP;

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La clausola PostgreSQL WHERE viene utilizzata per specificare una condizione durante il recupero dei dati da una singola tabella o l'unione con più tabelle.

Se la condizione data è soddisfatta, solo allora restituisce un valore specifico dalla tabella. È possibile filtrare le righe che non si desidera includere nel set di risultati utilizzando la clausola WHERE.

La clausola WHERE non solo viene utilizzata nell'istruzione SELECT, ma è anche utilizzata nell'istruzione UPDATE, DELETE, ecc., Che esamineremo nei capitoli successivi.

Sintassi

La sintassi di base dell'istruzione SELECT con la clausola WHERE è la seguente:

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

È possibile specificare una condizione_ricerca utilizzando il confronto o gli operatori logici. come>, <, =, LIKE, NOT, ecc. I seguenti esempi renderebbero chiaro questo concetto.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

Di seguito sono riportati semplici esempi che mostrano l'utilizzo degli operatori logici PostgreSQL. La seguente istruzione SELECT elencherà tutti i record in cui AGE è maggiore o uguale a 25AND lo stipendio è maggiore o uguale a 65000,00 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La seguente istruzione SELECT elenca tutti i record in cui AGE è maggiore o uguale a 25 OR lo stipendio è maggiore o uguale a 65000,00 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

La seguente istruzione SELECT elenca tutti i record in cui AGE non è NULL, il che significa tutti i record, perché nessuno dei record ha AGE uguale a NULL -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

La seguente istruzione SELECT elenca tutti i record in cui NAME inizia con "Pa", non importa cosa viene dopo "Pa".

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La seguente istruzione SELECT elenca tutti i record in cui il valore AGE è 25 o 27 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La seguente istruzione SELECT elenca tutti i record in cui il valore AGE non è né 25 né 27 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

La seguente istruzione SELECT elenca tutti i record in cui il valore AGE è compreso tra 25 e 27 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La seguente istruzione SELECT utilizza la sottoquery SQL in cui la sottoquery trova tutti i record con il campo AGE con SALARY> 65000 e successiva viene utilizzata la clausola WHERE insieme all'operatore EXISTS per elencare tutti i record in cui AGE dalla query esterna esiste nel risultato restituito per sottoquery -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

La seguente istruzione SELECT utilizza la sottoquery SQL dove la sottoquery trova tutti i record con il campo AGE con SALARY> 65000 e successiva viene utilizzata la clausola WHERE insieme all'operatore> per elencare tutti i record in cui la query AGE dall'esterno è maggiore dell'età in il risultato restituito dalla sottoquery -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

Il PostgreSQL AND e ORgli operatori vengono utilizzati per combinare più condizioni per restringere i dati selezionati in un'istruzione PostgreSQL. Questi due operatori sono chiamati operatori congiuntivi.

Questi operatori forniscono un mezzo per fare confronti multipli con diversi operatori nella stessa istruzione PostgreSQL.

L'operatore AND

Il ANDL'operatore consente l'esistenza di più condizioni nella clausola WHERE di un'istruzione PostgreSQL. Durante l'utilizzo dell'operatore AND, la condizione completa verrà considerata vera quando tutte le condizioni sono vere. Ad esempio [condizione1] AND [condizione2] sarà vera solo quando sia condizione1 che condizione2 sono vere.

Sintassi

La sintassi di base dell'operatore AND con la clausola WHERE è la seguente:

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

È possibile combinare un numero N di condizioni utilizzando l'operatore AND. Affinché un'azione possa essere eseguita dall'istruzione PostgreSQL, sia che si tratti di una transazione o di una query, tutte le condizioni separate da AND devono essere TRUE.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

La seguente istruzione SELECT elenca tutti i record in cui AGE è maggiore o uguale a 25 AND lo stipendio è maggiore o uguale a 65000,00 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

L'operatore OR

L'operatore OR viene utilizzato anche per combinare più condizioni nella clausola WHERE di un'istruzione PostgreSQL. Durante l'utilizzo dell'operatore OR, la condizione completa verrà considerata vera quando almeno una delle condizioni è vera. Ad esempio [condizione1] OR [condizione2] sarà vera se la condizione1 o la condizione2 è vera.

Sintassi

La sintassi di base dell'operatore OR con la clausola WHERE è la seguente:

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

È possibile combinare un numero N di condizioni utilizzando l'operatore OR. Affinché un'azione venga eseguita dall'istruzione PostgreSQL, sia che si tratti di una transazione o di una query, solo UNA delle condizioni separate da OR deve essere TRUE.

Esempio

Considera la tabella AZIENDA , con i seguenti record:

# 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)

La seguente istruzione SELECT elenca tutti i record in cui AGE è maggiore o uguale a 25 OR lo stipendio è maggiore o uguale a 65000,00 -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

Il PostgreSQL UPDATELa query viene utilizzata per modificare i record esistenti in una tabella. È possibile utilizzare la clausola WHERE con la query UPDATE per aggiornare le righe selezionate. Altrimenti, tutte le righe verrebbero aggiornate.

Sintassi

La sintassi di base della query UPDATE con la clausola WHERE è la seguente:

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

È possibile combinare un numero N di condizioni utilizzando gli operatori AND o OR.

Esempio

Considera la tabella AZIENDA , con le seguenti registrazioni:

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)

Quello che segue è un esempio, che aggiorna ADDRESS per un cliente, il cui ID è 6 -

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

Ora, la tabella AZIENDA avrebbe i seguenti record:

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)

Se si desidera modificare tutti i valori delle colonne ADDRESS e SALARY nella tabella COMPANY, non è necessario utilizzare la clausola WHERE e la query UPDATE sarebbe la seguente:

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

Ora, la tabella AZIENDA avrà i seguenti record:

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)

Il PostgreSQL DELETELa query viene utilizzata per eliminare i record esistenti da una tabella. È possibile utilizzare la clausola WHERE con la query DELETE per eliminare le righe selezionate. In caso contrario, tutti i record verranno eliminati.

Sintassi

La sintassi di base della query DELETE con la clausola WHERE è la seguente:

DELETE FROM table_name
WHERE [condition];

È possibile combinare un numero N di condizioni utilizzando gli operatori AND o OR.

Esempio

Considera la tabella AZIENDA , con le seguenti registrazioni:

# 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)

Il seguente è un esempio, che cancellerebbe un cliente il cui ID è 7 -

testdb=# DELETE FROM COMPANY WHERE ID = 2;

Ora, la tabella AZIENDA avrà i seguenti record:

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)

Se si desidera CANCELLARE tutti i record dalla tabella AZIENDA, non è necessario utilizzare la clausola WHERE con le query DELETE, che sarebbe la seguente:

testdb=# DELETE FROM COMPANY;

Ora, la tabella COMPANY non ha alcun record perché tutti i record sono stati eliminati dall'istruzione DELETE.

Il PostgreSQL LIKEL'operatore viene utilizzato per confrontare i valori di testo con un modello utilizzando i caratteri jolly. Se l'espressione di ricerca può essere abbinata all'espressione del modello, l'operatore LIKE restituirà true, ovvero1.

Ci sono due caratteri jolly usati insieme all'operatore LIKE:

Il segno di percentuale (%)
Il carattere di sottolineatura (_)

Il segno di percentuale rappresenta zero, uno o più numeri o caratteri. Il trattino basso rappresenta un singolo numero o carattere. Questi simboli possono essere usati in combinazione.

Se uno di questi due segni non viene utilizzato insieme alla clausola LIKE, il LIKE si comporta come l'operatore di uguale.

Sintassi

La sintassi di base di% e _ è la seguente:

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_'

È possibile combinare un numero N di condizioni utilizzando gli operatori AND o OR. Qui XXXX potrebbe essere qualsiasi valore numerico o stringa.

Esempio

Di seguito sono riportati alcuni esempi che mostrano la parte WHERE con clausole LIKE diverse con operatori '%' e '_' -

S. No.	Dichiarazione e descrizione
1	WHERE SALARY::text LIKE '200%' Trova tutti i valori che iniziano con 200
2	WHERE SALARY::text LIKE '%200%' Trova tutti i valori che hanno 200 in qualsiasi posizione
3	WHERE SALARY::text LIKE '_00%' Trova tutti i valori che hanno 00 nella seconda e terza posizione
4	WHERE SALARY::text LIKE '2_%_%' Trova tutti i valori che iniziano con 2 e sono lunghi almeno 3 caratteri
5	WHERE SALARY::text LIKE '%2' Trova tutti i valori che terminano con 2
6	WHERE SALARY::text LIKE '_2%3' Trova tutti i valori che hanno 2 nella seconda posizione e terminano con 3
7	WHERE SALARY::text LIKE '2___3' Trova tutti i valori in un numero di cinque cifre che iniziano con 2 e finiscono con 3

Postgres LIKE è solo confronto tra stringhe. Quindi, dobbiamo eseguire il cast esplicito della colonna intera su stringa come negli esempi precedenti.

Facciamo un esempio reale, consideriamo la tabella AZIENDA , avente i record come segue:

# 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)

Il seguente è un esempio, che visualizzerebbe tutti i record dalla tabella AZIENDA in cui AGE inizia con 2 -

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

Ciò produrrebbe il seguente risultato:

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)

Il seguente è un esempio, che visualizzerebbe tutti i record dalla tabella AZIENDA dove INDIRIZZO avrà un trattino (-) all'interno del testo -

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

Ciò produrrebbe il seguente risultato:

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

Il PostgreSQL LIMIT viene utilizzata per limitare la quantità di dati restituita dall'istruzione SELECT.

Sintassi

La sintassi di base dell'istruzione SELECT con la clausola LIMIT è la seguente:

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

Quanto segue è la sintassi della clausola LIMIT quando viene utilizzata insieme alla clausola OFFSET:

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

LIMIT e OFFSET ti consentono di recuperare solo una parte delle righe generate dal resto della query.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

# 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)

Il seguente è un esempio, che limita la riga nella tabella in base al numero di righe che si desidera recuperare dalla tabella:

testdb=# SELECT * FROM COMPANY LIMIT 4;

Ciò produrrebbe il seguente risultato:

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)

Tuttavia, in determinate situazioni, potrebbe essere necessario prelevare un set di record da un determinato offset. Ecco un esempio, che raccoglie tre record a partire dalla terza posizione:

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

Ciò produrrebbe il seguente risultato:

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

Il PostgreSQL ORDER BY La clausola viene utilizzata per ordinare i dati in ordine crescente o decrescente, in base a una o più colonne.

Sintassi

La sintassi di base della clausola ORDER BY è la seguente:

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

È possibile utilizzare più di una colonna nella clausola ORDER BY. Assicurati che qualunque colonna stai utilizzando per ordinare, quella colonna dovrebbe essere disponibile nell'elenco delle colonne.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

Quello che segue è un esempio, che ordina il risultato in ordine crescente per SALARY -

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

Ciò produrrebbe il seguente risultato:

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)

Quello che segue è un esempio, che ordina il risultato in ordine crescente per NOME e STIPENDIO -

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

Ciò produrrebbe il seguente risultato:

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)

Il seguente è un esempio, che ordinerebbe il risultato in ordine decrescente per NOME -

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

Ciò produrrebbe il seguente risultato:

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)

Il PostgreSQL GROUP BYviene utilizzata in collaborazione con l'istruzione SELECT per raggruppare quelle righe in una tabella che hanno dati identici. Questo viene fatto per eliminare la ridondanza nell'output e / o negli aggregati di calcolo che si applicano a questi gruppi.

La clausola GROUP BY segue la clausola WHERE in un'istruzione SELECT e precede la clausola ORDER BY.

Sintassi

Di seguito viene fornita la sintassi di base della clausola GROUP BY. La clausola GROUP BY deve seguire le condizioni nella clausola WHERE e deve precedere la clausola ORDER BY, se utilizzata.

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

È possibile utilizzare più di una colonna nella clausola GROUP BY. Assicurati che qualunque colonna stai usando per raggruppare, quella colonna dovrebbe essere disponibile nell'elenco delle colonne.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

# 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)

Se desideri conoscere l'importo totale dello stipendio di ciascun cliente, la query GROUP BY sarà la seguente:

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

Ciò produrrebbe il seguente risultato:

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

Ora, creiamo altri tre record nella tabella COMPANY utilizzando le seguenti istruzioni INSERT:

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);

Ora, la nostra tabella ha i seguenti record con nomi duplicati:

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)

Ancora una volta, usiamo la stessa istruzione per raggruppare tutti i record usando la colonna NAME come segue:

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

Ciò produrrebbe il seguente risultato:

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

Usiamo la clausola ORDER BY insieme alla clausola GROUP BY come segue:

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

Ciò produrrebbe il seguente risultato:

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

In PostgreSQL, la query WITH fornisce un modo per scrivere istruzioni ausiliarie da utilizzare in una query più grande. Aiuta a scomporre query complesse e di grandi dimensioni in forme più semplici, che sono facilmente leggibili. Queste istruzioni, spesso denominate espressioni di tabella comuni o CTE, possono essere considerate come la definizione di tabelle temporanee che esistono solo per una query.

La query WITH essendo una query CTE, è particolarmente utile quando la sottoquery viene eseguita più volte. È ugualmente utile al posto delle tabelle temporanee. Calcola l'aggregazione una volta e ci consente di farvi riferimento per nome (può essere più volte) nelle query.

La clausola WITH deve essere definita prima di essere utilizzata nella query.

Sintassi

La sintassi di base della query WITH è la seguente:

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]

Dove name_for_summary_data è il nome dato alla clausola WITH. Name_for_summary_data può essere uguale al nome di una tabella esistente e avrà la precedenza.

È possibile utilizzare istruzioni di modifica dei dati (INSERT, UPDATE o DELETE) in WITH. Ciò consente di eseguire diverse operazioni diverse nella stessa query.

Ricorsivo CON

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

Ora, scriviamo una query utilizzando la clausola WITH per selezionare i record dalla tabella sopra, come segue:

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

Ora, scriviamo una query utilizzando la parola chiave RECURSIVE insieme alla clausola WITH, per trovare la somma degli stipendi inferiore a 20000, come segue:

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

Scriviamo una query utilizzando le istruzioni di modifica dei dati insieme alla clausola WITH, come mostrato di seguito.

Innanzitutto, crea una tabella COMPANY1 simile alla tabella COMPANY. La query nell'esempio sposta effettivamente le righe da COMPANY a COMPANY1. Il DELETE in WITH cancella le righe specificate da COMPANY, restituendone il contenuto tramite la sua clausola RETURNING; e quindi la query principale legge quell'output e lo inserisce in COMPANY1 TABLE -

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);

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

INSERT 0 3

Ora, i record nelle tabelle COMPANY e COMPANY1 sono i seguenti:

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)

La clausola HAVING ci consente di selezionare righe particolari in cui il risultato della funzione soddisfa una certa condizione.

La clausola WHERE pone condizioni sulle colonne selezionate, mentre la clausola HAVING pone condizioni sui gruppi creati dalla clausola GROUP BY.

Sintassi

Di seguito è riportata la posizione della clausola HAVING in una query SELECT:

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

La clausola HAVING deve seguire la clausola GROUP BY in una query e deve anche precedere la clausola ORDER BY, se utilizzata. Quanto segue è la sintassi dell'istruzione SELECT, inclusa la clausola HAVING:

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

Esempio

Considera la tabella AZIENDA che ha i record come segue:

# 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)

Il seguente è un esempio, che visualizzerebbe un record per il quale il conteggio dei nomi è inferiore a 2 -

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

Ciò produrrebbe il seguente risultato:

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

Ora, creiamo altri tre record nella tabella COMPANY utilizzando le seguenti istruzioni INSERT:

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);

Ora, la nostra tabella ha i seguenti record con nomi duplicati:

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)

Il seguente è l'esempio, che visualizzerebbe il record per il quale il conteggio dei nomi è maggiore di 1 -

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

Ciò produrrebbe il seguente risultato:

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

Il PostgreSQL DISTINCT la parola chiave viene utilizzata insieme all'istruzione SELECT per eliminare tutti i record duplicati e recuperare solo i record univoci.

Potrebbe verificarsi una situazione in cui si dispone di più record duplicati in una tabella. Durante il recupero di tali record, ha più senso recuperare solo i record univoci invece di recuperare i record duplicati.

Sintassi

La sintassi di base della parola chiave DISTINCT per eliminare i record duplicati è la seguente:

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

Esempio

Considera la tabella AZIENDA che ha i record come segue:

# 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)

Aggiungiamo altri due record a questa tabella come segue:

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 );

Ora, i record nella tabella AZIENDA sarebbero:

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)

Innanzitutto, vediamo come la seguente query SELECT restituisce record di stipendio duplicati:

testdb=# SELECT name FROM COMPANY;

Ciò produrrebbe il seguente risultato:

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

Ora, usiamo DISTINCT parola chiave con la query SELECT sopra e vedere il risultato -

testdb=# SELECT DISTINCT name FROM COMPANY;

Ciò produrrebbe il seguente risultato in cui non abbiamo alcuna voce duplicata:

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

I vincoli sono le regole applicate alle colonne di dati nella tabella. Questi vengono utilizzati per impedire che dati non validi vengano inseriti nel database. Ciò garantisce l'accuratezza e l'affidabilità dei dati nel database.

I vincoli possono essere a livello di colonna o di tabella. I vincoli a livello di colonna vengono applicati solo a una colonna, mentre i vincoli a livello di tabella vengono applicati all'intera tabella. La definizione di un tipo di dati per una colonna è di per sé un vincolo. Ad esempio, una colonna di tipo DATE vincola la colonna a date valide.

I seguenti sono vincoli comunemente usati disponibili in PostgreSQL.

NOT NULL Constraint - Assicura che una colonna non possa avere un valore NULL.
UNIQUE Constraint - Assicura che tutti i valori in una colonna siano diversi.
PRIMARY Key - Identifica in modo univoco ogni riga / record in una tabella di database.
FOREIGN Key - Vincola i dati in base alle colonne di altre tabelle.
CHECK Constraint - Il vincolo CHECK garantisce che tutti i valori in una colonna soddisfino determinate condizioni.
EXCLUSION Constraint - Il vincolo EXCLUDE garantisce che se due righe qualsiasi vengono confrontate sulle colonne o espressioni specificate utilizzando gli operatori specificati, non tutti questi confronti restituiranno TRUE.

NON NULLO Vincolo

Per impostazione predefinita, una colonna può contenere valori NULL. Se non si desidera che una colonna abbia un valore NULL, è necessario definire tale vincolo su questa colonna specificando che NULL non è ora consentito per quella colonna. Un vincolo NOT NULL viene sempre scritto come vincolo di colonna.

Un NULL non è la stessa cosa di nessun dato; piuttosto, rappresenta dati sconosciuti.

Esempio

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata COMPANY1 e aggiunge cinque colonne, tre delle quali, ID e NAME e AGE, specificano di non accettare valori NULL -

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

Vincolo UNICO

Il vincolo UNIQUE impedisce a due record di avere valori identici in una determinata colonna. Nella tabella AZIENDA, ad esempio, potresti voler impedire a due o più persone di avere la stessa età.

Esempio

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata COMPANY3 e aggiunge cinque colonne. Qui, la colonna AGE è impostata su UNIQUE, quindi non puoi avere due record con la stessa età -

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 Vincolo

Il vincolo PRIMARY KEY identifica in modo univoco ogni record in una tabella di database. Possono esserci più colonne UNICHE, ma solo una chiave primaria in una tabella. Le chiavi primarie sono importanti quando si progettano le tabelle del database. Le chiavi primarie sono ID univoci.

Li usiamo per fare riferimento alle righe della tabella. Le chiavi primarie diventano chiavi esterne in altre tabelle, quando si creano relazioni tra tabelle. A causa di una "supervisione di codifica di lunga data", le chiavi primarie possono essere NULL in SQLite. Questo non è il caso di altri database

Una chiave primaria è un campo in una tabella, che identifica in modo univoco ogni riga / record in una tabella di database. Le chiavi primarie devono contenere valori univoci. Una colonna di chiave primaria non può avere valori NULL.

Una tabella può avere una sola chiave primaria, che può essere costituita da uno o più campi. Quando più campi vengono utilizzati come chiave primaria, vengono chiamati acomposite key.

Se una tabella ha una chiave primaria definita su uno o più campi, non puoi avere due record con lo stesso valore di quel campo.

Esempio

Hai già visto vari esempi sopra in cui abbiamo creato la tabella COMAPNY4 con ID come chiave primaria -

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

Vincolo chiave estera

Un vincolo di chiave esterna specifica che i valori in una colonna (o un gruppo di colonne) devono corrispondere ai valori che appaiono in una riga di un'altra tabella. Diciamo che questo mantiene l'integrità referenziale tra due tabelle correlate. Sono chiamate chiavi esterne perché i vincoli sono esterni; cioè fuori dal tavolo. Le chiavi esterne sono talvolta chiamate chiave di riferimento.

Esempio

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata COMPANY5 e aggiunge cinque colonne.

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

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata DEPARTMENT1, che aggiunge tre colonne. La colonna EMP_ID è la chiave esterna e fa riferimento al campo ID della tabella COMPANY6.

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

CONTROLLA vincolo

Il vincolo CHECK consente a una condizione di verificare il valore immesso in un record. Se la condizione restituisce false, il record viola il vincolo e non viene inserito nella tabella.

Esempio

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata COMPANY5 e aggiunge cinque colonne. Qui, aggiungiamo una colonna CONTROLLO con STIPENDIO, in modo che tu non possa avere alcun SALARIO come Zero.

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)
);

Vincolo di ESCLUSIONE

I vincoli di esclusione assicurano che se due righe qualsiasi vengono confrontate sulle colonne o espressioni specificate utilizzando gli operatori specificati, almeno uno di questi confronti di operatori restituirà false o null.

Esempio

Ad esempio, la seguente istruzione PostgreSQL crea una nuova tabella denominata COMPANY7 e aggiunge cinque colonne. Qui, aggiungiamo un vincolo EXCLUDE -

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 <>)
);

In questo caso, USING gist è il tipo di indice da creare e utilizzare per l'applicazione.

È necessario eseguire il comando CREATE EXTENSION btree_gist , una volta per database. Questo installerà l'estensione btree_gist, che definisce i vincoli di esclusione sui tipi di dati scalari semplici.

Dato che abbiamo imposto l'età deve essere la stessa, vediamo questo inserendo i record nella tabella -

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 );

Per le prime due istruzioni INSERT, i record vengono aggiunti alla tabella COMPANY7. Per la terza istruzione INSERT, viene visualizzato il seguente errore:

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).

Eliminazione dei vincoli

Per rimuovere un vincolo è necessario conoscerne il nome. Se il nome è noto, è facile lasciarlo cadere. Altrimenti, devi scoprire il nome generato dal sistema. Il comando psql \ d nome tabella può essere utile qui. La sintassi generale è:

ALTER TABLE table_name DROP CONSTRAINT some_name;

Il PostgreSQL Joinsviene utilizzata per combinare i record di due o più tabelle in un database. Un JOIN è un mezzo per combinare i campi di due tabelle utilizzando valori comuni a ciascuna.

I tipi di join in PostgreSQL sono:

La CROCE JOIN
L'INNER JOIN
L'ESTERNO SINISTRO JOIN
L'UNIONE ESTERNA DESTRA
Il FULL OUTER JOIN

Prima di procedere, consideriamo due tabelle, AZIENDA e REPARTO. Abbiamo già visto le istruzioni INSERT per popolare la tabella COMPANY. Quindi supponiamo che l'elenco dei record disponibili nella tabella AZIENDA -

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

Un'altra tabella è DEPARTMENT, ha la seguente definizione:

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

Ecco l'elenco delle istruzioni INSERT per popolare la tabella DEPARTMENT -

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 );

Infine, abbiamo il seguente elenco di record disponibili nella tabella DEPARTMENT:

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

La CROCE JOIN

UN CROSS JOIN abbina ogni riga della prima tabella con ogni riga della seconda tabella. Se le tabelle di input hanno rispettivamente colonne xey, la tabella risultante avrà colonne x + y. Poiché i CROSS JOIN hanno il potenziale per generare tabelle estremamente grandi, è necessario prestare attenzione a utilizzarli solo quando appropriato.

Quanto segue è la sintassi di CROSS JOIN -

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

Sulla base delle tabelle sopra, possiamo scrivere un CROSS JOIN come segue:

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

La query sopra indicata produrrà il seguente risultato:

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

L'INNER JOIN

UN INNER JOIN crea una nuova tabella dei risultati combinando i valori di colonna di due tabelle (table1 e table2) in base al predicato di join. La query confronta ogni riga di table1 con ogni riga di table2 per trovare tutte le coppie di righe che soddisfano il predicato di join. Quando il predicato di join è soddisfatto, i valori di colonna per ciascuna coppia di righe corrispondenti di table1 e table2 vengono combinati in una riga di risultati.

Un INNER JOIN è il tipo di join più comune ed è il tipo di join predefinito. Puoi usare la parola chiave INNER facoltativamente.

Quanto segue è la sintassi di INNER JOIN -

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

Sulla base delle tabelle precedenti, possiamo scrivere un INNER JOIN come segue:

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

La query sopra indicata produrrà il seguente risultato:

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

L'ESTERNO SINISTRO JOIN

OUTER JOIN è un'estensione di INNER JOIN. Lo standard SQL definisce tre tipi di OUTER JOIN: LEFT, RIGHT e FULL e PostgreSQL supporta tutti questi.

In caso di LEFT OUTER JOIN, viene eseguito prima un inner join. Quindi, per ogni riga nella tabella T1 che non soddisfa la condizione di join con alcuna riga nella tabella T2, viene aggiunta una riga unita con valori nulli nelle colonne di T2. Pertanto, la tabella unita ha sempre almeno una riga per ogni riga in T1.

Quanto segue è la sintassi di LEFT OUTER JOIN -

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

Sulla base delle tabelle precedenti, possiamo scrivere un inner join come segue:

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

La query sopra indicata produrrà il seguente risultato:

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

L'UNIONE ESTERNA DESTRA

Innanzitutto, viene eseguita un'unione interna. Quindi, per ogni riga nella tabella T2 che non soddisfa la condizione di join con nessuna riga nella tabella T1, viene aggiunta una riga unita con valori nulli nelle colonne di T1. Questo è il contrario di un join sinistro; la tabella dei risultati avrà sempre una riga per ogni riga in T2.

Quanto segue è la sintassi di RIGHT OUTER JOIN -

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

Sulla base delle tabelle precedenti, possiamo scrivere un inner join come segue:

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

La query sopra indicata produrrà il seguente risultato:

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

Il FULL OUTER JOIN

Innanzitutto, viene eseguita un'unione interna. Quindi, per ogni riga nella tabella T1 che non soddisfa la condizione di join con alcuna riga nella tabella T2, viene aggiunta una riga unita con valori nulli nelle colonne di T2. Inoltre, per ogni riga di T2 che non soddisfa la condizione di join con nessuna riga in T1, viene aggiunta una riga unita con valori nulli nelle colonne di T1.

Quanto segue è la sintassi di FULL OUTER JOIN -

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

Sulla base delle tabelle precedenti, possiamo scrivere un inner join come segue:

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

La query sopra indicata produrrà il seguente risultato:

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

Il PostgreSQL UNION La clausola / operatore viene utilizzata per combinare i risultati di due o più istruzioni SELECT senza restituire righe duplicate.

Per utilizzare UNION, ogni SELECT deve avere lo stesso numero di colonne selezionate, lo stesso numero di espressioni di colonna, lo stesso tipo di dati e devono avere lo stesso ordine ma non devono essere della stessa lunghezza.

Sintassi

La sintassi di base di UNION è il seguente -

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

UNION

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

In questo caso, una determinata condizione potrebbe essere una determinata espressione in base alle proprie esigenze.

Esempio

Considera le seguenti due tabelle, (a) la tabella AZIENDA è la seguente:

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) Un'altra tabella è DEPARTMENT come segue:

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)

Ora uniamo queste due tabelle usando l'istruzione SELECT insieme alla clausola UNION come segue:

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;

Ciò produrrebbe il seguente risultato:

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)

La clausola UNION ALL

L'operatore UNION ALL viene utilizzato per combinare i risultati di due istruzioni SELECT comprese le righe duplicate. Le stesse regole che si applicano a UNION si applicano anche all'operatore UNION ALL.

Sintassi

La sintassi di base di UNION ALL è il seguente -

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

UNION ALL

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

In questo caso, una determinata condizione potrebbe essere una determinata espressione in base alle proprie esigenze.

Esempio

Ora, uniamo le due tabelle sopra menzionate nella nostra istruzione SELECT come segue:

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;

Ciò produrrebbe il seguente risultato:

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)

Il PostgreSQL NULLè il termine usato per rappresentare un valore mancante. Un valore NULL in una tabella è un valore in un campo che sembra essere vuoto.

Un campo con un valore NULL è un campo senza valore. È molto importante comprendere che un valore NULL è diverso da un valore zero o da un campo che contiene spazi.

Sintassi

La sintassi di base dell'utilizzo di NULL durante la creazione di una tabella è il seguente:

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

Qui, NOT NULLsignifica che la colonna dovrebbe sempre accettare un valore esplicito del tipo di dati specificato. Ci sono due colonne in cui non abbiamo usato NOT NULL. Quindi, questo significa che queste colonne potrebbero essere NULL.

Un campo con un valore NULL è uno che è stato lasciato vuoto durante la creazione del record.

Esempio

Il valore NULL può causare problemi durante la selezione dei dati, perché quando si confronta un valore sconosciuto con qualsiasi altro valore, il risultato è sempre sconosciuto e non è incluso nei risultati finali. Considera la seguente tabella, AZIENDA con i seguenti record:

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

Usiamo l'istruzione UPDATE per impostare alcuni valori nullable come NULL come segue:

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

Ora, la tabella AZIENDA dovrebbe avere i seguenti record:

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)

Successivamente, vediamo l'utilizzo di IS NOT NULL operatore per elencare tutti i record in cui SALARY non è NULL -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

Quello che segue è l'uso di IS NULL operatore che elencherà tutti i record in cui SALARY è NULL -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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

È possibile rinominare temporaneamente una tabella o una colonna assegnando un altro nome, noto come ALIAS. L'uso di alias di tabella significa rinominare una tabella in una particolare istruzione PostgreSQL. La ridenominazione è una modifica temporanea e il nome effettivo della tabella non cambia nel database.

Gli alias di colonna vengono utilizzati per rinominare le colonne di una tabella ai fini di una particolare query PostgreSQL.

Sintassi

La sintassi di base di table l'alias è il seguente -

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

La sintassi di base di column l'alias è il seguente -

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Esempio

Considera le seguenti due tabelle, (a) la tabella AZIENDA è la seguente:

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) Un'altra tabella è DEPARTMENT come segue:

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)

Di seguito è riportato l'utilizzo di TABLE ALIAS dove usiamo C e D come alias rispettivamente per le tabelle AZIENDA e REPARTO -

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

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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)

Vediamo un esempio per l'utilizzo di COLUMN ALIAS dove COMPANY_ID è un alias della colonna ID e COMPANY_NAME è un alias della colonna del nome -

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;

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

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 sono funzioni di callback del database, che vengono eseguite / invocate automaticamente quando si verifica un evento di database specificato.

Di seguito sono riportati punti importanti sui trigger di PostgreSQL:

È possibile specificare il trigger di PostgreSQL da attivare
- Prima che l'operazione venga tentata su una riga (prima che i vincoli vengano controllati e che venga tentato INSERT, UPDATE o DELETE)
- Dopo che l'operazione è stata completata (dopo che i vincoli sono stati controllati e INSERT, UPDATE o DELETE è stato completato)
- Al posto dell'operazione (nel caso di inserimenti, aggiornamenti o cancellazioni su una vista)
Un trigger contrassegnato FOR EACH ROW viene chiamato una volta per ogni riga modificata dall'operazione. Al contrario, un trigger contrassegnato con FOR EACH STATEMENT viene eseguito solo una volta per una determinata operazione, indipendentemente dal numero di righe modificate.
Sia la clausola WHEN che le azioni trigger, possono accedere agli elementi della riga che viene inserita, eliminata o aggiornata utilizzando i riferimenti del modulo NEW.column-name e OLD.column-name, dove nome-colonna è il nome di una colonna della tabella a cui è associato il trigger.
Se viene fornita una clausola WHEN, le istruzioni PostgreSQL specificate vengono eseguite solo per le righe per le quali la clausola WHEN è vera. Se non viene fornita alcuna clausola WHEN, le istruzioni PostgreSQL vengono eseguite per tutte le righe.
Se per lo stesso evento vengono definiti più trigger dello stesso tipo, verranno attivati in ordine alfabetico per nome.
La parola chiave BEFORE, AFTER o INSTEAD OF determina quando verranno eseguite le azioni trigger relative all'inserimento, alla modifica o alla rimozione della riga associata.
I trigger vengono eliminati automaticamente quando viene eliminata la tabella a cui sono associati.
La tabella da modificare deve esistere nello stesso database della tabella o della vista a cui è collegato il trigger e si deve utilizzare solo tablename, no database.tablename.
Un'opzione CONSTRAINT, se specificata, crea un trigger di vincolo . È lo stesso di un trigger normale, tranne per il fatto che il tempo di attivazione del grilletto può essere regolato utilizzando SET CONSTRAINTS. Ci si aspetta che i trigger di vincolo generino un'eccezione quando i vincoli che implementano vengono violati.

Sintassi

La sintassi di base della creazione di un file trigger è il seguente -

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

Qui, event_namepotrebbe essere un'operazione di database INSERT, DELETE, UPDATE e TRUNCATE sulla tabella menzionatatable_name. Facoltativamente, è possibile specificare FOR EACH ROW dopo il nome della tabella.

Quanto segue è la sintassi per creare un trigger su un'operazione UPDATE su una o più colonne specificate di una tabella come segue:

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

Esempio

Consideriamo un caso in cui vogliamo mantenere la prova di audit per ogni record inserito nella tabella AZIENDA, che creeremo di nuovo come segue (Elimina tabella AZIENDA se già ce l'hai).

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

Per mantenere la prova di audit, creeremo una nuova tabella chiamata AUDIT in cui verranno inseriti i messaggi di registro ogni volta che c'è una voce nella tabella AZIENDA per un nuovo record -

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

Qui, ID è l'ID del record AUDIT e EMP_ID è l'ID, che verrà dalla tabella COMPANY e DATE manterrà il timestamp quando il record verrà creato nella tabella COMPANY. Quindi ora, creiamo un trigger sulla tabella AZIENDA come segue:

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

Dove auditlogfunc () è un PostgreSQL procedure e ha la seguente definizione:

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;

Ora inizieremo il lavoro vero e proprio. Cominciamo con l'inserimento del record nella tabella AZIENDA che dovrebbe comportare la creazione di un record del registro di controllo nella tabella AUDIT. Quindi creiamo un record nella tabella AZIENDA come segue:

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

Questo creerà un record nella tabella AZIENDA, che è il seguente:

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

Allo stesso tempo, verrà creato un record nella tabella AUDIT. Questo record è il risultato di un trigger, che abbiamo creato durante l'operazione INSERT nella tabella COMPANY. Allo stesso modo, puoi creare i tuoi trigger nelle operazioni UPDATE e DELETE in base alle tue esigenze.

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

Elenco TRIGGERS

È possibile elencare tutti i trigger nel database corrente da pg_trigger tabella come segue -

testdb=# SELECT * FROM pg_trigger;

L'istruzione PostgreSQL sopra indicata elencherà tutti i trigger.

Se vuoi elencare i trigger su una particolare tabella, usa la clausola AND con il nome della tabella come segue:

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

L'istruzione PostgreSQL sopra indicata elencherà anche solo una voce come segue:

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

TRIGGERS in caduta

Di seguito è riportato il comando DROP, che può essere utilizzato per rilasciare un trigger esistente:

testdb=# DROP TRIGGER trigger_name;

Gli indici sono tabelle di ricerca speciali che il motore di ricerca del database può utilizzare per accelerare il recupero dei dati. In poche parole, un indice è un puntatore ai dati in una tabella. Un indice in un database è molto simile a un indice sul retro di un libro.

Ad esempio, se vuoi fare riferimento a tutte le pagine di un libro che tratta un certo argomento, devi prima fare riferimento all'indice, che elenca tutti gli argomenti in ordine alfabetico e poi fare riferimento a uno o più numeri di pagina specifici.

Un indice aiuta ad accelerare le query SELECT e le clausole WHERE; tuttavia, rallenta l'immissione dei dati, con le istruzioni UPDATE e INSERT. Gli indici possono essere creati o eliminati senza alcun effetto sui dati.

La creazione di un indice implica l'istruzione CREATE INDEX, che consente di denominare l'indice, di specificare la tabella e la colonna o le colonne da indicizzare e di indicare se l'indice è in ordine crescente o decrescente.

Gli indici possono anche essere univoci, in modo simile al vincolo UNIQUE, in quanto l'indice impedisce voci duplicate nella colonna o combinazione di colonne su cui è presente un indice.

Il comando CREATE INDEX

La sintassi di base di CREATE INDEX è il seguente -

CREATE INDEX index_name ON table_name;

Tipi di indice

PostgreSQL fornisce diversi tipi di indice: B-tree, Hash, GiST, SP-GiST e GIN. Ogni tipo di indice utilizza un algoritmo diverso che è più adatto a diversi tipi di query. Per impostazione predefinita, il comando CREATE INDEX crea indici B-tree, che si adattano alle situazioni più comuni.

Indici a colonna singola

Un indice a colonna singola è quello creato in base a una sola colonna della tabella. La sintassi di base è la seguente:

CREATE INDEX index_name
ON table_name (column_name);

Indici a più colonne

Un indice a più colonne è definito su più di una colonna di una tabella. La sintassi di base è la seguente:

CREATE INDEX index_name
ON table_name (column1_name, column2_name);

Indipendentemente dal fatto che si crei un indice a colonna singola o a più colonne, prendere in considerazione le colonne che è possibile utilizzare molto frequentemente nella clausola WHERE di una query come condizioni di filtro.

Se viene utilizzata una sola colonna, la scelta dovrebbe essere un indice a colonna singola. Dovrebbero esserci due o più colonne utilizzate frequentemente nella clausola WHERE come filtri, l'indice a più colonne sarebbe la scelta migliore.

Indici unici

Gli indici univoci vengono utilizzati non solo per le prestazioni, ma anche per l'integrità dei dati. Un indice univoco non consente l'inserimento di valori duplicati nella tabella. La sintassi di base è la seguente:

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Indici parziali

Un indice parziale è un indice costruito su un sottoinsieme di una tabella; il sottoinsieme è definito da un'espressione condizionale (chiamata predicato dell'indice parziale). L'indice contiene voci solo per quelle righe della tabella che soddisfano il predicato. La sintassi di base è la seguente:

CREATE INDEX index_name
on table_name (conditional_expression);

Indici impliciti

Gli indici impliciti sono indici che vengono creati automaticamente dal server di database quando viene creato un oggetto. Gli indici vengono creati automaticamente per vincoli di chiave primaria e vincoli univoci.

Esempio

Quello che segue è un esempio in cui creeremo un indice sulla tabella AZIENDA per la colonna salario -

# CREATE INDEX salary_index ON COMPANY (salary);

Ora, elenchiamo tutti gli indici disponibili nella tabella AZIENDA utilizzando \d company comando.

# \d company

Questo produrrà il seguente risultato, dove company_pkey è un indice implicito, che è stato creato quando è stata creata la tabella.

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)

È possibile elencare l'intero database degli indici utilizzando l'estensione \di comando -

Il comando DROP INDEX

Un indice può essere eliminato utilizzando PostgreSQL DROPcomando. È necessario prestare attenzione quando si elimina un indice perché le prestazioni potrebbero essere rallentate o migliorate.

La sintassi di base è la seguente:

DROP INDEX index_name;

È possibile utilizzare la seguente dichiarazione per eliminare l'indice creato in precedenza:

# DROP INDEX salary_index;

Quando è opportuno evitare gli indici?

Sebbene gli indici abbiano lo scopo di migliorare le prestazioni di un database, a volte dovrebbero essere evitati. Le seguenti linee guida indicano quando è necessario riconsiderare l'uso di un indice:

Gli indici non devono essere utilizzati su piccoli tavoli.
Tabelle con aggiornamenti batch frequenti e di grandi dimensioni o operazioni di inserimento.
Gli indici non devono essere utilizzati su colonne che contengono un numero elevato di valori NULL.
Le colonne che vengono manipolate di frequente non devono essere indicizzate.

Il PostgreSQL ALTER TABLE viene utilizzato per aggiungere, eliminare o modificare colonne in una tabella esistente.

Si utilizzerà anche il comando ALTER TABLE per aggiungere e eliminare vari vincoli su una tabella esistente.

Sintassi

La sintassi di base di ALTER TABLE per aggiungere una nuova colonna in una tabella esistente è il seguente:

ALTER TABLE table_name ADD column_name datatype;

La sintassi di base di ALTER TABLE su DROP COLUMN in una tabella esistente è la seguente:

ALTER TABLE table_name DROP COLUMN column_name;

La sintassi di base di ALTER TABLE per modificare il file DATA TYPE di una colonna in una tabella è la seguente:

ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;

La sintassi di base di ALTER TABLE per aggiungere un file NOT NULL vincolo a una colonna in una tabella è il seguente:

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

La sintassi di base di ALTER TABLE su ADD UNIQUE CONSTRAINT a una tabella è il seguente:

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

La sintassi di base di ALTER TABLE su ADD CHECK CONSTRAINT a una tabella è il seguente:

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

La sintassi di base di ALTER TABLE su ADD PRIMARY KEY vincolo a una tabella è il seguente:

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

La sintassi di base di ALTER TABLE su DROP CONSTRAINT da una tabella è il seguente:

ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;

Se stai usando MySQL, il codice è il seguente:

ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;

La sintassi di base di ALTER TABLE su DROP PRIMARY KEY vincolo da una tabella è il seguente:

ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;

Se stai usando MySQL, il codice è il seguente:

ALTER TABLE table_name
DROP PRIMARY KEY;

Esempio

Considera che la nostra tabella AZIENDA ha i seguenti record:

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

Il seguente è l'esempio per AGGIUNGERE una nuova colonna in una tabella esistente:

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

Ora, la tabella COMPANY è cambiata e il seguente sarebbe l'output dell'istruzione SELECT -

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)

Quello che segue è l'esempio per eliminare la colonna sesso dalla tabella esistente -

testdb=# ALTER TABLE COMPANY DROP GENDER;

Ora, la tabella COMPANY è cambiata e il seguente sarebbe l'output dell'istruzione SELECT -

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

Il PostgreSQL TRUNCATE TABLEviene utilizzato per eliminare i dati completi da una tabella esistente. È inoltre possibile utilizzare il comando DROP TABLE per eliminare la tabella completa, ma rimuoverà la struttura della tabella completa dal database e sarà necessario ricreare questa tabella ancora una volta se si desidera memorizzare alcuni dati.

Ha lo stesso effetto di DELETE su ogni tabella, ma poiché non esegue effettivamente la scansione delle tabelle, è più veloce. Inoltre, recupera immediatamente lo spazio su disco, invece di richiedere una successiva operazione di VACUUM. Ciò è particolarmente utile su tabelle di grandi dimensioni.

Sintassi

La sintassi di base di TRUNCATE TABLE è il seguente -

TRUNCATE TABLE  table_name;

Esempio

Considera che la tabella AZIENDA ha i seguenti record:

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)

Il seguente è l'esempio da troncare:

testdb=# TRUNCATE TABLE COMPANY;

Ora, la tabella COMPANY viene troncata e il seguente sarebbe l'output dell'istruzione SELECT:

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

Le viste sono pseudo-tabelle. Cioè, non sono tavoli reali; tuttavia appaiono come tabelle normali per SELECT. Una vista può rappresentare un sottoinsieme di una tabella reale, selezionando determinate colonne o determinate righe da una tabella ordinaria. Una vista può anche rappresentare tabelle unite. Poiché alle viste vengono assegnate autorizzazioni separate, è possibile utilizzarle per limitare l'accesso alla tabella in modo che gli utenti vedano solo righe o colonne specifiche di una tabella.

Una vista può contenere tutte le righe di una tabella o le righe selezionate da una o più tabelle. Una vista può essere creata da una o più tabelle, che dipende dalla query PostgreSQL scritta per creare una vista.

Le viste, che sono una specie di tabelle virtuali, consentono agli utenti di eseguire le seguenti operazioni:

Struttura i dati in modo che gli utenti o le classi di utenti trovino naturali o intuitivi.
Limita l'accesso ai dati in modo tale che un utente possa vedere solo dati limitati invece della tabella completa.
Riepiloga i dati di varie tabelle, che possono essere utilizzati per generare rapporti.

Poiché le viste non sono tabelle normali, potresti non essere in grado di eseguire un'istruzione DELETE, INSERT o UPDATE su una vista. Tuttavia, è possibile creare una REGOLA per correggere questo problema di utilizzare CANCELLA, INSERISCI o AGGIORNA su una vista.

Creazione di viste

Le viste di PostgreSQL vengono create utilizzando il CREATE VIEWdichiarazione. Le viste PostgreSQL possono essere create da una singola tabella, più tabelle o un'altra vista.

La sintassi base di CREATE VIEW è la seguente:

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Puoi includere più tabelle nella tua istruzione SELECT in un modo molto simile a come le usi nella normale query PostgreSQL SELECT. Se è presente la parola chiave TEMP o TEMPORARY facoltativa, la vista verrà creata nello spazio temporaneo. Le visualizzazioni temporanee vengono automaticamente eliminate alla fine della sessione corrente.

Esempio

Considera, la tabella AZIENDA contiene i seguenti record:

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

Di seguito è riportato un esempio per creare una vista dalla tabella AZIENDA. Questa vista verrebbe utilizzata per avere solo poche colonne dalla tabella AZIENDA -

testdb=# CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

Ora puoi interrogare COMPANY_VIEW in modo simile a come interroghi una tabella effettiva. Di seguito è riportato l'esempio:

testdb=# SELECT * FROM COMPANY_VIEW;

Ciò produrrebbe il seguente risultato:

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)

Eliminazione delle visualizzazioni

Per eliminare una visualizzazione, utilizzare semplicemente l'istruzione DROP VIEW con l'estensione view_name. La sintassi di base di DROP VIEW è la seguente:

testdb=# DROP VIEW view_name;

Il seguente comando cancellerà la vista COMPANY_VIEW, che abbiamo creato nell'ultima sezione -

testdb=# DROP VIEW COMPANY_VIEW;

Una transazione è un'unità di lavoro eseguita su un database. Le transazioni sono unità o sequenze di lavoro eseguite in un ordine logico, sia manualmente da un utente che automaticamente da una sorta di programma di database.

Una transazione è la propagazione di una o più modifiche al database. Ad esempio, se stai creando un record, aggiornando un record o eliminando un record dalla tabella, stai eseguendo la transazione sulla tabella. È importante controllare le transazioni per garantire l'integrità dei dati e per gestire gli errori del database.

In pratica, raggrupperai molte query PostgreSQL in un gruppo e le eseguirai tutte insieme come parte di una transazione.

Proprietà delle transazioni

Le transazioni hanno le seguenti quattro proprietà standard, solitamente indicate con l'acronimo ACID -

Atomicity- Assicura che tutte le operazioni all'interno dell'unità di lavoro siano completate con successo; in caso contrario, la transazione viene interrotta al punto di errore e le operazioni precedenti vengono riportate allo stato precedente.
Consistency - Assicura che il database modifichi correttamente gli stati in seguito a una transazione eseguita correttamente.
Isolation - Consente alle transazioni di operare in modo indipendente e trasparente l'una dall'altra.
Durability - Assicura che il risultato o l'effetto di una transazione confermata persista in caso di guasto del sistema.

Controllo delle transazioni

I seguenti comandi vengono utilizzati per controllare le transazioni:

BEGIN TRANSACTION - Per avviare una transazione.
COMMIT - Per salvare le modifiche, in alternativa puoi usare END TRANSACTION comando.
ROLLBACK - Per ripristinare le modifiche.

I comandi di controllo transazionale vengono utilizzati solo con i comandi DML solo INSERT, UPDATE e DELETE. Non possono essere utilizzati durante la creazione di tabelle o durante la loro eliminazione perché queste operazioni vengono salvate automaticamente nel database.

Il comando BEGIN TRANSACTION

Le transazioni possono essere avviate utilizzando BEGIN TRANSACTION o semplicemente il comando BEGIN. Tali transazioni di solito persistono fino a quando non viene rilevato il successivo comando COMMIT o ROLLBACK. Ma una transazione verrà anche ROLLBACK se il database viene chiuso o se si verifica un errore.

Quanto segue è la semplice sintassi per avviare una transazione:

BEGIN;

or

BEGIN TRANSACTION;

Il comando COMMIT

Il comando COMMIT è il comando transazionale utilizzato per salvare le modifiche invocate da una transazione nel database.

Il comando COMMIT salva tutte le transazioni nel database dall'ultimo comando COMMIT o ROLLBACK.

La sintassi per il comando COMMIT è la seguente:

COMMIT;

or

END TRANSACTION;

Il comando ROLLBACK

Il comando ROLLBACK è il comando transazionale utilizzato per annullare le transazioni che non sono già state salvate nel database.

Il comando ROLLBACK può essere utilizzato solo per annullare le transazioni dall'ultimo comando COMMIT o ROLLBACK.

La sintassi per il comando ROLLBACK è la seguente:

ROLLBACK;

Esempio

Considera che la tabella AZIENDA contiene i seguenti record:

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

Ora, iniziamo una transazione ed eliminiamo i record dalla tabella con età = 25 e infine usiamo il comando ROLLBACK per annullare tutte le modifiche.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
ROLLBACK;

Se controllerai che la tabella AZIENDA abbia ancora i seguenti record:

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

Ora, iniziamo un'altra transazione ed eliminiamo i record dalla tabella con età = 25 e infine utilizziamo il comando COMMIT per eseguire il commit di tutte le modifiche.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
COMMIT;

Se controlli la tabella AZIENDA, ha ancora i seguenti record:

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)

Serrature o esclusivo serrature o serrature scrittura impedire agli utenti di modificare una riga o un'intera tabella. Le righe modificate da UPDATE e DELETE vengono quindi bloccate automaticamente in modo esclusivo per la durata della transazione. Ciò impedisce ad altri utenti di modificare la riga fino a quando non viene eseguito il commit o il rollback della transazione.

L'unico momento in cui gli utenti devono attendere altri utenti è quando stanno tentando di modificare la stessa riga. Se modificano righe diverse, non è necessaria alcuna attesa. Le query SELECT non devono mai aspettare.

Il database esegue il blocco automaticamente. In alcuni casi, tuttavia, il blocco deve essere controllato manualmente. Il blocco manuale può essere eseguito utilizzando il comando LOCK. Consente la specifica del tipo di blocco e dell'ambito di una transazione.

Sintassi per il comando LOCK

La sintassi di base per il comando LOCK è la seguente:

LOCK [ TABLE ]
name
 IN
lock_mode

name- Il nome (facoltativamente qualificato dallo schema) di una tabella esistente da bloccare. Se viene specificato SOLO prima del nome della tabella, solo quella tabella è bloccata. Se ONLY non è specificato, la tabella e tutte le sue tabelle discendenti (se presenti) sono bloccate.
lock_mode- La modalità di blocco specifica con quali blocchi questo blocco è in conflitto. Se non viene specificata alcuna modalità di blocco, viene utilizzata ACCESS EXCLUSIVE, la modalità più restrittiva. I valori possibili sono: ACCESS SHARE, ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE, EXCLUSIVE, ACCESS EXCLUSIVE.

Una volta ottenuto, il blocco viene mantenuto per il resto della transazione corrente. Non è presente alcun comando UNLOCK TABLE; i blocchi vengono sempre rilasciati alla fine della transazione.

DeadLocks

I deadlock possono verificarsi quando due transazioni sono in attesa l'una dell'altra per completare le loro operazioni. Sebbene PostgreSQL possa rilevarli e terminarli con un ROLLBACK, i deadlock possono comunque essere scomodi. Per evitare che le tue applicazioni si imbattano in questo problema, assicurati di progettarle in modo tale che blocchino gli oggetti nello stesso ordine.

Serrature consultive

PostgreSQL fornisce i mezzi per creare blocchi con significati definiti dall'applicazione. Questi sono chiamati blocchi di avviso . Poiché il sistema non ne impone l'uso, spetta all'applicazione utilizzarli correttamente. I blocchi di avviso possono essere utili per le strategie di blocco che si adattano in modo scomodo al modello MVCC.

Ad esempio, un uso comune dei blocchi di avviso è quello di emulare strategie di blocco pessimistiche tipiche dei cosiddetti sistemi di gestione dei dati "flat file". Sebbene un flag memorizzato in una tabella possa essere utilizzato per lo stesso scopo, i blocchi di avviso sono più veloci, evitano il gonfiaggio della tabella e vengono automaticamente ripuliti dal server alla fine della sessione.

Esempio

Considera la tabella AZIENDA che ha i record come segue:

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)

L'esempio seguente blocca la tabella COMPANY all'interno del database testdb in modalità ACCESS EXCLUSIVE. L'istruzione LOCK funziona solo in modalità transazione -

testdb=#BEGIN;
LOCK TABLE company1 IN ACCESS EXCLUSIVE MODE;

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

LOCK TABLE

Il messaggio sopra indica che la tabella è bloccata fino al termine della transazione e per terminare la transazione dovrai eseguire il rollback o il commit della transazione.

Una sottoquery, una query interna o una query annidata è una query all'interno di un'altra query PostgreSQL e incorporata nella clausola WHERE.

Una sottoquery viene utilizzata per restituire i dati che verranno utilizzati nella query principale come condizione per limitare ulteriormente i dati da recuperare.

Le sottoquery possono essere utilizzate con le istruzioni SELECT, INSERT, UPDATE e DELETE insieme a operatori come =, <,>,> =, <=, IN, ecc.

Ci sono alcune regole che le sottoquery devono seguire:

Le sottoquery devono essere racchiuse tra parentesi.
Una sottoquery può avere solo una colonna nella clausola SELECT, a meno che non siano presenti più colonne nella query principale per la sottoquery per confrontare le colonne selezionate.
Non è possibile utilizzare ORDER BY in una sottoquery, sebbene la query principale possa utilizzare ORDER BY. GROUP BY può essere utilizzato per eseguire la stessa funzione di ORDER BY in una sottoquery.
Le sottoquery che restituiscono più di una riga possono essere utilizzate solo con più operatori di valore, come l'operatore IN, EXISTS, NOT IN, ANY / SOME, ALL.
L'operatore BETWEEN non può essere utilizzato con una sottoquery; tuttavia, BETWEEN può essere utilizzato all'interno della sottoquery.

Sottoquery con l'istruzione SELECT

Le sottoquery vengono utilizzate più di frequente con l'istruzione SELECT. La sintassi di base è la seguente:

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
      (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

Esempio

Considera la tabella AZIENDA con i seguenti record:

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)

Ora, controlliamo la seguente sottoquery con l'istruzione SELECT:

testdb=# SELECT *
   FROM COMPANY
   WHERE ID IN (SELECT ID
      FROM COMPANY
      WHERE SALARY > 45000) ;

Ciò produrrebbe il seguente risultato:

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

Sottoquery con l'istruzione INSERT

Le sottoquery possono essere utilizzate anche con le istruzioni INSERT. L'istruzione INSERT utilizza i dati restituiti dalla sottoquery per inserirli in un'altra tabella. I dati selezionati nella sottoquery possono essere modificati con qualsiasi funzione di carattere, data o numero.

La sintassi di base è la seguente:

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ] ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Esempio

Si consideri una tabella COMPANY_BKP, con struttura simile alla tabella COMPANY e può essere creata utilizzando la stessa CREATE TABLE utilizzando COMPANY_BKP come nome della tabella. Ora, per copiare la tabella COMPANY completa in COMPANY_BKP, la seguente è la sintassi:

testdb=# INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY
   WHERE ID IN (SELECT ID
      FROM COMPANY) ;

Sottoquery con l'istruzione UPDATE

La sottoquery può essere utilizzata insieme all'istruzione UPDATE. Una o più colonne in una tabella possono essere aggiornate quando si utilizza una sottoquery con l'istruzione UPDATE.

La sintassi di base è la seguente:

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Esempio

Supponendo che sia disponibile la tabella COMPANY_BKP, che è il backup della tabella COMPANY.

L'esempio seguente aggiorna lo SALARIO di 0,50 volte nella tabella AZIENDA per tutti i clienti, la cui ETÀ è maggiore o uguale a 27 -

testdb=# UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Ciò influirà su due righe e alla fine la tabella AZIENDA avrebbe i seguenti record:

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)

Sottoquery con l'istruzione DELETE

La sottoquery può essere utilizzata insieme all'istruzione DELETE come con qualsiasi altra istruzione menzionata sopra.

La sintassi di base è la seguente:

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Esempio

Supponendo che sia disponibile la tabella COMPANY_BKP, che è un backup della tabella COMPANY.

L'esempio seguente elimina i record dalla tabella AZIENDA per tutti i clienti, la cui ETÀ è maggiore o uguale a 27 -

testdb=# DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE > 27 );

Ciò influirà su due righe e alla fine la tabella AZIENDA avrebbe i seguenti record:

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 ha i tipi di dati smallserial , serial e bigserial ; questi non sono veri tipi, ma semplicemente una comodità notazionale per la creazione di colonne identificative univoche. Questi sono simili alla proprietà AUTO_INCREMENT supportata da alcuni altri database.

Se desideri che una colonna seriale abbia un vincolo univoco o sia una chiave primaria, ora deve essere specificata, proprio come qualsiasi altro tipo di dati.

Il nome del tipo serial crea colonne di un numero intero . Il nome del tipo bigserial crea una colonna bigint . bigserial dovrebbe essere utilizzato se si prevede di utilizzare più di 2 ³¹ identificatori per tutta la durata della tabella. Il nome del tipo smallserial crea una colonna smallint .

Sintassi

L'utilizzo di base di SERIAL dataype è il seguente -

CREATE TABLE tablename (
   colname SERIAL
);

Esempio

Considerare la tabella AZIENDA da creare come segue:

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

Ora, inserisci i seguenti record nella tabella AZIENDA -

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 );

Questo inserirà sette tuple nella tabella AZIENDA e AZIENDA avrà i seguenti record:

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

Ogni volta che un oggetto viene creato in un database, gli viene assegnato un proprietario. Il proprietario è solitamente colui che ha eseguito la dichiarazione di creazione. Per la maggior parte dei tipi di oggetti, lo stato iniziale è che solo il proprietario (o un superutente) può modificare o eliminare l'oggetto. Per consentire ad altri ruoli o utenti di utilizzarlo, è necessario concedere privilegi o autorizzazioni.

Diversi tipi di privilegi in PostgreSQL sono:

SELECT,
INSERT,
UPDATE,
DELETE,
TRUNCATE,
REFERENCES,
TRIGGER,
CREATE,
CONNECT,
TEMPORARY,
ESEGUI e
USAGE

A seconda del tipo di oggetto (tabella, funzione, ecc.), I privilegi vengono applicati all'oggetto. Per assegnare privilegi agli utenti, viene utilizzato il comando GRANT.

Sintassi per GRANT

La sintassi di base per il comando GRANT è la seguente:

GRANT privilege [, ...]
ON object [, ...]
TO { PUBLIC | GROUP group | username }

privilege - i valori potrebbero essere: SELECT, INSERT, UPDATE, DELETE, RULE, ALL.
object- Il nome di un oggetto a cui concedere l'accesso. I possibili oggetti sono: tabella, vista, sequenza
PUBLIC - Un breve modulo che rappresenta tutti gli utenti.
GRUPPO group - Un gruppo a cui concedere privilegi.
username- Il nome di un utente a cui concedere i privilegi. PUBLIC è una forma breve che rappresenta tutti gli utenti.

I privilegi possono essere revocati utilizzando il comando REVOKE.

Sintassi per REVOKE

La sintassi di base per il comando REVOKE è la seguente:

REVOKE privilege [, ...]
ON object [, ...]
FROM { PUBLIC | GROUP groupname | username }

privilege - i valori potrebbero essere: SELECT, INSERT, UPDATE, DELETE, RULE, ALL.
object- Il nome di un oggetto a cui concedere l'accesso. I possibili oggetti sono: tabella, vista, sequenza
PUBLIC - Un breve modulo che rappresenta tutti gli utenti.
GRUPPO group - Un gruppo a cui concedere privilegi.
username- Il nome di un utente a cui concedere i privilegi. PUBLIC è una forma breve che rappresenta tutti gli utenti.

Esempio

Per comprendere i privilegi, creiamo prima un UTENTE come segue:

testdb=# CREATE USER manisha WITH PASSWORD 'password';
CREATE ROLE

Il messaggio CREATE ROLE indica che l'UTENTE "manisha" è stato creato.

Considera la tabella AZIENDA che ha i record come segue:

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)

Successivamente, concediamo tutti i privilegi su una tabella COMPANY all'utente "manisha" come segue:

testdb=# GRANT ALL ON COMPANY TO manisha;
GRANT

Il messaggio GRANT indica che tutti i privilegi sono assegnati all'UTENTE.

Successivamente, revociamo i privilegi all'UTENTE "manisha" come segue:

testdb=# REVOKE ALL ON COMPANY FROM manisha;
REVOKE

Il messaggio REVOKE indica che tutti i privilegi sono stati revocati dall'UTENTE.

Puoi anche eliminare l'utente come segue:

testdb=# DROP USER manisha;
DROP ROLE

Il messaggio DROP ROLE indica che l'UTENTE "Manisha" è stato eliminato dal database.

Abbiamo discusso dei tipi di dati Data / Ora nel capitolo Tipi di dati . Vediamo ora gli operatori e le funzioni di data / ora.

La tabella seguente elenca i comportamenti degli operatori aritmetici di base:

Operatore	Esempio	Risultato
+	data "2001-09-28" + numero intero "7"	data "2001-10-05"
+	data "2001-09-28" + intervallo "1 ora"	timestamp "2001-09-28 01:00:00"
+	data '2001-09-28' + ora '03: 00 '	timestamp "2001-09-28 03:00:00"
+	intervallo "1 giorno" + intervallo "1 ora"	intervallo "1 giorno 01:00:00"
+	timestamp "2001-09-28 01:00" + intervallo "23 ore"	timestamp "2001-09-29 00:00:00"
+	ora '01: 00 '+ intervallo' 3 ore '	tempo '04: 00: 00 '
-	- intervallo "23 ore"	intervallo '-23: 00: 00'
-	data "2001-10-01" - data "2001-09-28"	intero "3" (giorni)
-	data "2001-10-01" - numero intero "7"	data "2001-09-24"
-	data '2001-09-28' - intervallo '1 ora'	timestamp "2001-09-27 23:00:00"
-	ora '05: 00 '- ora '03: 00'	intervallo '02: 00: 00 '
-	ora '05: 00 '- intervallo' 2 ore '	tempo '03: 00: 00 '
-	timestamp "2001-09-28 23:00" - intervallo "23 ore"	timestamp "2001-09-28 00:00:00"
-	intervallo "1 giorno" - intervallo "1 ora"	intervallo '1 giorno -01: 00: 00'
-	timestamp "29/09/2001 03:00" - timestamp "27/09/2001 12:00"	intervallo "1 giorno 15:00:00"
*	900 * intervallo "1 secondo"	intervallo '00: 15: 00 '
*	21 * intervallo "1 giorno"	intervallo "21 giorni"
*	doppia precisione "3,5" * intervallo "1 ora"	intervallo '03: 30: 00 '
/	intervallo "1 ora" / doppia precisione "1,5"	intervallo '00: 40: 00 '

Di seguito è riportato l'elenco di tutte le funzioni importanti relative a data e ora disponibili.

S. No.	Descrizione della funzione
1	ETÀ() Sottrai argomenti
2	DATA / ORA CORRENTI () Data e ora correnti
3	DATE_PART () Ottieni sottocampo (equivalente a estrarre)
4	ESTRATTO() Ottieni sottocampo
5	ISFINITE () Test per data, ora e intervallo finiti (non +/- infinito)
6	GIUSTIFICARE Regola l'intervallo

AGE (timestamp, timestamp), AGE (timestamp)

S. No.	Descrizione della funzione
1	AGE(timestamp, timestamp) Quando invocato con la forma TIMESTAMP del secondo argomento, AGE () sottrae argomenti, producendo un risultato "simbolico" che utilizza anni e mesi ed è di tipo INTERVAL.
2	AGE(timestamp) Quando invocato con solo il TIMESTAMP come argomento, AGE () sottrae da current_date (a mezzanotte).

Esempio della funzione AGE (timestamp, timestamp) è -

testdb=# SELECT AGE(timestamp '2001-04-10', timestamp '1957-06-13');

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

age
-------------------------
 43 years 9 mons 27 days

Esempio della funzione AGE (timestamp) è -

testdb=# select age(timestamp '1957-06-13');

L'istruzione PostgreSQL sopra indicata produrrà il seguente risultato:

age
--------------------------
 55 years 10 mons 22 days

DATA / ORA CORRENTI ()

PostgreSQL fornisce una serie di funzioni che restituiscono valori relativi alla data e all'ora correnti. Di seguito sono riportate alcune funzioni:

S. No.	Descrizione della funzione
1	CURRENT_DATE Fornisce la data corrente.
2	CURRENT_TIME Fornisce valori con fuso orario.
3	CURRENT_TIMESTAMP Fornisce valori con fuso orario.
4	CURRENT_TIME(precision) Facoltativamente accetta un parametro di precisione, che fa sì che il risultato venga arrotondato a quel numero di cifre frazionarie nel campo dei secondi.
5	CURRENT_TIMESTAMP(precision) Facoltativamente accetta un parametro di precisione, che fa sì che il risultato venga arrotondato a quel numero di cifre frazionarie nel campo dei secondi.
6	LOCALTIME Fornisce valori senza fuso orario.
7	LOCALTIMESTAMP Fornisce valori senza fuso orario.
8	LOCALTIME(precision) Facoltativamente accetta un parametro di precisione, che fa sì che il risultato venga arrotondato a quel numero di cifre frazionarie nel campo dei secondi.
9	LOCALTIMESTAMP(precision) Facoltativamente accetta un parametro di precisione, che fa sì che il risultato venga arrotondato a quel numero di cifre frazionarie nel campo dei secondi.

Esempi di utilizzo delle funzioni dalla tabella sopra:

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 fornisce anche funzioni che restituiscono l'ora di inizio dell'istruzione corrente, nonché l'ora corrente effettiva nel momento in cui viene chiamata la funzione. Queste funzioni sono:

S. No.	Descrizione della funzione
1	transaction_timestamp() È equivalente a CURRENT_TIMESTAMP, ma è denominato per riflettere chiaramente ciò che restituisce.
2	statement_timestamp() Restituisce l'ora di inizio dell'istruzione corrente.
3	clock_timestamp() Restituisce l'ora corrente effettiva e quindi il suo valore cambia anche all'interno di un singolo comando SQL.
4	timeofday() Restituisce l'ora corrente effettiva, ma come stringa di testo formattata anziché come timestamp con il valore del fuso orario.
5	now() È un PostgreSQL tradizionale equivalente a transaction_timestamp ().

DATE_PART (testo, timestamp), DATE_PART (testo, intervallo), DATE_TRUNC (testo, timestamp)

S. No.	Descrizione della funzione
1	DATE_PART('field', source) Queste funzioni ottengono i sottocampi. Il parametro field deve essere un valore stringa, non un nome. I nomi dei campi validi sono: century, day, decade, dow, doy, epoch, hour, isodow, isoyear, microseconds, millennium, milliseconds, minute, month, quarter, second, timezone, timezone_hour, timezone_minute, week, year.
2	DATE_TRUNC('field', source) Questa funzione è concettualmente simile alla funzione trunc per i numeri. source è un'espressione di valore di tipo timestamp o intervallo. campo seleziona con quale precisione troncare il valore di input. Il valore restituito è di tipo timestamp o intervallo . I valori validi per il campo sono: microsecondi, millisecondi, secondo, minuto, ora, giorno, settimana, mese, trimestre, anno, decennio, secolo, millennio

Di seguito sono riportati esempi di funzioni DATE_PART ( 'campo' , sorgente):

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)

I seguenti sono esempi di funzioni DATE_TRUNC ( 'campo' , sorgente):

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 (campo da timestamp), EXTRACT (campo da intervallo)

Il EXTRACT(field FROM source)la funzione recupera i sottocampi come l'anno o l'ora dai valori di data / ora. L' origine deve essere un'espressione di valore di tipo timestamp, ora o intervallo . Il campo è un identificatore o una stringa che seleziona quale campo estrarre dal valore di origine. La funzione ESTRATTA restituisce valori di tipo doppia precisione .

I seguenti sono nomi di campo validi (simili ai nomi di campo funzione DATE_PART): century, day, decade, dow, doy, epoch, hour, isodow, isoyear, microseconds, millennium, milliseconds, minute, month, quarter, second, timezone, timezone_hour , timezone_minute, settimana, anno.

I seguenti sono esempi di funzioni EXTRACT ( 'field' , source) -

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 (data), ISFINITE (timestamp), ISFINITE (intervallo)

S. No.	Descrizione della funzione
1	ISFINITE(date) Test per data finita.
2	ISFINITE(timestamp) Test per timestamp finito.
3	ISFINITE(interval) Test per intervallo finito.

Di seguito sono riportati gli esempi delle funzioni ISFINITE ():

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 (intervallo), JUSTIFY_HOURS (intervallo), JUSTIFY_INTERVAL (intervallo)

S. No.	Descrizione della funzione
1	JUSTIFY_DAYS(interval) Regola l'intervallo in modo che i periodi di tempo di 30 giorni siano rappresentati come mesi. Restituisci il fileinterval genere
2	JUSTIFY_HOURS(interval) Regola l'intervallo in modo che i periodi di 24 ore siano rappresentati come giorni. Restituisci il fileinterval genere
3	JUSTIFY_INTERVAL(interval) Regola l'intervallo utilizzando JUSTIFY_DAYS e JUSTIFY_HOURS, con ulteriori aggiustamenti del segno. Restituisci il fileinterval genere

Di seguito sono riportati gli esempi per le funzioni ISFINITE ():

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 functions, note anche come stored procedure, consentono di eseguire operazioni che normalmente richiederebbero diverse query e round trip in un'unica funzione all'interno del database. Le funzioni consentono il riutilizzo del database poiché altre applicazioni possono interagire direttamente con le stored procedure invece di un codice di livello intermedio o di duplicazione.

Le funzioni possono essere create in un linguaggio a tua scelta come SQL, PL / pgSQL, C, Python, ecc.

Sintassi

La sintassi di base per creare una funzione è la seguente:

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;

Dove,

function-name specifica il nome della funzione.
L'opzione [O SOSTITUISCI] consente di modificare una funzione esistente.
La funzione deve contenere un file return dichiarazione.
RETURNla clausola specifica il tipo di dati che si intende restituire dalla funzione. Ilreturn_datatype può essere un tipo di base, composto o di dominio oppure può fare riferimento al tipo di una colonna della tabella.
function-body contiene la parte eseguibile.
La parola chiave AS viene utilizzata per creare una funzione autonoma.
plpgsqlè il nome del linguaggio in cui è implementata la funzione. Qui utilizziamo questa opzione per PostgreSQL, può essere SQL, C, interno o il nome di un linguaggio procedurale definito dall'utente. Per compatibilità con le versioni precedenti, il nome può essere racchiuso tra virgolette singole.

Esempio

L'esempio seguente illustra la creazione e la chiamata di una funzione autonoma. Questa funzione restituisce il numero totale di record nella tabella AZIENDA. Useremo la tabella AZIENDA , che ha i seguenti record:

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)

La funzione totalRecords () è la seguente:

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;

Quando viene eseguita la query di cui sopra, il risultato sarebbe:

testdb# CREATE FUNCTION

Ora, eseguiamo una chiamata a questa funzione e controlliamo i record nella tabella COMPANY

testdb=# select totalRecords();

Quando viene eseguita la query di cui sopra, il risultato sarebbe:

totalrecords
--------------
      7
(1 row)

Le funzioni integrate di PostgreSQL, chiamate anche funzioni di aggregazione, vengono utilizzate per eseguire l'elaborazione su stringhe o dati numerici.

Di seguito è riportato l'elenco di tutte le funzioni predefinite di PostgreSQL per scopi generici:

Funzione PostgreSQL COUNT - La funzione di aggregazione PostgreSQL COUNT viene utilizzata per contare il numero di righe in una tabella di database.
Funzione PostgreSQL MAX - La funzione di aggregazione PostgreSQL MAX ci consente di selezionare il valore più alto (massimo) per una determinata colonna.
Funzione MIN di PostgreSQL - La funzione di aggregazione MIN di PostgreSQL ci consente di selezionare il valore più basso (minimo) per una certa colonna.
Funzione PostgreSQL AVG: la funzione di aggregazione PostgreSQL AVG seleziona il valore medio per determinate colonne della tabella.
Funzione PostgreSQL SUM - La funzione di aggregazione PostgreSQL SUM consente di selezionare il totale per una colonna numerica.
Funzioni ARRAY di PostgreSQL - La funzione di aggregazione ARRAY di PostgreSQL inserisce i valori di input, inclusi i valori nulli, concatenati in un array.
Funzioni numeriche PostgreSQL : elenco completo delle funzioni PostgreSQL necessarie per manipolare i numeri in SQL.
PostgreSQL String Functions - Elenco completo delle funzioni PostgreSQL richieste per manipolare le stringhe in PostgreSQL.

Questo tutorial utilizzerà libpqxxlibreria, che è l'API client ufficiale C ++ per PostgreSQL. Il codice sorgente per libpqxx è disponibile sotto la licenza BSD, quindi sei libero di scaricarlo, passarlo ad altri, modificarlo, venderlo, includerlo nel tuo codice e condividere le tue modifiche con chiunque tu scelga.

Installazione

L'ultima versione di libpqxx è disponibile per essere scaricata dal link Download Libpqxx . Quindi scarica l'ultima versione e segui i seguenti passaggi:

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

Prima di iniziare a utilizzare l'interfaccia PostgreSQL C / C ++, trova il file pg_hba.conf file nella directory di installazione di PostgreSQL e aggiungi la seguente riga:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

È possibile avviare / riavviare il server postgres nel caso in cui non sia in esecuzione utilizzando il seguente comando:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

API dell'interfaccia C / C ++

Le seguenti sono importanti routine di interfaccia che possono soddisfare le tue esigenze per lavorare con il database PostgreSQL dal tuo programma C / C ++. Se stai cercando un'applicazione più sofisticata, puoi esaminare la documentazione ufficiale di libpqxx oppure puoi utilizzare le API disponibili in commercio.

S. No.	API e descrizione
1	pqxx::connection C( const std::string & dbstring ) Questo è un typedef che verrà utilizzato per connettersi al database. Qui, dbstring fornisce i parametri richiesti per connettersi al database, ad esempiodbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432. Se la connessione è impostata correttamente, crea C con l'oggetto connessione che fornisce varie utili funzioni pubbliche.
2	C.is_open() Il metodo is_open () è un metodo pubblico di oggetto di connessione e restituisce un valore booleano. Se la connessione è attiva, questo metodo restituisce true, altrimenti restituisce false.
3	C.disconnect() Questo metodo viene utilizzato per disconnettere una connessione al database aperta.
4	pqxx::work W( C ) Si tratta di un typedef che verrà utilizzato per creare un oggetto transazionale utilizzando la connessione C, che alla fine verrà utilizzato per eseguire istruzioni SQL in modalità transazionale. Se l'oggetto transazione viene creato correttamente, viene assegnato alla variabile W che verrà utilizzata per accedere ai metodi pubblici relativi all'oggetto transazionale.
5	W.exec(const std::string & sql) Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire l'istruzione SQL.
6	W.commit() Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire il commit della transazione.
7	W.abort() Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire il rollback della transazione.
8	pqxx::nontransaction N( C ) Si tratta di un typedef che verrà utilizzato per creare un oggetto non transazionale utilizzando la connessione C, che alla fine verrà utilizzato per eseguire istruzioni SQL in modalità non transazionale. Se l'oggetto transazione viene creato correttamente, viene assegnato alla variabile N che verrà utilizzata per accedere ai metodi pubblici relativi all'oggetto non transazionale.
9	N.exec(const std::string & sql) Questo metodo pubblico da un oggetto non transazionale verrà utilizzato per eseguire l'istruzione SQL e restituisce un oggetto risultato che in realtà è un interatore che contiene tutti i record restituiti.

Connessione al database

Il seguente segmento di codice C mostra come connettersi a un database esistente in esecuzione sulla macchina locale alla porta 5432. Qui, ho usato la barra rovesciata \ per la continuazione della riga.

#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;
   }
}

Ora, compiliamo ed eseguiamo il programma sopra per connetterci al nostro database testdb, che è già disponibile nello schema ed è possibile accedervi utilizzando l'utente postgres e la password pass123 .

È possibile utilizzare l'ID utente e la password in base alle impostazioni del database. Ricorda di mantenere -lpqxx e -lpq nell'ordine dato! Altrimenti, il linker si lamenterà amaramente delle funzioni mancanti con nomi che iniziano con "PQ".

$g++ test.cpp -lpqxx -lpq $./a.out
Opened database successfully: testdb

Crea una tabella

Il seguente segmento di codice C verrà utilizzato per creare una tabella nel database creato in precedenza:

#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;
}

Quando il programma sopra indicato viene compilato ed eseguito, creerà la tabella COMPANY nel database testdb e visualizzerà le seguenti istruzioni:

Opened database successfully: testdb
Table created successfully

Operazione INSERT

Il seguente segmento di codice C mostra come possiamo creare record nella nostra tabella COMPANY creata nell'esempio precedente:

#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;
}

Quando il programma sopra indicato viene compilato ed eseguito, creerà dati record nella tabella AZIENDA e mostrerà le seguenti due righe:

Opened database successfully: testdb
Records created successfully

Operazione SELECT

Il seguente segmento di codice C mostra come possiamo recuperare e visualizzare i record dalla nostra tabella AZIENDA creata nell'esempio precedente:

#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;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

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

Operazione UPDATE

Il seguente segmento di codice C mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

#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;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

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

Operazione DELETE

Il seguente segmento di codice C mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

#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;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

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

Installazione

Prima di iniziare a utilizzare PostgreSQL nei nostri programmi Java, dobbiamo assicurarci di avere PostgreSQL JDBC e Java configurati sulla macchina. Puoi controllare il tutorial Java per l'installazione di Java sulla tua macchina. Ora controlliamo come impostare il driver JDBC PostgreSQL.

Scarica l'ultima versione di postgresql- (VERSION) .jdbc.jar dal repository postgresql-jdbc .
Aggiungi il file jar scaricato postgresql- (VERSIONE) .jdbc.jar nel tuo percorso di classe, oppure puoi usarlo insieme all'opzione -classpath come spiegato di seguito negli esempi.

La sezione seguente presume che tu abbia poca conoscenza dei concetti di Java JDBC. In caso contrario, si consiglia di dedicare mezz'ora al Tutorial JDBC per familiarizzare con i concetti spiegati di seguito.

Connessione al database

Il seguente codice Java mostra come connettersi a un database esistente. Se il database non esiste, verrà creato e infine verrà restituito un oggetto database.

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");
   }
}

Prima di compilare ed eseguire il programma sopra, trova pg_hba.conf file nella directory di installazione di PostgreSQL e aggiungi la seguente riga:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

È possibile avviare / riavviare il server postgres nel caso in cui non sia in esecuzione utilizzando il seguente comando:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Ora, compiliamo ed eseguiamo il programma sopra per connetterci con testdb. Qui stiamo usandopostgres come ID utente e 123come password per accedere al database. È possibile modificarlo secondo la configurazione e l'impostazione del database. Stiamo anche assumendo la versione corrente del driver JDBCpostgresql-9.2-1002.jdbc3.jar è disponibile nel percorso corrente.

C:\JavaPostgresIntegration>javac PostgreSQLJDBC.java
C:\JavaPostgresIntegration>java -cp c:\tools\postgresql-9.2-1002.jdbc3.jar;C:\JavaPostgresIntegration PostgreSQLJDBC
Open database successfully

Crea una tabella

Il seguente programma Java verrà utilizzato per creare una tabella nel database aperto in precedenza. Assicurati di non avere già questa tabella nel database di destinazione.

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");
   }
}

Quando un programma viene compilato ed eseguito, creerà la tabella COMPANY in formato testdb database e visualizzerà le seguenti due righe:

Opened database successfully
Table created successfully

Operazione INSERT

Il seguente programma Java mostra come possiamo creare record nella nostra tabella AZIENDA creata nell'esempio precedente:

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");
   }
}

Quando il programma di cui sopra viene compilato ed eseguito, creerà dati record nella tabella AZIENDA e visualizzerà le seguenti due righe:

Opened database successfully
Records created successfully

Operazione SELECT

Il seguente programma Java mostra come possiamo recuperare e visualizzare i record dalla nostra tabella AZIENDA creata nell'esempio precedente:

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");
   }
}

Quando il programma viene compilato ed eseguito, produrrà il seguente risultato:

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

Operazione UPDATE

Il seguente codice Java mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

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");
   }
}

Quando il programma viene compilato ed eseguito, produrrà il seguente risultato:

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

Operazione DELETE

Il seguente codice Java mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

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");
   }
}

Quando il programma viene compilato ed eseguito, produrrà il seguente risultato:

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

Installazione

L'estensione PostgreSQL è abilitata per impostazione predefinita nelle ultime versioni di PHP 5.3.x. È possibile disabilitarlo utilizzando--without-pgsqlin fase di compilazione. È ancora possibile utilizzare il comando yum per installare l'interfaccia PHP -PostgreSQL -

yum install php-pgsql

Prima di iniziare a utilizzare l'interfaccia PHP PostgreSQL, trova il file pg_hba.conf file nella directory di installazione di PostgreSQL e aggiungi la seguente riga:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Puoi avviare / riavviare il server postgres, nel caso in cui non sia in esecuzione, utilizzando il seguente comando:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Gli utenti Windows devono abilitare php_pgsql.dll per utilizzare questa estensione. Questa DLL è inclusa nelle distribuzioni di Windows nelle ultime versioni di PHP 5.3.x

Per istruzioni dettagliate sull'installazione, controlla il nostro tutorial PHP e il suo sito Web ufficiale.

API dell'interfaccia PHP

Le seguenti sono routine PHP importanti, che possono essere sufficienti per lavorare con il database PostgreSQL dal programma PHP. Se stai cercando un'applicazione più sofisticata, puoi consultare la documentazione ufficiale di PHP.

S. No.	API e descrizione
1	resource pg_connect ( string $connection_string [, int $connect_type ] ) Questo apre una connessione a un database PostgreSQL specificato da connection_string. Se PGSQL_CONNECT_FORCE_NEW viene passato come connect_type, viene creata una nuova connessione in caso di una seconda chiamata a pg_connect (), anche se connection_string è identica a una connessione esistente.
2	bool pg_connection_reset ( resource $connection ) Questa routine ripristina la connessione. È utile per il ripristino degli errori. Restituisce TRUE in caso di successo o FALSE in caso di fallimento.
3	int pg_connection_status ( resource $connection ) Questa routine restituisce lo stato della connessione specificata. Restituisce PGSQL_CONNECTION_OK o PGSQL_CONNECTION_BAD.
4	string pg_dbname ([ resource $connection ] ) Questa routine restituisce il nome del database che la risorsa di connessione PostgreSQL data.
5	resource pg_prepare ([ resource $connection ], string $stmtname, string $query ) Questo invia una richiesta per creare un'istruzione preparata con i parametri forniti e attende il completamento.
6	resource pg_execute ([ resource $connection ], string $stmtname, array $params ) Questa routine invia una richiesta per eseguire un'istruzione preparata con determinati parametri e attende il risultato.
7	resource pg_query ([ resource $connection ], string $query ) Questa routine esegue la query sulla connessione al database specificata.
8	array pg_fetch_row ( resource $result [, int $row ] ) Questa routine recupera una riga di dati dal risultato associato alla risorsa del risultato specificata.
9	array pg_fetch_all ( resource $result ) Questa routine restituisce una matrice che contiene tutte le righe (record) nella risorsa risultato.
10	int pg_affected_rows ( resource $result ) Questa routine restituisce il numero di righe interessate dalle query INSERT, UPDATE e DELETE.
11	int pg_num_rows ( resource $result ) Questa routine restituisce il numero di righe in una risorsa risultato PostgreSQL, ad esempio il numero di righe restituite dall'istruzione SELECT.
12	bool pg_close ([ resource $connection ] ) Questa routine chiude la connessione non persistente a un database PostgreSQL associato alla risorsa di connessione data.
13	string pg_last_error ([ resource $connection ] ) Questa routine restituisce l'ultimo messaggio di errore per una determinata connessione.
14	string pg_escape_literal ([ resource $connection ], string $data ) Questa routine evita un valore letterale per l'inserimento in un campo di testo.
15	string pg_escape_string ([ resource $connection ], string $data ) Questa routine esegue l'escape di una stringa per interrogare il database.

Connessione al database

Il seguente codice PHP mostra come connettersi a un database esistente su una macchina locale e infine verrà restituito un oggetto di connessione al database.

<?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";
   }
?>

Ora, eseguiamo il programma sopra indicato per aprire il nostro database testdb: se il database è stato aperto con successo, allora darà il seguente messaggio -

Opened database successfully

Crea una tabella

Il seguente programma PHP verrà utilizzato per creare una tabella in un database creato in precedenza:

<?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);
?>

Quando il programma sopra indicato viene eseguito, creerà la tabella COMPANY nel tuo file testdb e mostrerà i seguenti messaggi -

Opened database successfully
Table created successfully

Operazione INSERT

Il seguente programma PHP mostra come possiamo creare record nella nostra tabella AZIENDA creata nell'esempio sopra:

<?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);
?>

Quando il programma sopra indicato viene eseguito, creerà i record dati nella tabella AZIENDA e visualizzerà le seguenti due righe:

Opened database successfully
Records created successfully

Operazione SELECT

Il seguente programma PHP mostra come possiamo recuperare e visualizzare i record dalla nostra tabella AZIENDA creata nell'esempio sopra -

<?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);
?>

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato. Tieni presente che i campi vengono restituiti nella sequenza in cui sono stati utilizzati durante la creazione della tabella.

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

Operazione UPDATE

Il seguente codice PHP mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

<?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);
?>

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Operazione DELETE

Il seguente codice PHP mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

<?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);
?>

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Installazione

PostgreSQL può essere integrato con Perl utilizzando il modulo Perl DBI, che è un modulo di accesso al database per il linguaggio di programmazione Perl. Definisce un insieme di metodi, variabili e convenzioni che forniscono un'interfaccia database standard.

Ecco alcuni semplici passaggi per installare il modulo DBI sulla tua macchina Linux / Unix -

$ 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

Se è necessario installare il driver SQLite per DBI, è possibile installarlo come segue:

$ 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

Prima di iniziare a utilizzare l'interfaccia PostgreSQL di Perl, trova il file pg_hba.conf file nella directory di installazione di PostgreSQL e aggiungi la seguente riga:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Puoi avviare / riavviare il server postgres, nel caso in cui non sia in esecuzione, utilizzando il seguente comando:

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

API dell'interfaccia DBI

Di seguito sono riportate le routine DBI importanti, che possono essere sufficienti per il tuo requisito per lavorare con il database SQLite dal tuo programma Perl. Se stai cercando un'applicazione più sofisticata, puoi consultare la documentazione ufficiale di Perl DBI.

S. No.	API e descrizione
1	DBI→connect($data_source, "userid", "password", \%attr) Stabilisce una connessione al database, o sessione, con $ data_source richiesta. Restituisce un oggetto handle di database se la connessione riesce. L'origine dati ha la forma come: DBI:Pg:dbname=$database;host=127.0.0.1;port=5432 Pg è il nome del driver PostgreSQL e testdb è il nome del database.
2	$dbh→do($sql) Questa routine prepara ed esegue una singola istruzione SQL. Restituisce il numero di righe interessate o undef in caso di errore. Un valore restituito di -1 significa che il numero di righe non è noto, non applicabile o non disponibile. Qui $ dbh è un handle restituito dalla chiamata DBI → connect ().
3	$dbh→prepare($sql) Questa routine prepara un'istruzione per l'esecuzione successiva dal motore di database e restituisce un riferimento a un oggetto handle dell'istruzione.
4	$sth→execute() Questa routine esegue qualsiasi elaborazione necessaria per eseguire l'istruzione preparata. Se si verifica un errore, viene restituito un undef. Un'esecuzione riuscita restituisce sempre true indipendentemente dal numero di righe interessate. Qui$sth is a statement handle returned by $dbh → prepara ($ sql) chiamata.
5	$sth→fetchrow_array() Questa routine recupera la riga di dati successiva e la restituisce come un elenco contenente i valori del campo. I campi nulli vengono restituiti come valori undef nell'elenco.
6	$DBI::err Questo è equivalente a $ h → err, dove $h is any of the handle types like $dbh, $sth, or $drh. Restituisce il codice di errore del motore di database nativo dall'ultimo metodo del driver chiamato.
7	$DBI::errstr Questo è equivalente a $ h → errstr, dove $h is any of the handle types like $dbh, $sth, or $drh. Ciò restituisce il messaggio di errore del motore di database nativo dall'ultimo metodo DBI chiamato.
8	$dbh->disconnect() Questa routine chiude una connessione al database precedentemente aperta da una chiamata a DBI → connect ().

Connessione al database

Il seguente codice Perl mostra come connettersi a un database esistente. Se il database non esiste, verrà creato e infine verrà restituito un oggetto database.

#!/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";

Ora, eseguiamo il programma sopra indicato per aprire il nostro database testdb; se il database viene aperto correttamente, verrà visualizzato il seguente messaggio:

Open database successfully

Crea una tabella

Il seguente programma Perl verrà utilizzato per creare una tabella nel database creato in precedenza:

#!/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();

Quando il programma sopra indicato viene eseguito, creerà la tabella COMPANY nel tuo file testdb e mostrerà i seguenti messaggi -

Opened database successfully
Table created successfully

Operazione INSERT

Il seguente programma Perl mostra come possiamo creare record nella nostra tabella AZIENDA creata nell'esempio precedente:

#!/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();

Quando il programma sopra indicato viene eseguito, creerà dati record nella tabella AZIENDA e visualizzerà le seguenti due righe:

Opened database successfully
Records created successfully

Operazione SELECT

Il seguente programma Perl mostra come possiamo recuperare e visualizzare i record dalla nostra tabella AZIENDA creata nell'esempio precedente:

#!/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();

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Operazione UPDATE

Il seguente codice Perl mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

#!/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();

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Operazione DELETE

Il seguente codice Perl mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

#!/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();

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Installazione

PostgreSQL può essere integrato con Python utilizzando il modulo psycopg2. sycopg2 è un adattatore per database PostgreSQL per il linguaggio di programmazione Python. psycopg2 è stato scritto con l'obiettivo di essere molto piccolo e veloce e stabile come una roccia. Non è necessario installare questo modulo separatamente perché viene fornito, per impostazione predefinita, insieme alla versione 2.5.x di Python in poi.

Se non lo hai installato sulla tua macchina, puoi usare il comando yum per installarlo come segue:

$yum install python-psycopg2

Per utilizzare il modulo psycopg2, devi prima creare un oggetto Connection che rappresenti il database e poi opzionalmente puoi creare un oggetto cursore che ti aiuterà nell'esecuzione di tutte le istruzioni SQL.

API del modulo Python psycopg2

Le seguenti sono importanti routine del modulo psycopg2, che possono essere sufficienti per lavorare con il database PostgreSQL dal programma Python. Se stai cercando un'applicazione più sofisticata, puoi esaminare la documentazione ufficiale del modulo Python psycopg2.

S. No.	API e descrizione
1	psycopg2.connect(database="testdb", user="postgres", password="cohondob", host="127.0.0.1", port="5432") Questa API apre una connessione al database PostgreSQL. Se il database viene aperto correttamente, restituisce un oggetto di connessione.
2	connection.cursor() Questa routine crea un file cursor che verrà utilizzato durante la programmazione del database con Python.
3	cursor.execute(sql [, optional parameters]) Questa routine esegue un'istruzione SQL. L'istruzione SQL può essere parametrizzata (cioè, segnaposto invece di letterali SQL). Il modulo psycopg2 supporta segnaposto utilizzando il segno% s Ad esempio: cursor.execute ("insert into people values (% s,% s)", (who, age))
4	cursor.executemany(sql, seq_of_parameters) Questa routine esegue un comando SQL su tutte le sequenze di parametri o le mappature trovate nella sequenza sql.
5	cursor.callproc(procname[, parameters]) Questa routine esegue una procedura del database memorizzato con il nome specificato. La sequenza di parametri deve contenere una voce per ogni argomento previsto dalla procedura.
6	cursor.rowcount Questo attributo di sola lettura che restituisce il numero totale di righe del database che sono state modificate, inserite o eliminate dall'ultima esecuzione * ().
7	connection.commit() Questo metodo esegue il commit della transazione corrente. Se non chiami questo metodo, tutto ciò che hai fatto dall'ultima chiamata a commit () non è visibile da altre connessioni al database.
8	connection.rollback() Questo metodo ripristina tutte le modifiche al database dall'ultima chiamata a commit ().
9	connection.close() Questo metodo chiude la connessione al database. Notare che questo non chiama automaticamente commit (). Se chiudi semplicemente la connessione al database senza chiamare prima commit (), le tue modifiche andranno perse!
10	cursor.fetchone() Questo metodo recupera la riga successiva di un set di risultati di query, restituendo una singola sequenza o Nessuno quando non sono disponibili più dati.
11	cursor.fetchmany([size=cursor.arraysize]) Questa routine recupera la serie successiva di righe del risultato di una query, restituendo un elenco. Quando non sono disponibili più righe, viene restituito un elenco vuoto. Il metodo cerca di recuperare tutte le righe indicate dal parametro size.
12	cursor.fetchall() Questa routine recupera tutte le righe (rimanenti) di un risultato di query, restituendo un elenco. Quando non sono disponibili righe, viene restituito un elenco vuoto.

Connessione al database

Il seguente codice Python mostra come connettersi a un database esistente. Se il database non esiste, verrà creato e infine verrà restituito un oggetto database.

#!/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"

Qui puoi anche fornire database testdb come nome e se il database viene aperto correttamente, verrà visualizzato il seguente messaggio:

Open database successfully

Crea una tabella

Il seguente programma Python verrà utilizzato per creare una tabella nel database creato in precedenza:

#!/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()

Quando il programma sopra indicato viene eseguito, creerà la tabella COMPANY nel tuo file test.db e mostrerà i seguenti messaggi -

Opened database successfully
Table created successfully

Operazione INSERT

Il seguente programma Python mostra come possiamo creare record nella nostra tabella AZIENDA creata nell'esempio sopra:

#!/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()

Quando il programma sopra indicato viene eseguito, creerà dati record nella tabella AZIENDA e visualizzerà le seguenti due righe:

Opened database successfully
Records created successfully

Operazione SELECT

Il seguente programma Python mostra come possiamo recuperare e visualizzare i record dalla nostra tabella COMPANY creata nell'esempio precedente:

#!/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()

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Operazione UPDATE

Il seguente codice Python mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

#!/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()

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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

Operazione DELETE

Il seguente codice Python mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

#!/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()

Quando il programma sopra indicato viene eseguito, produrrà il seguente risultato:

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