Estos contenidos se han traducido de forma automática para su comodidad, pero Huawei Cloud no garantiza la exactitud de estos. Para consultar los contenidos originales, acceda a la versión en inglés.

Centro de ayuda/ Data Warehouse Service/ Prácticas recomendadas / Gestión de bases de datos/ Consulta de información de tablas y bases de datos

Actualización más reciente 2026-09-29 GMT+08:00

Ver PDF

Consulta de información de tablas y bases de datos

Consulta de información de tablas

Utilice el catálogo del sistema PG_TABLES para consultar la información de todas las tablas de una base de datos.
1

SELECT * FROM PG_TABLES;
Utilice la vista del sistema DBA_TAB_COLUMNS para consultar las columnas de las tablas, los tipos de datos y los comentarios de todas las tablas de un esquema especificado.
Ejemplo: Consulte la información de todas las columnas de una tabla en un esquema especificado.
1

SELECT * FROM DBA_TAB_COLUMNS WHERE schema = 'public';

Consulta de la estructura de la tabla mediante el comando \d+ de la herramienta gsql.

Ejemplo: Cree una tabla customer_t1 e inserte datos en la tabla.

     CREATE TABLE customer_t1
(
    c_customer_sk             integer,
    c_customer_id             char(5),
    c_first_name              char(6),
    c_last_name               char(8)
)
with (orientation = column,compression=middle)
distribute by hash (c_last_name);
 
 
  

     INSERT INTO customer_t1 (c_customer_sk, c_customer_id, c_first_name) VALUES
    (6885, 'map', 'Peter'),
    (4321, 'river', 'Lily'),
    (9527, 'world', 'James');

Consulte la estructura de la tabla. Si no se especifica ningún esquema al crear una tabla, el esquema de la tabla es public por defecto.

     \d+ customer_t1;
                          Table "public.customer_t1"
    Column     |     Type     | Modifiers | Storage  | Stats target | Description
---------------+--------------+-----------+----------+--------------+-------------
 c_customer_sk | integer      |           | plain    |              |
 c_customer_id | character(5) |           | extended |              |
 c_first_name  | character(6) |           | extended |              |
 c_last_name   | character(8) |           | extended |              |
Has OIDs: no
Distribute By: HASH(c_last_name)
Location Nodes: ALL DATANODES
Options: orientation=column, compression=middle, colversion=2.0, enable_delta=false
 
 
  

Las opciones pueden variar en diferentes versiones, pero la diferencia no afecta a los servicios. Las opciones aquí son solo para referencia. Las opciones reales están sujetas a la versión.

Utilice pg_get_tabledef para consultar la definición de la tabla.

     SELECT * FROM PG_GET_TABLEDEF('customer_t1');
                                  pg_get_tabledef                                  
-----------------------------------------------------------------------------------
 SET search_path = tpchobs;                                                       +
 CREATE  TABLE customer_t1 (                                                      +
         c_customer_sk integer,                                                   +
         c_customer_id character(5),                                              +
         c_first_name character(6),                                               +
         c_last_name character(8)                                                 +
 )                                                                                +
 WITH (orientation=column, compression=middle, colversion=2.0, enable_delta=false)+
 DISTRIBUTE BY HASH(c_last_name)                                                  +
 TO GROUP group_version1;
(1 row)
 
 
  

Consulta de todos los datos en customer_t1

     SELECT * FROM customer_t1;
 c_customer_sk | c_customer_id | c_first_name | c_last_name
---------------+---------------+--------------+-------------
          6885 | map           | Peter        |
          4321 | river         | Lily         |
          9527 | world         | James        |
(3 rows)
 
 
  

Consulta de todos los datos de una columna en customer_t1 mediante SELECT

     SELECT c_customer_sk FROM customer_t1;
 c_customer_sk
---------------
          6885
          4321
          9527
(3 rows)
 
 
  

Verifique si se ha analizado una tabla. Se devolverá la hora en que se analizó la tabla. Si no se devuelve nada, significa que la tabla no se ha analizado.

     SELECT pg_stat_get_last_analyze_time(oid),relname FROM pg_class where relkind='r';

