> ## Documentation Index
> Fetch the complete documentation index at: https://docs.risingwave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# DESCRIBE

> Use the `DESCRIBE` command to check the information or execution fragments of a relation (table, source, sink, view, materialized view).

## Syntax

<Note>
  Added in v2.4.0: `DESCRIBE FRAGMENTS`.
</Note>

```sql theme={null}
DESCRIBE relation_name;
DESCRIBE FRAGMENTS relation_name;
```

| Parameter        | Description                                                                      |
| :--------------- | :------------------------------------------------------------------------------- |
| *relation\_name* | The table, source, sink, view or materialized view whose columns will be listed. |

### `DESCRIBE`

This command shows the columns, primary key, distribution key, indexes, and description (comment) of a specified table, source, sink, view, or materialized view.

<Tip>
  `DESCRIBE <relation_name>` is similar to [`SHOW COLUMNS FROM <relation_name>`](/sql/commands/sql-show-columns), but `DESCRIBE` also provides information about indexes and table/column comments.
</Tip>

```sql Examples theme={null}
-- Set up a table with columns, primary key, index, and comments
CREATE TABLE customers (
  customer_id BIGINT PRIMARY KEY,
  name VARCHAR,
  email VARCHAR
);
COMMENT ON COLUMN customers.customer_id IS 'Unique identifier for each customer';
COMMENT ON COLUMN customers.name IS 'Name of the customer';
COMMENT ON COLUMN customers.email IS 'Email address of the customer';
COMMENT ON TABLE customers IS 'All customer records';
CREATE INDEX idx_customers_email ON customers(email);

-- Describe the table
DESCRIBE customers;
```

**Output:**

```bash theme={null}
| Name                | Type                                                                  | Is Hidden | Description                         |
| :------------------ | :-------------------------------------------------------------------- | :-------- | :---------------------------------- |
| customer_id         | bigint                                                                | false     | Unique identifier for each customer |
| name                | character varying                                                     | false     | Name of the customer                |
| email               | character varying                                                     | false     | Email address of the customer       |
| primary key         | customer_id                                                           |           |                                     |
| distribution key    | customer_id                                                           |           |                                     |
| idx_customers_email | index(email ASC, customer_id ASC) include(name) distributed by(email) |           |                                     |
| table description   | customers                                                             |           | All customer records                |
```

### `DESCRIBE FRAGMENTS`

This command shows the distributed execution fragments of the job associated with the specified relation (e.g., a materialized view, table, or source).
It helps in understanding the job's physical structure, parallelism, and data flow, which is useful for debugging and optimization.

```sql Examples theme={null}
CREATE TABLE customers (
  customer_id BIGINT PRIMARY KEY,
  name VARCHAR,
  email VARCHAR
);
CREATE TABLE orders (
  order_id BIGINT PRIMARY KEY,
  customer_id BIGINT,
  order_date DATE
);
CREATE MATERIALIZED VIEW mv AS
SELECT name, email, count(*) FROM
orders JOIN customers ON orders.customer_id = customers.customer_id
GROUP BY name, email;

DESCRIBE FRAGMENTS mv;
```

**Sample Output:**

```
Fragment 12 (Actor 50,51,52,53)                                                                                                
StreamMaterialize { columns: [name, email, count], stream_key: [name, email], pk_columns: [name, email], pk_conflict: NoCheck }
├── output: [ customers.name, customers.email, count ]                                                                         
├── stream key: [ customers.name, customers.email ]                                                                            
└── StreamHashAgg { group_key: [customers.name, customers.email], aggs: [count] }                                              
    ├── output: [ customers.name, customers.email, count ]                                                                     
    ├── stream key: [ customers.name, customers.email ]                                                                        
    └── MergeExecutor                                                                                                          
        ├── output: [ customers.name, customers.email, orders.order_id, orders.customer_id, customers.customer_id ]            
        └── stream key: [ orders.order_id, orders.customer_id ]                                                                
                                                                                                                            
Fragment 13 (Actor 54,55,56,57)                                                                                                
StreamHashJoin { type: Inner, predicate: orders.customer_id = customers.customer_id }                                          
├── output: [ customers.name, customers.email, orders.order_id, orders.customer_id, customers.customer_id ]                    
├── stream key: [ orders.order_id, orders.customer_id ]                                                                        
├── MergeExecutor { output: [ orders.customer_id, orders.order_id ], stream key: [ orders.order_id ] }                         
└── MergeExecutor { output: [ customers.customer_id, customers.name, customers.email ], stream key: [ customers.customer_id ] }
                                                                                                                            
Fragment 14 (Actor 58,59,60,61)                                                                                                
StreamTableScan { table: orders, columns: [customer_id, order_id] }                                                            
├── output: [ orders.customer_id, orders.order_id ]                                                                            
├── stream key: [ orders.order_id ]                                                                                            
├── Upstream { output: [ customer_id, order_id ], stream key: [] }                                                             
└── BatchPlanNode { output: [ customer_id, order_id ], stream key: [] }                                                        
                                                                                                                            
Fragment 15 (Actor 62,63,64,65)                                                                                                
StreamTableScan { table: customers, columns: [customer_id, name, email] }                                                      
```

The output has a similar format like [`EXPLAIN (DISTSQL)`](/sql/commands/sql-explain), but `DESCRIBE FRAGMENTS` operates on an existing job rather than a new statement being planned.

To check the runtime performance of each operator, use [`EXPLAIN ANALYZE`](/sql/commands/sql-explain-analyze).