Package org.postgresql.jdbc

# Class TypeInfoCache

java.lang.Object
org.postgresql.jdbc.TypeInfoCache

All Implemented Interfaces:
  `TypeInfo`

public class TypeInfoCache extends Object implements TypeInfo

## Constructor Summary

Constructors
Constructor
Description
`TypeInfoCache(BaseConnection conn, int unknownLength)`

## Method Summary

Modifier and Type
Method
Description
`void`
`addCoreType(String pgTypeName, Integer oid, Integer sqlType, String javaClass, Integer arrayOid)`
`void`
`addDataType(String type, Class<? extends PGobject> klass)`
`void`
`cacheSQLTypes()`
`protected int`
`convertArrayToBaseOid(int oid)`
Return the oid of the array's base element if it's an array, if not return the provided oid.
`char`
`getArrayDelimiter(int oid)`
Determine the delimiter for the elements of the given array type oid.
`int`
`getDisplaySize(int oid, int typmod)`
`int`
`getJavaArrayType(String className)`
`String`
`getJavaClass(int oid)`
`int`
`getMaximumPrecision(int oid)`
`int`
`getPGArrayElement(int oid)`
Look up the oid of an array's base type given the array's type oid.
`int`
`getPGArrayType(@Nullable String elementTypeName)`
Determine the oid of the given base postgresql type's array type.
`@Nullable Class<? extends PGobject>`
`getPGobject(String type)`
`@Nullable String`
`getPGType(int oid)`
Look up the postgresql type name for a given oid.
`int`
`getPGType(String pgTypeName)`
Look up the oid for a given postgresql type name.
`Iterator<String>`
`getPGTypeNamesWithSQLTypes()`
`Iterator<Integer>`
`getPGTypeOidsWithSQLTypes()`
`int`
`getPrecision(int oid, int typmod)`
`int`
`getScale(int oid, int typmod)`
`int`
`getSQLType(int typeOid)`
Look up the SQL typecode for a given type oid.
`int`
`getSQLType(String pgTypeName)`
Look up the SQL typecode for a given postgresql type name.
`@Nullable String`
`getTypeForAlias(@Nullable String alias)`
`long`
`intOidToLong(int oid)`
Java Integers are signed 32-bit integers, but oids are unsigned 32-bit integers.
`boolean`
`isCaseSensitive(int oid)`
`boolean`
`isSigned(int oid)`
`int`
`longOidToInt(long oid)`
Java Integers are signed 32-bit integers, but oids are unsigned 32-bit integers.
`boolean`
`requiresQuoting(int oid)`
`boolean`
`requiresQuotingSqlType(int sqlType)`
Returns true if particular sqlType requires quoting.

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

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

## Constructor Details

### TypeInfoCache

public TypeInfoCache(BaseConnection conn, int unknownLength)

## Method Details

### addCoreType

public void addCoreType(String pgTypeName, Integer oid, Integer sqlType, String javaClass, Integer arrayOid)

Specified by:
  `addCoreType` in interface `TypeInfo`

### addDataType

public void addDataType(String type, Class<? extends PGobject> klass) throws SQLException

Specified by:
  `addDataType` in interface `TypeInfo`
Throws:
  `SQLException`

### getPGTypeNamesWithSQLTypes

public Iterator<String> getPGTypeNamesWithSQLTypes()

Specified by:
  `getPGTypeNamesWithSQLTypes` in interface `TypeInfo`

### getPGTypeOidsWithSQLTypes

public Iterator<Integer> getPGTypeOidsWithSQLTypes()

Specified by:
  `getPGTypeOidsWithSQLTypes` in interface `TypeInfo`

### cacheSQLTypes

public void cacheSQLTypes() throws SQLException

Throws:
  `SQLException`

### getSQLType

public int getSQLType(String pgTypeName) throws SQLException
Description copied from interface: `TypeInfo`
Look up the SQL typecode for a given postgresql type name.

Specified by:
  `getSQLType` in interface `TypeInfo`
Parameters:
  `pgTypeName` - the server type name to look up
Returns:
  the SQL type code (a constant from `Types`) for the type
Throws:
  `SQLException` - if an error occurs when retrieving sql type

### getJavaArrayType

public int getJavaArrayType(String className) throws SQLException

Specified by:
  `getJavaArrayType` in interface `TypeInfo`
Throws:
  `SQLException`

### getSQLType

public int getSQLType(int typeOid) throws SQLException
Description copied from interface: `TypeInfo`
Look up the SQL typecode for a given type oid.

Specified by:
  `getSQLType` in interface `TypeInfo`
Parameters:
  `typeOid` - the type's OID
Returns:
  the SQL type code (a constant from `Types`) for the type
Throws:
  `SQLException` - if an error occurs when retrieving sql type

### getPGType

public int getPGType(String pgTypeName) throws SQLException
Description copied from interface: `TypeInfo`
Look up the oid for a given postgresql type name. This is the inverse of `TypeInfo.getPGType(int)`.

Specified by:
  `getPGType` in interface `TypeInfo`
Parameters:
  `pgTypeName` - the server type name to look up
Returns:
  the type's OID, or 0 if unknown
Throws:
  `SQLException` - if an error occurs when retrieving PG type

### getPGType