Consulte la hora en que se analizó la tabla public.

     SELECT pg_stat_get_last_analyze_time(c.oid),c.relname FROM pg_class c LEFT JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relkind='r' AND n.nspname='public';
 pg_stat_get_last_analyze_time |       relname
-------------------------------+----------------------
 2022-05-17 07:48:26.923782+00 | warehouse_t19
 2022-05-17 07:48:26.964512+00 | emp
 2022-05-17 07:48:27.016709+00 | test_trigger_src_tbl
 2022-05-17 07:48:27.045385+00 | customer
 2022-05-17 07:48:27.062486+00 | warehouse_t1
 2022-05-17 07:48:27.114884+00 | customer_t1
 2022-05-17 07:48:27.172256+00 | product_info_input
 2022-05-17 07:48:27.197014+00 | tt1
 2022-05-17 07:48:27.212906+00 | timezone_test
(9 rows)
 
 
  

Consulte rápidamente la información de las columnas de una tabla. Si una vista de information_schema tiene una gran cantidad de objetos en la base de datos, se tardará mucho tiempo en devolver el resultado. Puede ejecutar la siguiente sentencia SQL para consultar rápidamente la información de las columnas de una o más tablas:

     SELECT /*+ set (enable_hashjoin off) */T.table_schema AS tableschema,
	T.TABLE_NAME AS tablename,
	T.dtd_identifier AS srcAttrId,
	COLUMN_NAME AS fieldName,
	'N' AS isPrimaryKey,
	nvl ( nvl ( T.character_maximum_length, T.numeric_precision ), 0 ) AS fieldLength,
	T.udt_name AS fieldType 
from (	
 SELECT  /*+ indexscan(co) indexscan(nco) indexscan(a) indexscan(t) leading((nc c a)) leading((co nco)) indexscan(bt) indexscan(nt) */
    nc.nspname AS table_schema,
    c.relname AS table_name,
    a.attname AS column_name,
    information_schema._pg_char_max_length(information_schema._pg_truetypid(a.*, t.*), information_schema._pg_truetypmod(a.*, t.*))::information_schema.cardinal_number AS character_maximum_length,
    information_schema._pg_numeric_precision(information_schema._pg_truetypid(a.*, t.*), information_schema._pg_truetypmod(a.*, t.*))::information_schema.cardinal_number AS numeric_precision,
    COALESCE(bt.typname, t.typname)::information_schema.sql_identifier AS udt_name,
    a.attnum AS dtd_identifier
   FROM pg_attribute a
   LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
   JOIN (pg_class c
   JOIN pg_namespace nc ON c.relnamespace = nc.oid) ON a.attrelid = c.oid
   JOIN (pg_type t
   JOIN pg_namespace nt ON t.typnamespace = nt.oid) ON a.atttypid = t.oid
   LEFT JOIN (pg_type bt
   JOIN pg_namespace nbt ON bt.typnamespace = nbt.oid) ON t.typtype = 'd'::"char" AND t.typbasetype = bt.oid
   LEFT JOIN (pg_collation co
   JOIN pg_namespace nco ON co.collnamespace = nco.oid) ON a.attcollation = co.oid AND (nco.nspname <> 'pg_catalog'::name OR co.collname <> 'default'::name)
  WHERE NOT pg_is_other_temp_schema(nc.oid) AND a.attnum > 0 AND NOT a.attisdropped AND (c.relkind = ANY (ARRAY['r'::"char", 'v'::"char", 'f'::"char"])) AND (pg_has_role(c.relowner, 'USAGE'::text) OR has_column_privilege(c.oid, a.attnum, 'SELECT, INSERT, UPDATE, REFERENCES'::text))

) t
WHERE
	1 = 1 
	AND UPPER ( T.TABLE_NAME ) <> 'DIS_USER_DATARIGHT_IF_SPLIT_T' 
	AND UPPER ( T.TABLE_NAME ) NOT LIKE'DIS_TMP_%' 
	AND UPPER ( T.COLUMN_NAME ) <> '_DISAPP_AUTO_ID_' 
	AND (  ( T.TABLE_NAME ),  ( T.table_schema ) ) IN ( ( lower ( 'table_name' )::name, lower ( 'schema_name' )::name ) );
 
 
  

