Come si esegue l'equivalente di Oracle DESCRIBE TABLE
in PostgreSQL (usando il comando psql)?
Come si esegue l'equivalente di Oracle DESCRIBE TABLE
in PostgreSQL (usando il comando psql)?
Risposte:
Prova questo (nello psql
strumento da riga di comando):
\d+ tablename
Vedi il manuale per maggiori informazioni.
+
è davvero frizione, come PostgreSQL 9 dà solo la descrizione approfondita per la vista quando si fanno \d+ table_name
, piuttosto che la semplice\d table_name
psql -E
è utile per ottenere il sql che implementa \d+
e simili (per l'uso al di fuori del prompt di psql)
Oltre al modo PostgreSQL (\ d 'qualcosa' o \ dt 'tabella' o \ ds 'sequenza' e così via)
Il modo standard SQL, come mostrato qui :
select column_name, data_type, character_maximum_length
from INFORMATION_SCHEMA.COLUMNS where table_name = '<name of table>';
È supportato da molti motori db.
\d+
non lo è. Questa è la risposta migliore IMO
Se si desidera ottenerlo dalla query anziché da psql, è possibile eseguire una query sullo schema del catalogo. Ecco una query complessa che lo fa:
SELECT
f.attnum AS number,
f.attname AS name,
f.attnum,
f.attnotnull AS notnull,
pg_catalog.format_type(f.atttypid,f.atttypmod) AS type,
CASE
WHEN p.contype = 'p' THEN 't'
ELSE 'f'
END AS primarykey,
CASE
WHEN p.contype = 'u' THEN 't'
ELSE 'f'
END AS uniquekey,
CASE
WHEN p.contype = 'f' THEN g.relname
END AS foreignkey,
CASE
WHEN p.contype = 'f' THEN p.confkey
END AS foreignkey_fieldnum,
CASE
WHEN p.contype = 'f' THEN g.relname
END AS foreignkey,
CASE
WHEN p.contype = 'f' THEN p.conkey
END AS foreignkey_connnum,
CASE
WHEN f.atthasdef = 't' THEN d.adsrc
END AS default
FROM pg_attribute f
JOIN pg_class c ON c.oid = f.attrelid
JOIN pg_type t ON t.oid = f.atttypid
LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)
LEFT JOIN pg_class AS g ON p.confrelid = g.oid
WHERE c.relkind = 'r'::char
AND n.nspname = '%s' -- Replace with Schema name
AND c.relname = '%s' -- Replace with table name
AND f.attnum > 0 ORDER BY number
;
È piuttosto complesso ma ti mostra la potenza e la flessibilità del catalogo di sistema PostgreSQL e dovrebbe portarti sulla strada verso la padronanza di pg_catalog ;-). Assicurati di modificare le% s nella query. Il primo è Schema e il secondo è il nome della tabella.
format_type()
includerà eventuali modificatori collegati al tipo, ad es numeric(6,2)
. mentre information_schema.columns
riporterà solo il tipo di base di numeric
.
Puoi farlo con un comando slash psql:
\d myTable describe table
Funziona anche con altri oggetti:
\d myView describe view
\d myIndex describe index
\d mySequence describe sequence
Fonte: faqs.org
L'equivalente psql di DESCRIBE TABLE
è \d table
.
Vedere la parte psql del manuale PostgreSQL per maggiori dettagli.
\c databasename
piuttosto che use databasename
(per chi proviene da MySQL come me :-). Senza \c databasename
prima, \d tablename
produce No relations found.
messaggi e niente di più.
Puoi fare degli \d *search pattern *
asterischi per trovare le tabelle che corrispondono al modello di ricerca che ti interessa.
\d *"<SubString>"*
. Cioè, le doppie virgolette devono essere all'interno degli asterischi. Tuttavia, se vuoi solo l' elenco delle tabelle, allora vuoi usare\dt
Oltre alla riga di comando che \d+ <table_name>
hai già trovato, puoi anche utilizzare lo schema delle informazioni per cercare i dati della colonna, usando info_schema.columns
SELECT *
FROM info_schema.columns
WHERE table_schema = 'your_schema'
AND table_name = 'your_table'
FROM info_schema.columns
non ha funzionato per me che ho dovuto usare from information_schema.columns
, non sono sicuro che sia un errore di battitura nella tua risposta o un problema di implementazione da parte mia.
Utilizzare la seguente istruzione SQL
SELECT DATA_TYPE
FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_name = 'tbl_name'
AND COLUMN_NAME = 'col_name'
Se si sostituisce tbl_name e col_name, viene visualizzato il tipo di dati della colonna specifica che si sta cercando.
Questa variazione della query (come spiegato in altre risposte) ha funzionato per me.
SELECT
COLUMN_NAME
FROM
information_schema.COLUMNS
WHERE
TABLE_NAME = 'city';
È descritto qui in dettaglio: http://www.postgresqltutorial.com/postgresql-describe-table/
In MySQL , DESCRIBE table_name
In PostgreSQL , \ d table_name
In alternativa, puoi usare questo comando lungo:
SELECT
a.attname AS Field,
t.typname || '(' || a.atttypmod || ')' AS Type,
CASE WHEN a.attnotnull = 't' THEN 'YES' ELSE 'NO' END AS Null,
CASE WHEN r.contype = 'p' THEN 'PRI' ELSE '' END AS Key,
(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid), '\'(.*)\'')
FROM
pg_catalog.pg_attrdef d
WHERE
d.adrelid = a.attrelid
AND d.adnum = a.attnum
AND a.atthasdef) AS Default,
'' as Extras
FROM
pg_class c
JOIN pg_attribute a ON a.attrelid = c.oid
JOIN pg_type t ON a.atttypid = t.oid
LEFT JOIN pg_catalog.pg_constraint r ON c.oid = r.conrelid
AND r.conname = a.attname
WHERE
c.relname = 'tablename'
AND a.attnum > 0
ORDER BY a.attnum
Per migliorare la query SQL dell'altra risposta (che è eccezionale!), Ecco una query rivista. Include anche nomi di vincoli, informazioni di ereditarietà e tipi di dati suddivisi nelle sue parti costitutive (tipo, lunghezza, precisione, scala). Filtra anche le colonne che sono state eliminate (che esistono ancora nel database).
SELECT
n.nspname as schema,
c.relname as table,
f.attname as column,
f.attnum as column_id,
f.attnotnull as not_null,
f.attislocal not_inherited,
f.attinhcount inheritance_count,
pg_catalog.format_type(f.atttypid,f.atttypmod) AS data_type_full,
t.typname AS data_type_name,
CASE
WHEN f.atttypmod >= 0 AND t.typname <> 'numeric'THEN (f.atttypmod - 4) --first 4 bytes are for storing actual length of data
END AS data_type_length,
CASE
WHEN t.typname = 'numeric' THEN (((f.atttypmod - 4) >> 16) & 65535)
END AS numeric_precision,
CASE
WHEN t.typname = 'numeric' THEN ((f.atttypmod - 4)& 65535 )
END AS numeric_scale,
CASE
WHEN p.contype = 'p' THEN 't'
ELSE 'f'
END AS is_primary_key,
CASE
WHEN p.contype = 'p' THEN p.conname
END AS primary_key_name,
CASE
WHEN p.contype = 'u' THEN 't'
ELSE 'f'
END AS is_unique_key,
CASE
WHEN p.contype = 'u' THEN p.conname
END AS unique_key_name,
CASE
WHEN p.contype = 'f' THEN 't'
ELSE 'f'
END AS is_foreign_key,
CASE
WHEN p.contype = 'f' THEN p.conname
END AS foreignkey_name,
CASE
WHEN p.contype = 'f' THEN p.confkey
END AS foreign_key_columnid,
CASE
WHEN p.contype = 'f' THEN g.relname
END AS foreign_key_table,
CASE
WHEN p.contype = 'f' THEN p.conkey
END AS foreign_key_local_column_id,
CASE
WHEN f.atthasdef = 't' THEN d.adsrc
END AS default_value
FROM pg_attribute f
JOIN pg_class c ON c.oid = f.attrelid
JOIN pg_type t ON t.oid = f.atttypid
LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)
LEFT JOIN pg_class AS g ON p.confrelid = g.oid
WHERE c.relkind = 'r'::char
AND f.attisdropped = false
AND n.nspname = '%s' -- Replace with Schema name
AND c.relname = '%s' -- Replace with table name
AND f.attnum > 0
ORDER BY f.attnum
;
Puoi anche controllare usando la query qui sotto
Select * from schema_name.table_name limit 0;
Expmple: la mia tabella ha 2 colonne nome e pwd. Dare screenshot qui sotto.
* Utilizzo di PG admin3
Use this command
\d table name
like
\d queuerecords
Table "public.queuerecords"
Column | Type | Modifiers
-----------+-----------------------------+-----------
id | uuid | not null
endtime | timestamp without time zone |
payload | text |
queueid | text |
starttime | timestamp without time zone |
status | text |
In postgres \d is used to describe the table structure.
e.g. \d schema_name.table_name;
this command will provide you the basic info of table such as, columns, type and modifiers.
If you want more info about table use
\d+ schema_name.table_name;
this will give you extra info such as, storage, stats target and description
1) PostgreSQL DESCRIBE TABLE usando psql
Nello strumento da riga di comando psql, \ d table_name o \ d + table_name per trovare le informazioni sulle colonne di una tabella
2) PostgreSQL DESCRIBE TABLE usando information_schema
Istruzione SELECT per eseguire query su column_names, tipo di dati, lunghezza massima dei caratteri della tabella delle colonne nel database information_schema;
SELEZIONA COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH da INFORMATION_SCHEMA.COLUMNS dove table_name = 'tablename';
Per maggiori informazioni https://www.postgresqltutorial.com/postgresql-describe-table/
/ dt è il comando che elenca tutte le tabelle presenti in un database. usando il
comando / d e / d + possiamo ottenere i dettagli di una tabella. Il sysntax sarà come
* / d nome_tabella (o) \ d + nome_tabella
Ho elaborato il seguente script per ottenere lo schema della tabella.
'CREATE TABLE ' || 'yourschema.yourtable' || E'\n(\n' ||
array_to_string(
array_agg(
' ' || column_expr
)
, E',\n'
) || E'\n);\n'
from
(
SELECT ' ' || column_name || ' ' || data_type ||
coalesce('(' || character_maximum_length || ')', '') ||
case when is_nullable = 'YES' then ' NULL' else ' NOT NULL' end as column_expr
FROM information_schema.columns
WHERE table_schema || '.' || table_name = 'yourschema.yourtable'
ORDER BY ordinal_position
) column_list;