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`