Consulte rápidamente la información de las columnas de la tabla promotion.

     SELECT /*+ set (enable_hashjoin off) */T.table_schema AS tableschema,
	T.TABLE_NAME AS tablename,
	T.dtd_identifier AS srcAttrId,
	COLUMN_NAME AS fieldName,
	'N' AS isPrimaryKey,
	nvl ( nvl ( T.character_maximum_length, T.numeric_precision ), 0 ) AS fieldLength,
	T.udt_name AS fieldType 
from (	
 SELECT  /*+ indexscan(co) indexscan(nco) indexscan(a) indexscan(t) leading((nc c a)) leading((co nco)) indexscan(bt) indexscan(nt) */
    nc.nspname AS table_schema,
    c.relname AS table_name,
    a.attname AS column_name,
    information_schema._pg_char_max_length(information_schema._pg_truetypid(a.*, t.*), information_schema._pg_truetypmod(a.*, t.*))::information_schema.cardinal_number AS character_maximum_length,
    information_schema._pg_numeric_precision(information_schema._pg_truetypid(a.*, t.*), information_schema._pg_truetypmod(a.*, t.*))::information_schema.cardinal_number AS numeric_precision,
    COALESCE(bt.typname, t.typname)::information_schema.sql_identifier AS udt_name,
    a.attnum AS dtd_identifier
   FROM pg_attribute a
   LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
   JOIN (pg_class c
   JOIN pg_namespace nc ON c.relnamespace = nc.oid) ON a.attrelid = c.oid
   JOIN (pg_type t
   JOIN pg_namespace nt ON t.typnamespace = nt.oid) ON a.atttypid = t.oid
   LEFT JOIN (pg_type bt
   JOIN pg_namespace nbt ON bt.typnamespace = nbt.oid) ON t.typtype = 'd'::"char" AND t.typbasetype = bt.oid
   LEFT JOIN (pg_collation co
   JOIN pg_namespace nco ON co.collnamespace = nco.oid) ON a.attcollation = co.oid AND (nco.nspname <> 'pg_catalog'::name OR co.collname <> 'default'::name)
  WHERE NOT pg_is_other_temp_schema(nc.oid) AND a.attnum > 0 AND NOT a.attisdropped AND (c.relkind = ANY (ARRAY['r'::"char", 'v'::"char", 'f'::"char"])) AND (pg_has_role(c.relowner, 'USAGE'::text) OR has_column_privilege(c.oid, a.attnum, 'SELECT, INSERT, UPDATE, REFERENCES'::text))

) t
WHERE
	1 = 1 
	AND UPPER ( T.TABLE_NAME ) <> 'DIS_USER_DATARIGHT_IF_SPLIT_T' 
	AND UPPER ( T.TABLE_NAME ) NOT LIKE'DIS_TMP_%' 
	AND UPPER ( T.COLUMN_NAME ) <> '_DISAPP_AUTO_ID_' 
	AND (  ( T.TABLE_NAME ),  ( T.table_schema ) ) IN ( ( lower ( 'promotion' )::name, lower ( 'public' )::name ) );
 
 
  

Obtenga la definición de la tabla consultando los registros de auditoría.

Utilice la función pgxc_query_audit para consultar los registros de auditoría de todos los CN. La sintaxis es la siguiente:

     pgxc_query_audit(timestamptz startime,timestamptz endtime)

Consulte los registros de auditoría de varios objetos.

     SET audit_object_name_format TO 'all';
SELECT object_name,result,operation_type,command_text FROM pgxc_query_audit('2024-05-26 8:00:00','2024-05-26 22:55:00') where command_text like '%student%';

Consulta de la clave de distribución de una tabla

Utilice la función PG_GET_TABLEDEF para consultar la clave de distribución de una tabla (por ejemplo, customer_t1). En la salida del comando, HASH(c_last_name) indica que el modo de distribución de la tabla es HASH y la clave de distribución es c_last_name.

     SELECT * FROM PG_GET_TABLEDEF('customer_t1');
                                  pg_get_tabledef                                  
