com.amazon.redshift.jdbc

## Class RedshiftResultSetMetaDataImpl

- java.lang.Object
- - com.amazon.redshift.jdbc.RedshiftResultSetMetaDataImpl

All Implemented Interfaces:
  RedshiftResultSetMetaData, ResultSetMetaData, Wrapper

    public class RedshiftResultSetMetaDataImpl
    extends Object
    implements ResultSetMetaData, RedshiftResultSetMetaData

### Field Summary

Fields
`protected BaseConnection` `connection`
`protected Field[]` `fields`

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

`columnNoNulls, columnNullable, columnNullableUnknown`

### Constructor Summary

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

### Method Summary

All Methods Instance Methods Concrete Methods
`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?
`int` `getPrecision(int column)`
`protected String` `getRSType(int columnIndex)`
`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 Detail

#### connection

    protected final BaseConnection connection

#### fields

    protected final Field[] fields

### Constructor Detail

#### RedshiftResultSetMetaDataImpl

    public RedshiftResultSetMetaDataImpl(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 Detail

#### 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 Redshift 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 Redshift, 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: `RedshiftResultSetMetaData`
Returns the underlying column name of a query result, or "" if it is unable to be determined.

Specified by:
  `getBaseColumnName` in interface `RedshiftResultSetMetaData`
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: `RedshiftResultSetMetaData`
Returns the underlying schema name of query result, or "" if it is unable to be determined.

Specified by:
  `getBaseSchemaName` in interface `RedshiftResultSetMetaData`
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: `RedshiftResultSetMetaData`
Returns the underlying table name of query result, or "" if it is unable to be determined.

Specified by:
  `getBaseTableName` in interface `RedshiftResultSetMetaData`
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: `RedshiftResultSetMetaData`
Is a column Text or Binary?

Specified by:
  `getFormat` in interface `RedshiftResultSetMetaData`
Parameters:
  `column` - column position (1-based)
Returns:
  0 if column data foramt 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

#### getRSType

    protected String getRSType(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`