Package org.postgresql.jdbc

# Class PgResultSetMetaData

java.lang.Object
org.postgresql.jdbc.PgResultSetMetaData

All Implemented Interfaces:
  `ResultSetMetaData`, `Wrapper`, `PGResultSetMetaData`

public class PgResultSetMetaData extends Object implements ResultSetMetaData, PGResultSetMetaData

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final BaseConnection`
`connection`
`protected final Field[]`
`fields`

### Fields inherited from interface java.sql.ResultSetMetaData

`columnNoNulls, columnNullable, columnNullableUnknown`

## Constructor Summary

Constructors
Constructor
Description
`PgResultSetMetaData(BaseConnection connection, Field[] fields)`
Initialise for a result with a tuple set and a field descriptor set

## Method Summary

Modifier and Type
Method
Description
`String`
`getBaseColumnName(int column)`
Returns the underlying column name of a query result, or "" if it is unable to be determined.
`String`
`getBaseSchemaName(int column)`
Returns the underlying schema name of query result, or "" if it is unable to be determined.
`String`
`getBaseTableName(int column)`
Returns the underlying table name of query result, or "" if it is unable to be determined.
`String`
`getCatalogName(int column)`
`String`
`getColumnClassName(int column)`
`int`
`getColumnCount()`
`int`
`getColumnDisplaySize(int column)`
`String`
`getColumnLabel(int column)`
`String`
`getColumnName(int column)`
`int`
`getColumnType(int column)`
`String`
`getColumnTypeName(int column)`
`protected Field`
`getField(int columnIndex)`
For several routines in this package, we need to convert a columnIndex into a Field[] descriptor.
`int`
`getFormat(int column)`
Is a column Text or Binary?
`protected @Nullable String`
`getPGType(int columnIndex)`
`int`
`getPrecision(int column)`
`int`
`getScale(int column)`
`String`
`getSchemaName(int column)`
`protected int`
`getSQLType(int columnIndex)`
`String`
`getTableName(int column)`
`boolean`
`isAutoIncrement(int column)`
`boolean`
`isCaseSensitive(int column)`
`boolean`
`isCurrency(int column)`
`boolean`
`isDefinitelyWritable(int column)`
`int`
`isNullable(int column)`
`boolean`
`isReadOnly(int column)`
`boolean`
`isSearchable(int column)`
`boolean`
`isSigned(int column)`
`boolean`
`isWrapperFor(Class<?> iface)`
`boolean`
`isWritable(int column)`
`<T> T`
`unwrap(Class<T> iface)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### connection

protected final BaseConnection connection

### fields

protected final Field[] fields

## Constructor Details

### PgResultSetMetaData

public PgResultSetMetaData(BaseConnection connection, Field[] fields)
Initialise for a result with a tuple set and a field descriptor set

Parameters:
  `connection` - the connection to retrieve metadata
  `fields` - the array of field descriptors

## Method Details

### getColumnCount

public int getColumnCount() throws SQLException

Specified by:
  `getColumnCount` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### isAutoIncrement

public boolean isAutoIncrement(int column) throws SQLException

It is believed that PostgreSQL does not support this feature.

Specified by:
  `isAutoIncrement` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

### isCaseSensitive

public boolean isCaseSensitive(int column) throws SQLException

Does a column's case matter? ASSUMPTION: Any field that is not obviously case insensitive is assumed to be case sensitive

Specified by:
  `isCaseSensitive` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

### isSearchable

public boolean isSearchable(int column) throws SQLException

Can the column be used in a WHERE clause? Basically for this, I split the functions into two types: recognised types (which are always useable), and OTHER types (which may or may not be useable). The OTHER types, for now, I will assume they are useable. We should really query the catalog to see if they are useable.

Specified by:
  `isSearchable` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  true if they can be used in a WHERE clause
Throws:
  `SQLException` - if a database access error occurs

### isCurrency

public boolean isCurrency(int column) throws SQLException

Is the column a cash value? 6.1 introduced the cash/money type, which haven't been incorporated as of 970414, so I just check the type name for both 'cash' and 'money'

Specified by:
  `isCurrency` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  true if its a cash column
Throws:
  `SQLException` - if a database access error occurs

### isNullable

public int isNullable(int column) throws SQLException

Specified by:
  `isNullable` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### isSigned

public boolean isSigned(int column) throws SQLException

Is the column a signed number? In PostgreSQL, all numbers are signed, so this is trivial. However, strings are not signed (duh!)

Specified by:
  `isSigned` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

### getColumnDisplaySize

public int getColumnDisplaySize(int column) throws SQLException

Specified by:
  `getColumnDisplaySize` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getColumnLabel

public String getColumnLabel(int column) throws SQLException

Specified by:
  `getColumnLabel` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getColumnName

public String getColumnName(int column) throws SQLException

Specified by:
  `getColumnName` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getBaseColumnName