-----------------------------------------------------------------------------------
 SET search_path = tpchobs;                                                       +
 CREATE  TABLE customer_t1 (                                                      +
         c_customer_sk integer,                                                   +
         c_customer_id character(5),                                              +
         c_first_name character(6),                                               +
         c_last_name character(8)                                                 +
 )                                                                                +
 WITH (orientation=column, compression=middle, colversion=2.0, enable_delta=false)+
 DISTRIBUTE BY HASH(c_last_name)                                                  +
 TO GROUP group_version1;
(1 row)
 
 
  

Utilice la siguiente sentencia SQL para consultar el modo de distribución y la clave de distribución de varias tablas por lotes. Reemplace dbadmin al final de la sentencia con el propietario real de la tabla. El siguiente ejemplo muestra cómo consultar el modo de distribución y la clave de distribución de todas las tablas creadas por dbadmin.

distribute_type indica el modo de distribución, por ejemplo, HASH. distributekey indica la clave de distribución, por ejemplo, ca_address_sk.

     SELECT pg_catalog.pg_get_userbyid(pc.relowner) AS tableowner,
 pn.nspname AS schemaname,
 pc.relname AS tablename,
 CASE pxc.pclocatortype WHEN 'N' THEN
 'ROUND ROBIN' WHEN 'R' THEN
 'REPLICATION' WHEN 'H' THEN
 'HASH' WHEN 'M' THEN
 'MODULO' END AS distribute_type,
 pc.relkind,
 getdistributekey(pxc.pcrelid) AS distributekey,
 pc.reloptions
 FROM pgxc_class pxc, pg_class pc,pg_namespace pn
 WHERE pxc.pcrelid = pc.oid AND pn.oid=pc.relnamespace AND tableowner='dbadmin';
 
 
  

haga clic para agrandar

Consulta del tamaño de la tabla

A continuación se enumeran algunos métodos comunes para consultar el tamaño de la tabla. Para obtener más prácticas sobre cómo consultar el tamaño de las tablas, consulte Consulta del tamaño de la tabla.

Consulta del tamaño total de una tabla (incluidos los índices y los datos)

     SELECT pg_size_pretty(pg_total_relation_size('<schemaname>.<tablename>'));

Ejemplo:

Primero, cree un índice en customer_t1.

     CREATE INDEX index1 ON customer_t1 USING btree(c_customer_sk);

A continuación, consulte el tamaño de la tabla customer_t1 de public.

     SELECT pg_size_pretty(pg_total_relation_size('public.customer_t1'));
 pg_size_pretty
----------------
 264 kB
(1 row)
 
 
  

Consulta del tamaño de una tabla (excluidos los índices)

     SELECT pg_size_pretty(pg_relation_size('<schemaname>.<tablename>'));

Ejemplo: Consulte el tamaño de la tabla customer_t1 de public.

     SELECT pg_size_pretty(pg_relation_size('public.customer_t1'));
 pg_size_pretty
----------------
 208 kB
(1 row)
 
 
  

Utilice la función pg_foreign_table_size para consultar el tamaño total de la tabla externa y devolver el resultado. La unidad es byte. Esta función solo está disponible para clústeres de la versión 9.1.1.100 o posterior.
La tabla foránea solo puede ser dfs_fdw o hdfs_fdw.
1 2 3 4 5

SELECT * FROM pg_foreign_table_size('public','customer_address2'); pg_foreign_table_size ----------------------- 1439489 (1 row)

Consulte todas las tablas, clasificadas por su espacio ocupado.

     SELECT table_schema || '.' || table_name AS table_full_name, pg_size_pretty(pg_total_relation_size('"' || table_schema || '"."' || table_name || '"')) AS size FROM information_schema.tables
ORDER BY
pg_total_relation_size('"' || table_schema || '"."' || table_name || '"') DESC limit xx;

Ejemplo 1: Consultar las 15 tablas que ocupan más espacio.

     SELECT table_schema || '.' || table_name AS table_full_name, pg_size_pretty(pg_total_relation_size('"' || table_schema || '"."' || table_name || '"')) AS size FROM information_schema.tables
ORDER BY
pg_total_relation_size('"' || table_schema || '"."' || table_name || '"') DESC limit 15;
      table_full_name      |  size