public @Nullable String getPGType(int oid) throws SQLException
Description copied from interface: `TypeInfo`
Look up the postgresql type name for a given oid. This is the inverse of `TypeInfo.getPGType(String)`.

Specified by:
  `getPGType` in interface `TypeInfo`
Parameters:
  `oid` - the type's OID
Returns:
  the server type name for that OID or null if unknown
Throws:
  `SQLException` - if an error occurs when retrieving PG type

### getPGArrayType

public int getPGArrayType(@Nullable String elementTypeName) throws SQLException
Description copied from interface: `TypeInfo`
Determine the oid of the given base postgresql type's array type.

Specified by:
  `getPGArrayType` in interface `TypeInfo`
Parameters:
  `elementTypeName` - the base type's
Returns:
  the array type's OID, or 0 if unknown
Throws:
  `SQLException` - if an error occurs when retrieving array type

### convertArrayToBaseOid

protected int convertArrayToBaseOid(int oid)
Return the oid of the array's base element if it's an array, if not return the provided oid. This doesn't do any database lookups, so it's only useful for the originally provided type mappings. This is fine for it's intended uses where we only have intimate knowledge of types that are already known to the driver.

Parameters:
  `oid` - input oid
Returns:
  oid of the array's base element or the provided oid (if not array)

### getArrayDelimiter

public char getArrayDelimiter(int oid) throws SQLException
Description copied from interface: `TypeInfo`
Determine the delimiter for the elements of the given array type oid.

Specified by:
  `getArrayDelimiter` in interface `TypeInfo`
Parameters:
  `oid` - the array type's OID
Returns:
  the base type's array type delimiter
Throws:
  `SQLException` - if an error occurs when retrieving array delimiter

### getPGArrayElement

public int getPGArrayElement(int oid) throws SQLException
Description copied from interface: `TypeInfo`
Look up the oid of an array's base type given the array's type oid.

Specified by:
  `getPGArrayElement` in interface `TypeInfo`
Parameters:
  `oid` - the array type's OID
Returns:
  the base type's OID, or 0 if unknown
Throws:
  `SQLException` - if an error occurs when retrieving array element

### getPGobject

public @Nullable Class<? extends PGobject> getPGobject(String type)

Specified by:
  `getPGobject` in interface `TypeInfo`

### getJavaClass

public String getJavaClass(int oid) throws SQLException

Specified by:
  `getJavaClass` in interface `TypeInfo`
Throws:
  `SQLException`

### getTypeForAlias

public @Nullable String getTypeForAlias(@Nullable String alias)

Specified by:
  `getTypeForAlias` in interface `TypeInfo`

### getPrecision

public int getPrecision(int oid, int typmod)

Specified by:
  `getPrecision` in interface `TypeInfo`

### getScale

public int getScale(int oid, int typmod)

Specified by:
  `getScale` in interface `TypeInfo`

### isCaseSensitive

public boolean isCaseSensitive(int oid)

Specified by:
  `isCaseSensitive` in interface `TypeInfo`

### isSigned

public boolean isSigned(int oid)

Specified by:
  `isSigned` in interface `TypeInfo`

### getDisplaySize

public int getDisplaySize(int oid, int typmod)

Specified by:
  `getDisplaySize` in interface `TypeInfo`

### getMaximumPrecision

public int getMaximumPrecision(int oid)

Specified by:
  `getMaximumPrecision` in interface `TypeInfo`

### requiresQuoting

public boolean requiresQuoting(int oid) throws SQLException

Specified by:
  `requiresQuoting` in interface `TypeInfo`
Throws:
  `SQLException`

### requiresQuotingSqlType

public boolean requiresQuotingSqlType(int sqlType) throws SQLException
Returns true if particular sqlType requires quoting. This method is used internally by the driver, so it might disappear without notice.

Specified by:
  `requiresQuotingSqlType` in interface `TypeInfo`
Parameters:
  `sqlType` - sql type as in java.sql.Types
Returns:
  true if the type requires quoting
Throws:
  `SQLException` - if something goes wrong

### longOidToInt

public int longOidToInt(long oid) throws SQLException
Description copied from interface: `TypeInfo`

Java Integers are signed 32-bit integers, but oids are unsigned 32-bit integers. We therefore read them as positive long values and then force them into signed integers (wrapping around into negative values when required) or we'd be unable to correctly handle the upper half of the oid space.

This function handles the mapping of uint32-values in the long to java integers, and throws for values that are out of range.

Specified by:
  `longOidToInt` in interface `TypeInfo`
Parameters:
  `oid` - the oid as a long.
Returns:
  the (internal) signed integer representation of the (unsigned) oid.
Throws:
  `SQLException` - if the long has a value outside of the range representable by uint32

### intOidToLong

public long intOidToLong(int oid)
Description copied from interface: `TypeInfo`
Java Integers are signed 32-bit integers, but oids are unsigned 32-bit integers. We must therefore first map the (internal) integer representation to a positive long value before sending it to postgresql, or we would be unable to correctly handle the upper half of the oid space because these negative values are disallowed as OID values.

Specified by:
  `intOidToLong` in interface `TypeInfo`
Parameters:
  `oid` - the (signed) integer oid to convert into a long.
Returns:
  the non-negative value of this oid, stored as a java long.