public String getBaseColumnName(int column) throws SQLException
Description copied from interface: `PGResultSetMetaData`
Returns the underlying column name of a query result, or "" if it is unable to be determined.

Specified by:
  `getBaseColumnName` in interface `PGResultSetMetaData`
Parameters:
  `column` - column position (1-based)
Returns:
  underlying column name of a query result
Throws:
  `SQLException` - if something wrong happens

### getSchemaName

public String getSchemaName(int column) throws SQLException

Specified by:
  `getSchemaName` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getBaseSchemaName

public String getBaseSchemaName(int column) throws SQLException
Description copied from interface: `PGResultSetMetaData`
Returns the underlying schema name of query result, or "" if it is unable to be determined.

Specified by:
  `getBaseSchemaName` in interface `PGResultSetMetaData`
Parameters:
  `column` - column position (1-based)
Returns:
  underlying schema name of query result
Throws:
  `SQLException` - if something wrong happens

### getPrecision

public int getPrecision(int column) throws SQLException

Specified by:
  `getPrecision` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getScale

public int getScale(int column) throws SQLException

Specified by:
  `getScale` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getTableName

public String getTableName(int column) throws SQLException

Specified by:
  `getTableName` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getBaseTableName

public String getBaseTableName(int column) throws SQLException
Description copied from interface: `PGResultSetMetaData`
Returns the underlying table name of query result, or "" if it is unable to be determined.

Specified by:
  `getBaseTableName` in interface `PGResultSetMetaData`
Parameters:
  `column` - column position (1-based)
Returns:
  underlying table name of query result
Throws:
  `SQLException` - if something wrong happens

### getCatalogName

public String getCatalogName(int column) throws SQLException

As with getSchemaName(), we can say that if getTableName() returns n/a, then we can too - otherwise, we need to work on it.

Specified by:
  `getCatalogName` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2...
Returns:
  catalog name, or "" if not applicable
Throws:
  `SQLException` - if a database access error occurs

### getColumnType

public int getColumnType(int column) throws SQLException

Specified by:
  `getColumnType` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### getFormat

public int getFormat(int column) throws SQLException
Description copied from interface: `PGResultSetMetaData`
Is a column Text or Binary?

Specified by:
  `getFormat` in interface `PGResultSetMetaData`
Parameters:
  `column` - column position (1-based)
Returns:
  0 if column data format is TEXT, or 1 if BINARY
Throws:
  `SQLException` - if something wrong happens
See Also:
  - `Field.BINARY_FORMAT`
  - `Field.TEXT_FORMAT`

### getColumnTypeName

public String getColumnTypeName(int column) throws SQLException

Specified by:
  `getColumnTypeName` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### isReadOnly

public boolean isReadOnly(int column) throws SQLException

In reality, we would have to check the GRANT/REVOKE stuff for this to be effective, and I haven't really looked into that yet, so this will get re-visited.

Specified by:
  `isReadOnly` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2, etc.*
Returns:
  true if so*
Throws:
  `SQLException` - if a database access error occurs

### isWritable

public boolean isWritable(int column) throws SQLException

In reality have to check the GRANT/REVOKE stuff, which I haven't worked with as yet. However, if it isn't ReadOnly, then it is obviously writable.

Specified by:
  `isWritable` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2, etc.
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

### isDefinitelyWritable

public boolean isDefinitelyWritable(int column) throws SQLException

Hmmm...this is a bad one, since the two preceding functions have not been really defined. I cannot tell is the short answer. I thus return isWritable() just to give us an idea.

Specified by:
  `isDefinitelyWritable` in interface `ResultSetMetaData`
Parameters:
  `column` - the first column is 1, the second is 2, etc..
Returns:
  true if so
Throws:
  `SQLException` - if a database access error occurs

### getField

protected Field getField(int columnIndex) throws SQLException
For several routines in this package, we need to convert a columnIndex into a Field[] descriptor. Rather than do the same code several times, here it is.

Parameters:
  `columnIndex` - the first column is 1, the second is 2...
Returns:
  the Field description
Throws:
  `SQLException` - if a database access error occurs

### getPGType

protected @Nullable String getPGType(int columnIndex) throws SQLException

Throws:
  `SQLException`

### getSQLType

protected int getSQLType(int columnIndex) throws SQLException

Throws:
  `SQLException`

### getColumnClassName

public String getColumnClassName(int column) throws SQLException

Specified by:
  `getColumnClassName` in interface `ResultSetMetaData`
Throws:
  `SQLException`

### isWrapperFor

public boolean isWrapperFor(Class<?> iface) throws SQLException

Specified by:
  `isWrapperFor` in interface `Wrapper`
Throws:
  `SQLException`

### unwrap

public <T> T unwrap(Class<T> iface) throws SQLException

Specified by:
  `unwrap` in interface `Wrapper`
Throws:
  `SQLException`