---------------------------+---------
 pg_catalog.pg_attribute   | 2048 KB
 pg_catalog.pg_rewrite     | 1888 KB
 pg_catalog.pg_depend      | 1464 KB
 pg_catalog.pg_proc        | 1464 KB
 pg_catalog.pg_class       | 512 KB
 pg_catalog.pg_description | 504 KB
 pg_catalog.pg_collation   | 360 KB
 pg_catalog.pg_statistic   | 352 KB
 pg_catalog.pg_type        | 344 KB
 pg_catalog.pg_operator    | 224 KB
 pg_catalog.pg_amop        | 208 KB
 public.tt1                | 160 KB
 pg_catalog.pg_amproc      | 120 KB
 pg_catalog.pg_index       | 120 KB
 pg_catalog.pg_constraint  | 112 KB
(15 rows)
 
 
  

Ejemplo 2: Consultar las 20 tablas principales con el mayor uso de espacio en el esquema public.

     SELECT table_schema || '.' || table_name AS table_full_name, pg_size_pretty(pg_total_relation_size('"' || table_schema || '"."' || table_name || '"')) AS size FROM information_schema.tables where table_schema='public'
ORDER BY
pg_total_relation_size('"' || table_schema || '"."' || table_name || '"') DESC limit 20;
       table_full_name       |  size
-----------------------------+---------
 public.tt1                  | 160 KB
 public.product_info_input   | 112 KB
 public.customer_t1          | 96 KB
 public.warehouse_t19        | 48 KB
 public.emp                  | 32 KB
 public.customer             | 0 bytes
 public.test_trigger_src_tbl | 0 bytes
 public.warehouse_t1         | 0 bytes
(8 rows)
 
 
  

Consulta rápida del espacio ocupado por todas las tablas de la base de datos

En un clúster grande (8.1.3 o posterior) con una gran cantidad de datos (más de 1000 tablas), se recomienda utilizar la vista pgxc_wlm_table_distribution_skewness para consultar todas las tablas de la base de datos. Esta vista se puede utilizar para consultar el uso del tablespace y el sesgo de datos en la base de datos. La unidad de total_size y avg_size es byte.

     SELECT *, pg_size_pretty(total_size) as tableSize FROM pgxc_wlm_table_distribution_skewness ORDER BY total_size desc;
    schema_name     |                    table_name                     | total_size | avg_size  | max_percent | min_percent | skew_percent | tablesize 
--------------------+---------------------------------------------------+------------+-----------+-------------+-------------+--------------+-----------
 public             | history_tbs_test_row_1                            |  804347904 | 134057984 |       18.02 |       15.63 |         7.53 | 767 MB
 public             | history_tbs_test_row_3                            |  402096128 |  67016021 |       18.30 |       15.60 |         8.90 | 383 MB
 public             | history_tbs_test_row_2                            |  401743872 |  66957312 |       18.01 |       15.01 |         7.47 | 383 MB
 public             | i_history_tbs_test_1                              |  325263360 |  54210560 |       17.90 |       15.50 |         6.90 | 310 MB
 
 
  

El resultado de la consulta muestra que la tabla history_tbs_test_row_1 ocupa el espacio más grande y se produce un sesgo de datos.

La vista pgxc_wlm_table_distribution_skewness solo se puede consultar cuando el parámetro GUC use_workload_manager and enable_perm_space está habilitado. En versiones anteriores, se recomienda utilizar la función table_distribution() para consultar toda la base de datos. Si solo se consulta el tamaño de una tabla, se recomienda la función table_distribution(schemaname text, tablename text).
En las versiones de clúster 8.2.1 y posteriores, DWS admite la vista pgxc_wlm_table_distribution_skewness, que se puede utilizar directamente para consultas.
En la versión de clúster 8.1.3, puede utilizar la siguiente definición para crear una vista y, a continuación, realizar una consulta:

     CREATE OR REPLACE VIEW
pgxc_wlm_table_distribution_skewness AS
WITH skew AS
(
SELECT
schemaname,
tablename,
pg_catalog.sum(dnsize)
AS totalsize,
pg_catalog.avg(dnsize)
AS avgsize,
pg_catalog.max(dnsize)
AS maxsize,
pg_catalog.min(dnsize)
AS minsize,
(maxsize
- avgsize) * 100 AS skewsize
FROM
pg_catalog.gs_table_distribution()
GROUP
BY schemaname, tablename
)
SELECT
    schemaname AS schema_name,
    tablename AS table_name,
    totalsize AS total_size,
    avgsize::numeric(1000) AS avg_size,
    (
        CASE
            WHEN totalsize = 0 THEN 0.00
            ELSE (maxsize * 100 /
totalsize)::numeric(5, 2)
        END
    ) AS max_percent,
    (
        CASE
            WHEN totalsize = 0 THEN 0.00
            ELSE (minsize * 100 /
totalsize)::numeric(5, 2)
        END
    ) AS min_percent,
    (
        CASE
            WHEN totalsize = 0 THEN 0.00
            ELSE (skewsize /
maxsize)::numeric(5, 2)
        END
    ) AS skew_percent
FROM skew;
 
 
  

Consulta de información de base de datos

Consulta de la lista de bases de datos mediante el meta-comando \l de la herramienta gsql.

     \l
                          List of databases
   Name    | Owner | Encoding  | Collate | Ctype | Access privileges
-----------+-------+-----------+---------+-------+-------------------
 gaussdb   | Ruby  | SQL_ASCII | C       | C     |
 template0 | Ruby  | SQL_ASCII | C       | C     | =c/Ruby           +
           |       |           |         |       | Ruby=CTc/Ruby
 template1 | Ruby  | SQL_ASCII | C       | C     | =c/Ruby           +
           |       |           |         |       | Ruby=CTc/Ruby
(3 rows)
 
 
  

Si los parámetros LC_COLLATE y LC_CTYPE no se especifican durante la instalación de la base de datos, los valores predeterminados de ellos son C.
Si LC_COLLATE y LC_CTYPE no se especifican durante la creación de la base de datos, el orden de clasificación y la categorización de caracteres de la base de datos de plantilla se utilizan de forma predeterminada.
Para obtener más información, consulte CREATE DATABASE.

Consulta de la lista de bases de datos mediante el catálogo del sistema pg_database

     SELECT datname FROM pg_database;
  datname
-----------
 template1
 template0
 gaussdb
(3 rows)
 
 
  

Consulta del tamaño de la base de datos

     select datname,pg_size_pretty(pg_database_size(datname)) from pg_database;

Ejemplo:

     select datname,pg_size_pretty(pg_database_size(datname)) from pg_database;
  datname  | pg_size_pretty
-----------+----------------
 template1 | 61 MB
 template0 | 61 MB
 postgres  | 320 MB
(3 rows)
 
 
  

Consulta del tamaño de una tabla y del tamaño del índice correspondiente en un esquema especificado

     SELECT
    t.tablename,
    indexname,
    c.reltuples AS num_rows,
    pg_size_pretty(pg_relation_size(quote_ident(t.tablename)::text)) AS table_size,
    pg_size_pretty(pg_relation_size(quote_ident(indexrelname)::text)) AS index_size,
    CASE WHEN indisunique THEN 'Y'
       ELSE 'N'
    END AS UNIQUE,
    idx_scan AS number_of_scans,
    idx_tup_read AS tuples_read,
    idx_tup_fetch AS tuples_fetched
FROM pg_tables t
LEFT OUTER JOIN pg_class c ON t.tablename=c.relname
LEFT OUTER JOIN
    ( SELECT c.relname AS ctablename, ipg.relname AS indexname, x.indnatts AS number_of_columns, idx_scan, idx_tup_read, idx_tup_fetch, indexrelname, indisunique FROM pg_index x
           JOIN pg_class c ON c.oid = x.indrelid
           JOIN pg_class ipg ON ipg.oid = x.indexrelid
           JOIN pg_stat_all_indexes psai ON x.indexrelid = psai.indexrelid )
    AS foo
    ON t.tablename = foo.ctablename
WHERE t.schemaname='public'
ORDER BY 1,2;
 
 
  

Tema principal: Gestión de bases de datos

Tema anterior: Prácticas recomendadas para la gestión de usuarios

Tema siguiente: Consulta del tamaño de la tabla