Module org.firebirdsql.jaybird
Package org.firebirdsql.ds

# Class AbstractConnectionPropertiesDataSource

java.lang.Object
org.firebirdsql.ds.RootCommonDataSource
org.firebirdsql.ds.AbstractConnectionPropertiesDataSource

All Implemented Interfaces:
  `CommonDataSource`, `AttachmentProperties`, `BaseProperties`, `DatabaseConnectionProperties`, `FirebirdConnectionProperties`

Direct Known Subclasses:
  `FBAbstractCommonDataSource`, `FBSimpleDataSource`

public abstract class AbstractConnectionPropertiesDataSource extends RootCommonDataSource implements FirebirdConnectionProperties
Abstract implementation of `FirebirdConnectionProperties` to ensure subclasses can be introspected as beans.

Since:
  5
Author:
  Mark Rotteveel

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `AbstractConnectionPropertiesDataSource()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `String`
  `getAuthPlugins()`
  Get the list of authentication plugins to try.
  `int`
  `getBlobBufferSize()`
  `String`
  `getCharSet()`
  Java character set configured for the connection.
  `int`
  `getConnectTimeout()`
  Get the connect timeout in seconds.
  `String`
  `getDatabaseName()`
  Gets the database of the connection.
  `String`
  `getDataTypeBind()`
  Get the `dataTypeBind` configuration.
  `String`
  `getDbCryptConfig()`
  Get the database encryption plugin configuration.
  `String`
  `getDecfloatRound()`
  `String`
  `getDecfloatTraps()`
  `String`
  `getDefaultIsolation()`
  Get the default transaction isolation level as string.
  `int`
  `getDefaultTransactionIsolation()`
  Get the default transaction isolation level.
  `String`
  `getEnableProtocol()`
  Comma-separated list of additionally enabled protocols.
  `String`
  `getEncoding()`
  Firebird character set configured for the connection.
  `String`
  `getGeneratedKeysEnabled()`
  Get the `generatedKeysEnabled` configuration.
  `int`
  `getLoginTimeout()`
  `int`
  `getMaxBlobCacheSize()`
  `int`
  `getMaxInlineBlobSize()`
  `int`
  `getPageCacheSize()`
  Get the page cache size.
  `int`
  `getParallelWorkers()`
  `String`
  `getPassword()`
  `int`
  `getPortNumber()`
  Get the port number of the server.
  `Integer`
  `getProcessId()`
  `String`
  `getProcessName()`
  `String`
  `getReportSQLWarnings()`
  `String`
  `getRoleName()`
  `String`
  `getScrollableCursor()`
  `int`
  `getServerBatchBufferSize()`
  `String`
  `getServerName()`
  Get the hostname or IP address of the Firebird server.
  `String`
  `getSessionTimeZone()`
  Get the `sessionTimeZone`.
  `int`
  `getSocketBufferSize()`
  Get the socket buffer size.
  `String`
  `getSocketFactory()`
  The class name of a custom socket factory to be used for pure Java connections.
  `int`
  `getSoTimeout()`
  Get the initial Socket blocking timeout (SoTimeout).
  `int`
  `getSqlDialect()`
  `String`
  `getTpbMapping()`
  Get the used TPB mapping.
  `String`
  `getType()`
  `String`
  `getUser()`
  `String`
  `getUserName()`
  Deprecated.
  `String`
  `getWireCrypt()`
  Get the wire encryption level.
  `boolean`
  `isAllowTxStmts()`
  `boolean`
  `isAsyncFetch()`
  Gets if async fetching is enabled or disabled (pure Java only).
  `boolean`
  `isColumnLabelForName()`
  Gets the current setting of `columnLabelForName`
  `boolean`
  `isCreateDatabaseIfNotExist()`
  `boolean`
  `isDefaultResultSetHoldable()`
  Get whether ResultSets are holdable by default.
  `boolean`
  `isExtendedMetadata()`
  `boolean`
  `isIgnoreProcedureType()`
  Get the value for `ignoreProcedureType`.
  `boolean`
  `isUseCatalogAsPackage()`
  `boolean`
  `isUseFirebirdAutocommit()`
  Get whether to use Firebird autocommit (experimental).
  `boolean`
  `isUseServerBatch()`
  `boolean`
  `isUseStreamBlobs()`
  `boolean`
  `isWireCompression()`
  Get if wire compression should be enabled.
  `void`
  `setAllowTxStmts(boolean allowTxStmts)`
  Sets whether transaction management statements with (hard) transaction boundaries are allowed to be prepared or executed.
  `void`
  `setAsyncFetch(boolean asyncFetch)`
  Sets if async fetching is enabled or disabled (pure Java only).
  `void`
  `setAuthPlugins(String authPlugins)`
  Sets the authentication plugins to try.
  `void`
  `setBlobBufferSize(int blobBufferSize)`
  `void`
  `setCharSet(String charSet)`
  Set the Java character set for the connection.
  `void`
  `setColumnLabelForName(boolean columnLabelForName)`
  Set if `ResultSetMetaData.getColumnName(int)` returns the `columnLabel` instead of the `columnName`.
  `void`
  `setConnectTimeout(int connectTimeout)`
  Set the connect timeout in seconds.
  `void`
  `setCreateDatabaseIfNotExist(boolean createDatabaseIfNotExist)`
  Sets if an attempt should be made to create a database if it does not exist.
  `void`
  `setDatabaseName(String databaseName)`
  Sets the database of the connection
  `void`
  `setDataTypeBind(String dataTypeBind)`
  Sets the `dataTypeBind` configuration.
  `void`
  `setDbCryptConfig(String dbCryptConfig)`
  Sets the database encryption plugin configuration.
  `void`
  `setDecfloatRound(String decfloatRound)`
  Sets the `DECFLOAT` rounding mode
  `void`
  `setDecfloatTraps(String decfloatTraps)`
  Sets the `DECFLOAT` error traps.
  `void`
  `setDefaultIsolation(String isolation)`
  Set the default transaction isolation level as string.
  `void`
  `setDefaultResultSetHoldable(boolean defaultResultSetHoldable)`
  Set if `ResultSet` should be `ResultSet.HOLD_CURSORS_OVER_COMMIT` by default.
  `void`
  `setDefaultTransactionIsolation(int defaultIsolationLevel)`
  Set the default transaction isolation level.
  `void`
  `setEnableProtocol(String enableProtocol)`
  Comma-separated list of additionally enabled protocols.
  `void`
  `setEncoding(String encoding)`
  Set the Firebird character set for the connection.
  `void`
  `setExtendedMetadata(boolean extendedMetadata)`
  Sets if certain metadata classes will perform additional queries to enrich the information for certain types.
  `void`
  `setGeneratedKeysEnabled(String generatedKeysEnabled)`
  Sets the `generatedKeysEnabled` configuration.
  `void`
  `setIgnoreProcedureType(boolean ignoreProcedureType)`
  Sets the value `ignoreProcedureType`.
  `void`
  `setLoginTimeout(int seconds)`
  `void`
  `setMaxBlobCacheSize(int maxBlobCacheSize)`
  Sets the maximum inline blob cache size.
  `void`
  `setMaxInlineBlobSize(int maxInlineBlobSize)`
  Sets the maximum inline blob size.
  `void`
  `setPageCacheSize(int pageCacheSize)`
  Set the page cache size.
  `void`
  `setParallelWorkers(int parallelWorkers)`
  Sets the number of parallel workers of the connection.
  `void`
  `setPassword(String password)`
  `void`
  `setPortNumber(int portNumber)`
  Set the port number of the server.
  `void`
  `setProcessId(Integer processId)`
  Sets a custom process id to send to Firebird on attach.
  `void`
  `setProcessName(String processName)`
  Sets a custom process name to send to Firebird on attach
  `void`
  `setReportSQLWarnings(String reportSQLWarnings)`
  Sets if `SQLWarning` should be reported by `Connection.getWarnings()`, `Statement.getWarnings()`, and `ResultSet.getWarnings()`.
  `void`
  `setRoleName(String roleName)`
  `void`
  `setScrollableCursor(String scrollableCursor)`
  Sets the type of scrollable cursor.
  `void`
  `setServerBatchBufferSize(int serverBatchBufferSize)`
  Sets the server batch buffer size (if server batch is supported and enabled).
  `void`
  `setServerName(String serverName)`
  Set the hostname or IP address of the Firebird server.
  `void`
  `setSessionTimeZone(String sessionTimeZone)`
  Sets the `sessionTimeZone`.
  `void`
  `setSocketBufferSize(int socketBufferSize)`
  Set the socket buffer size.
  `void`
  `setSocketFactory(String socketFactory)`
  Sets the class name of a custom socket factory to be used for pure Java connections.
  `void`
  `setSoTimeout(int soTimeout)`
  Set the initial Socket blocking timeout (SoTimeout).
  `void`
  `setSqlDialect(int sqlDialect)`
  `void`
  `setTpbMapping(String tpbMapping)`
  Sets a resource bundle name with the TPB mapping.
  `void`
  `setType(String type)`
  `void`
  `setUseCatalogAsPackage(boolean useCatalogAsPackage)`
  Sets whether to use catalogs to report packages in database metadata.
  `void`
  `setUseFirebirdAutocommit(boolean useFirebirdAutocommit)`
  Set whether to use Firebird autocommit (experimental).
  `void`
  `setUser(String user)`
  `void`
  `setUserName(String userName)`
  Deprecated.
  `void`
  `setUseServerBatch(boolean useServerBatch)`
  Sets whether to use server-side batch support, if available.
  `void`
  `setUseStreamBlobs(boolean useStreamBlobs)`
  `void`
  `setWireCompression(boolean wireCompression)`
  Sets if the connection should try to enable wire compression.
  `void`
  `setWireCrypt(String wireCrypt)`
  Set the wire encryption level.

  ### Methods inherited from class org.firebirdsql.ds.RootCommonDataSource

  `getLogWriter, getParentLogger, setLogWriter`

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

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

  ### Methods inherited from interface org.firebirdsql.jaybird.props.BaseProperties

  `connectionPropertyValues, getBooleanProperty, getBooleanProperty, getIntProperty, getIntProperty, getProperty, getProperty, setBooleanProperty, setIntProperty, setProperty`

  ### Methods inherited from interface javax.sql.CommonDataSource

  `createShardingKeyBuilder`

  ### Methods inherited from interface org.firebirdsql.jdbc.FirebirdConnectionProperties

  `getTransactionParameters, setNonStandardProperty, setTransactionParameters`

- ## Constructor Details

  - ### AbstractConnectionPropertiesDataSource

    public AbstractConnectionPropertiesDataSource()

- ## Method Details

  - ### getServerName

    public String getServerName()
    Description copied from interface: `AttachmentProperties`
    Get the hostname or IP address of the Firebird server.
    Specified by:
      `getServerName` in interface `AttachmentProperties`
    Returns:
      Hostname or IP address of the server
    See Also:
      - `AttachmentProperties.setServerName(String)`

  - ### setServerName

    public void setServerName(String serverName)
    Description copied from interface: `AttachmentProperties`
    Set the hostname or IP address of the Firebird server.

    When set to `null` (the default), the `databaseName` or `serviceName` is used as the full identification of the database host, port and database path/alias. Protocol implementations, for example `PURE_JAVA`, may default to `localhost` when this property is `null`, but `databaseName`/`serviceName` does not (seem to) contain a host name.

    Specified by:
      `setServerName` in interface `AttachmentProperties`
    Parameters:
      `serverName` - Hostname or IP address of the server

  - ### getPortNumber

    public int getPortNumber()
    Description copied from interface: `AttachmentProperties`
    Get the port number of the server.
    Specified by:
      `getPortNumber` in interface `AttachmentProperties`
    Returns:
      Port number of the server
    See Also:
      - `AttachmentProperties.setPortNumber(int)`

  - ### setPortNumber

    public void setPortNumber(int portNumber)
    Description copied from interface: `AttachmentProperties`
    Set the port number of the server.

    Defaults to `3050`. This property value will be ignored if `serverName` is `null`, unless the protocol implementation needs a hostname, but cannot find a hostname in `databaseName`/`serviceName`.

    Specified by:
      `setPortNumber` in interface `AttachmentProperties`
    Parameters:
      `portNumber` - Port number of the server
    See Also:
      - `AttachmentProperties.setServerName(String)`

  - ### getDatabaseName

    public String getDatabaseName()
    Description copied from interface: `DatabaseConnectionProperties`
    Gets the database of the connection.
    Specified by:
      `getDatabaseName` in interface `DatabaseConnectionProperties`
    Returns:
      database name
    See Also:
      - `DatabaseConnectionProperties.setDatabaseName(String)`

  - ### setDatabaseName

    public void setDatabaseName(String databaseName)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the database of the connection

    When `serverName` is `null`, the value is taken as the URL of the database, and exact interpretation depends on the protocol implementation (`type`). Basically, the URL would be the JDBC URL, but without the `jdbc:firebird[sql]:[subprotocol:]` prefix and without connection properties. Examples:

    - //localhost/employee — PURE_JAVA, NATIVE (for NATIVE, this format is parsed and transformed to the next example)
    - localhost:employee — NATIVE, PURE_JAVA
    - //localhost:3051/employee — PURE_JAVA, NATIVE (for NATIVE, this format is parsed and transformed to the next example)
    - localhost/3051:employee — NATIVE, PURE_JAVA
    - /path/to/your.fdb — NATIVE, EMBEDDED, PURE_JAVA (PURE_JAVA will use localhost as `serverName`, depending on the Firebird version and platform, NATIVE may use Firebird Embedded)
    - C:\path\to\your.fdb — NATIVE, EMBEDDED (protocols like PURE_JAVA may attempt to connect to a server called `C`, depending on the Firebird version and platform, NATIVE may use Firebird Embedded)
    - C:/path/to/your.fdb — NATIVE, EMBEDDED (protocols like PURE_JAVA may attempt to connect to a server called `C`, depending on the Firebird version and platform, NATIVE may use Firebird Embedded)
    - xnet://employee — NATIVE (EMBEDDED will behave as NATIVE, protocols like PURE_JAVA may attempt to connect to a server called `xnet`)
    - other Firebird `fbclient` connection URLs — NATIVE (EMBEDDED will behave as NATIVE, protocols like PURE_JAVA may interpret the protocol name as a host name
    - Custom `type` implementations may support other URL formats

    Some protocols, for example PURE_JAVA, when `serverName` is not set, but `databaseName` doesn't seem to contain a host name, may default to attempting to connect to localhost with `databaseName` as the database path or alias.

    When `serverName` is set, the value is taken as the database path or alias. Examples:

    - employee
    - /path/to/your.fdb
    - C:\path\to\your.fdb
    - C:/path/to/your.fdb
    - relative/path/to/your.fdb — not recommended
    Specified by:
      `setDatabaseName` in interface `DatabaseConnectionProperties`
    Parameters:
      `databaseName` - database name

  - ### getType

    public String getType()
    Specified by:
      `getType` in interface `AttachmentProperties`
    Returns:
      type of the connection, for example, "PURE_JAVA", "NATIVE", "EMBEDDED", depends on the GDS implementations installed in the system.

  - ### setType

    public void setType(String type)
    Specified by:
      `setType` in interface `AttachmentProperties`
    Parameters:
      `type` - type of the connection, for example, "PURE_JAVA", "NATIVE", "EMBEDDED", depends on the GDS implementations installed in the system.

  - ### getUser

    public String getUser()
    Specified by:
      `getUser` in interface `AttachmentProperties`
    Returns:
      Name of the user to authenticate to the server.

  - ### setUser

    public void setUser(String user)
    Specified by:
      `setUser` in interface `AttachmentProperties`
    Parameters:
      `user` - Name of the user to authenticate to the server.

  - ### getPassword

    public String getPassword()
    Specified by:
      `getPassword` in interface `AttachmentProperties`
    Returns:
      Password to authenticate to the server.

  - ### setPassword

    public void setPassword(String password)
    Specified by:
      `setPassword` in interface `AttachmentProperties`
    Parameters:
      `password` - Password to authenticate to the server.

  - ### getRoleName

    public String getRoleName()
    Specified by:
      `getRoleName` in interface `AttachmentProperties`
    Returns:
      SQL role to use.

  - ### setRoleName

    public void setRoleName(String roleName)
    Specified by:
      `setRoleName` in interface `AttachmentProperties`
    Parameters:
      `roleName` - SQL role to use.

  - ### getCharSet

    public String getCharSet()
    Description copied from interface: `AttachmentProperties`
    Java character set configured for the connection.

    After connect, the actual Java character set applied can be obtained from `FbAttachment.getEncoding()` (property `charsetName`), or `FbAttachment.getEncodingFactory()` (properties `defaultEncoding.charsetName` or {code defaultEncodingDefinition.javaCharset}).

    Specified by:
      `getCharSet` in interface `AttachmentProperties`
    Returns:
      Java character set for the connection (`null` when not explicitly configured).

  - ### setCharSet

    public void setCharSet(String charSet)
    Description copied from interface: `AttachmentProperties`
    Set the Java character set for the connection.

    It is possible to set both the `charSet` and `encoding` to achieve a character set conversion effect, but in general only one of both properties should be set.

    Specified by:
      `setCharSet` in interface `AttachmentProperties`
    Parameters:
      `charSet` - Character set for the connection. Similar to `encoding` property, but accepts Java names instead of Firebird ones.
    See Also:
      - `AttachmentProperties.setEncoding(String)`

  - ### getEncoding

    public String getEncoding()
    Description copied from interface: `AttachmentProperties`
    Firebird character set configured for the connection.

    After connect, the actual Firebird character set applied can be obtained from `FbAttachment.getEncodingFactory()`, property `defaultEncodingDefinition.firebirdEncodingName`.

    Specified by:
      `getEncoding` in interface `AttachmentProperties`
    Returns:
      Firebird character encoding for the connection (`null` when not explicitly configured).

  - ### setEncoding

    public void setEncoding(String encoding)
    Description copied from interface: `AttachmentProperties`
    Set the Firebird character set for the connection.

    It is possible to set both the `charSet` and `encoding` to achieve a character set conversion effect, but in general only one of both properties should be set.

    Specified by:
      `setEncoding` in interface `AttachmentProperties`
    Parameters:
      `encoding` - Firebird character encoding for the connection. See Firebird documentation for more information.
    See Also:
      - `AttachmentProperties.setCharSet(String)`

  - ### getProcessId

    public Integer getProcessId()
    Specified by:
      `getProcessId` in interface `AttachmentProperties`
    Returns:
      Custom process id sent to Firebird on attach; `null` means the default is applied (read from system property `org.firebirdsql.jdbc.pid`, future versions may also determine the actual process id)

  - ### setProcessId

    public void setProcessId(Integer processId)
    Description copied from interface: `AttachmentProperties`
    Sets a custom process id to send to Firebird on attach.
    Specified by:
      `setProcessId` in interface `AttachmentProperties`
    Parameters:
      `processId` - The process id to send; `null` to apply the default behaviour (see `AttachmentProperties.getProcessId()`)

  - ### getProcessName

    public String getProcessName()
    Specified by:
      `getProcessName` in interface `AttachmentProperties`
    Returns:
      Custom process name sent to Firebird on attach; `null` means the default is applied (read from system property `org.firebirdsql.jdbc.processName`)

  - ### setProcessName

    public void setProcessName(String processName)
    Description copied from interface: `AttachmentProperties`
    Sets a custom process name to send to Firebird on attach
    Specified by:
      `setProcessName` in interface `AttachmentProperties`
    Parameters:
      `processName` - The process name to send; `null` to apply the default behaviour (see `AttachmentProperties.getProcessName()`)

  - ### getSocketBufferSize

    public int getSocketBufferSize()
    Description copied from interface: `AttachmentProperties`
    Get the socket buffer size.
    Specified by:
      `getSocketBufferSize` in interface `AttachmentProperties`
    Returns:
      socket buffer size in bytes, or `-1` if not set

  - ### setSocketBufferSize

    public void setSocketBufferSize(int socketBufferSize)
    Description copied from interface: `AttachmentProperties`
    Set the socket buffer size.
    Specified by:
      `setSocketBufferSize` in interface `AttachmentProperties`
    Parameters:
      `socketBufferSize` - socket buffer size in bytes.

  - ### getSoTimeout

    public int getSoTimeout()
    Description copied from interface: `AttachmentProperties`
    Get the initial Socket blocking timeout (SoTimeout).
    Specified by:
      `getSoTimeout` in interface `AttachmentProperties`
    Returns:
      The initial socket blocking timeout in milliseconds (0 is 'infinite'), or `-1` if not set

  - ### setSoTimeout

    public void setSoTimeout(int soTimeout)
    Description copied from interface: `AttachmentProperties`
    Set the initial Socket blocking timeout (SoTimeout).
    Specified by:
      `setSoTimeout` in interface `AttachmentProperties`
    Parameters:
      `soTimeout` - Timeout in milliseconds (0 is 'infinite')

  - ### getConnectTimeout

    public int getConnectTimeout()
    Description copied from interface: `AttachmentProperties`
    Get the connect timeout in seconds.
    Specified by:
      `getConnectTimeout` in interface `AttachmentProperties`
    Returns:
      Connect timeout in seconds (0 is 'infinite', or better: OS specific timeout), or `-1` if not set

  - ### setConnectTimeout

    public void setConnectTimeout(int connectTimeout)
    Description copied from interface: `AttachmentProperties`
    Set the connect timeout in seconds.
    Specified by:
      `setConnectTimeout` in interface `AttachmentProperties`
    Parameters:
      `connectTimeout` - Connect timeout in seconds (0 is 'infinite', or better: OS specific timeout)

  - ### getLoginTimeout

    public int getLoginTimeout() throws SQLException

    This property is an alias for the connectTimeout property.

    Specified by:
      `getLoginTimeout` in interface `CommonDataSource`
    Throws:
      `SQLException`

  - ### setLoginTimeout

    public void setLoginTimeout(int seconds) throws SQLException

    This property is an alias for the connectTimeout property.

    Specified by:
      `setLoginTimeout` in interface `CommonDataSource`
    Throws:
      `SQLException`

  - ### getWireCrypt

    public String getWireCrypt()
    Description copied from interface: `AttachmentProperties`
    Get the wire encryption level.
    Specified by:
      `getWireCrypt` in interface `AttachmentProperties`
    Returns:
      Wire encryption level

  - ### setWireCrypt

    public void setWireCrypt(String wireCrypt)
    Description copied from interface: `AttachmentProperties`
    Set the wire encryption level.

    Values are defined by `WireCrypt`, values are handled case insensitive. Invalid values will throw an exception.

    Specified by:
      `setWireCrypt` in interface `AttachmentProperties`
    Parameters:
      `wireCrypt` - Wire encryption level (`null` not allowed)

  - ### getDbCryptConfig

    public String getDbCryptConfig()
    Description copied from interface: `AttachmentProperties`
    Get the database encryption plugin configuration.
    Specified by:
      `getDbCryptConfig` in interface `AttachmentProperties`
    Returns:
      Database encryption plugin configuration, meaning plugin specific

  - ### setDbCryptConfig

    public void setDbCryptConfig(String dbCryptConfig)
    Description copied from interface: `AttachmentProperties`
    Sets the database encryption plugin configuration.
    Specified by:
      `setDbCryptConfig` in interface `AttachmentProperties`
    Parameters:
      `dbCryptConfig` - Database encryption plugin configuration, meaning plugin specific

  - ### getAuthPlugins

    public String getAuthPlugins()
    Description copied from interface: `AttachmentProperties`
    Get the list of authentication plugins to try.
    Specified by:
      `getAuthPlugins` in interface `AttachmentProperties`
    Returns:
      comma-separated list of authentication plugins

  - ### setAuthPlugins

    public void setAuthPlugins(String authPlugins)
    Description copied from interface: `AttachmentProperties`
    Sets the authentication plugins to try.

    Invalid names are skipped during authentication.

    Specified by:
      `setAuthPlugins` in interface `AttachmentProperties`
    Parameters:
      `authPlugins` - comma-separated list of authentication plugins

  - ### isWireCompression

    public boolean isWireCompression()
    Description copied from interface: `AttachmentProperties`
    Get if wire compression should be enabled.

    Wire compression requires Firebird 3 or higher, and the server must have the zlib library. If compression cannot be negotiated, the connection will be made without wire compression.

    This property will be ignored for native connections. For native connections, the configuration in `firebird.conf` read by the client library will be used.

    Specified by:
      `isWireCompression` in interface `AttachmentProperties`
    Returns:
      `true` wire compression enabled

  - ### setWireCompression

    public void setWireCompression(boolean wireCompression)
    Description copied from interface: `AttachmentProperties`
    Sets if the connection should try to enable wire compression.
    Specified by:
      `setWireCompression` in interface `AttachmentProperties`
    Parameters:
      `wireCompression` - `true` enable wire compression, `false` disable wire compression (the default)
    See Also:
      - `AttachmentProperties.isWireCompression()`

  - ### getEnableProtocol

    public String getEnableProtocol()
    Description copied from interface: `AttachmentProperties`
    Comma-separated list of additionally enabled protocols.

    By default, pure Java connections of Jaybird only supports the protocol versions of supported Firebird versions. This property lists the additionally enabled unsupported protocol versions. If Jaybird does not have a listed protocol, it is silently ignored.

    This property is ignored for native connections.

    Specified by:
      `getEnableProtocol` in interface `AttachmentProperties`
    Returns:
      List of unsupported protocol versions to try in addition to the supported protocols. Comma-separated using only the version number (e.g. `"10,11"`). Both the unmasked and masked version are supported (e.g. `32780` for protocol `12`), but we recommend to use the unmasked version. The value `"*"` will try all available protocols.

  - ### setEnableProtocol

    public void setEnableProtocol(String enableProtocol)
    Description copied from interface: `AttachmentProperties`
    Comma-separated list of additionally enabled protocols.
    Specified by:
      `setEnableProtocol` in interface `AttachmentProperties`
    Parameters:
      `enableProtocol` - List of unsupported protocol versions to try in addition to the supported protocols.
    See Also:
      - `AttachmentProperties.getEnableProtocol()`

  - ### getSqlDialect

    public int getSqlDialect()
    Specified by:
      `getSqlDialect` in interface `DatabaseConnectionProperties`
    Returns:
      SQL dialect of the client connection

  - ### setSqlDialect

    public void setSqlDialect(int sqlDialect)
    Specified by:
      `setSqlDialect` in interface `DatabaseConnectionProperties`
    Parameters:
      `sqlDialect` - SQL dialect of the client connection.

  - ### getPageCacheSize

    public int getPageCacheSize()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the page cache size.

    A value of `0` indicates that the value is not set, and that the server default is used.

    This option is only relevant for Firebird implementations with per connection cache (eg Classic)

    NOTE: Implementer should take care to return `0` if the value hasn't been set yet.

    Specified by:
      `getPageCacheSize` in interface `DatabaseConnectionProperties`
    Returns:
      size of cache in pages for this connection, can be specified for Classic and SuperClassic instances, ignored for SuperServer as the cache is shared; 0 when not set

  - ### setPageCacheSize

    public void setPageCacheSize(int pageCacheSize)
    Description copied from interface: `DatabaseConnectionProperties`
    Set the page cache size.

    A value of `0` indicates that the value is not set, and that the server default is used.

    This option is only relevant for Firebird implementations with per connection cache (eg Classic).

    Specified by:
      `setPageCacheSize` in interface `DatabaseConnectionProperties`
    Parameters:
      `pageCacheSize` - size of cache in pages for this connection, can be specified for Classic and SuperClassic instances ignored for SuperServer as the cache is shared.

  - ### getDataTypeBind

    public String getDataTypeBind()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the `dataTypeBind` configuration.
    Specified by:
      `getDataTypeBind` in interface `DatabaseConnectionProperties`
    Returns:
      configuration value for `dataTypeBind`, or `null` for driver default

  - ### setDataTypeBind

    public void setDataTypeBind(String dataTypeBind)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the `dataTypeBind` configuration.

    If the value is explicitly set to a non-null value and the connected server is Firebird 4 or higher, this will configure the data type binding with the specified values using `isc_dpb_set_bind`, which is equivalent to executing `SET BIND` statements with the values.

    See also Firebird documentation for `SET BIND`.

    Specified by:
      `setDataTypeBind` in interface `DatabaseConnectionProperties`
    Parameters:
      `dataTypeBind` - Firebird 4+ data type bind configuration, a semicolon-separated list of `<from-type> TO <to-type>`

  - ### getSessionTimeZone

    public String getSessionTimeZone()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the `sessionTimeZone`.
    Specified by:
      `getSessionTimeZone` in interface `DatabaseConnectionProperties`
    Returns:
      value for `sessionTimeZone`, or `null` for driver default (JVM default time zone)

  - ### setSessionTimeZone

    public void setSessionTimeZone(String sessionTimeZone)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the `sessionTimeZone`.
    Specified by:
      `setSessionTimeZone` in interface `DatabaseConnectionProperties`
    Parameters:
      `sessionTimeZone` - Firebird 4+ session time zone name (we strongly suggest to use Java compatible names only), use `"server"` to use server default time zone (note: conversion will use JVM default time zone). For offset-based names, the value will be normalized to the Firebird name (e.g. GMT+05:00 is stored as +05:00).

  - ### getBlobBufferSize

    public int getBlobBufferSize()
    Specified by:
      `getBlobBufferSize` in interface `DatabaseConnectionProperties`
    Returns:
      BLOB buffer size in bytes; if the configured value is less than an implementation-specific minimum, that minimum is returned

  - ### setBlobBufferSize

    public void setBlobBufferSize(int blobBufferSize)
    Specified by:
      `setBlobBufferSize` in interface `DatabaseConnectionProperties`
    Parameters:
      `blobBufferSize` - size of the BLOB buffer in bytes

  - ### isUseStreamBlobs

    public boolean isUseStreamBlobs()
    Specified by:
      `isUseStreamBlobs` in interface `DatabaseConnectionProperties`
    Returns:
      `true` if stream blobs should be created, otherwise `false`.

  - ### setUseStreamBlobs

    public void setUseStreamBlobs(boolean useStreamBlobs)
    Specified by:
      `setUseStreamBlobs` in interface `DatabaseConnectionProperties`
    Parameters:
      `useStreamBlobs` - `true` if stream blobs should be created, otherwise `false`.

  - ### isDefaultResultSetHoldable

    public boolean isDefaultResultSetHoldable()
    Description copied from interface: `DatabaseConnectionProperties`
    Get whether ResultSets are holdable by default.
    Specified by:
      `isDefaultResultSetHoldable` in interface `DatabaseConnectionProperties`
    Returns:
      `true` ResultSets by default are `ResultSet.HOLD_CURSORS_OVER_COMMIT`, `false` (default), ResultSets are `ResultSet.CLOSE_CURSORS_AT_COMMIT`

  - ### setDefaultResultSetHoldable

    public void setDefaultResultSetHoldable(boolean defaultResultSetHoldable)
    Description copied from interface: `DatabaseConnectionProperties`
    Set if `ResultSet` should be `ResultSet.HOLD_CURSORS_OVER_COMMIT` by default.
    Specified by:
      `setDefaultResultSetHoldable` in interface `DatabaseConnectionProperties`
    Parameters:
      `defaultResultSetHoldable` - `true` ResultSets are holdable, `false` (default) ResultSets are `ResultSet.CLOSE_CURSORS_AT_COMMIT`

  - ### isUseFirebirdAutocommit

    public boolean isUseFirebirdAutocommit()
    Description copied from interface: `DatabaseConnectionProperties`
    Get whether to use Firebird autocommit (experimental).
    Specified by:
      `isUseFirebirdAutocommit` in interface `DatabaseConnectionProperties`
    Returns:
      `true` use Firebird autocommit

  - ### setUseFirebirdAutocommit

    public void setUseFirebirdAutocommit(boolean useFirebirdAutocommit)
    Description copied from interface: `DatabaseConnectionProperties`
    Set whether to use Firebird autocommit (experimental).
    Specified by:
      `setUseFirebirdAutocommit` in interface `DatabaseConnectionProperties`
    Parameters:
      `useFirebirdAutocommit` - `true` Use Firebird autocommit

  - ### isColumnLabelForName

    public boolean isColumnLabelForName()
    Description copied from interface: `DatabaseConnectionProperties`
    Gets the current setting of `columnLabelForName`
    Specified by:
      `isColumnLabelForName` in interface `DatabaseConnectionProperties`
    Returns:
      `false` JDBC compliant behavior (`columnName` is returned), `true` compatibility option (`columnLabel` is returned)
    See Also:
      - `DatabaseConnectionProperties.setColumnLabelForName(boolean)`

  - ### setColumnLabelForName

    public void setColumnLabelForName(boolean columnLabelForName)
    Description copied from interface: `DatabaseConnectionProperties`
    Set if `ResultSetMetaData.getColumnName(int)` returns the `columnLabel` instead of the `columnName`.

    The default behaviour (with `columnLabelForName=false` is JDBC-compliant. The behavior for value `true` is to provide compatibility with tools with a wrong expectation.

    Specified by:
      `setColumnLabelForName` in interface `DatabaseConnectionProperties`
    Parameters:
      `columnLabelForName` - `false` JDBC compliant behavior (`columnName` is returned), `true` compatibility option (`columnLabel` is returned)

  - ### getGeneratedKeysEnabled

    public String getGeneratedKeysEnabled()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the `generatedKeysEnabled` configuration.
    Specified by:
      `getGeneratedKeysEnabled` in interface `DatabaseConnectionProperties`
    Returns:
      configuration value for `generatedKeysEnabled`, or `null` for driver default

  - ### setGeneratedKeysEnabled

    public void setGeneratedKeysEnabled(String generatedKeysEnabled)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the `generatedKeysEnabled` configuration.
    Specified by:
      `setGeneratedKeysEnabled` in interface `DatabaseConnectionProperties`
    Parameters:
      `generatedKeysEnabled` - Generated keys support configuration: `default` (or null/empty), `disabled`, `ignored`, or a list of statement types to enable (possible values: `insert`, `update`, `delete`, `update_or_insert`, `merge`)

  - ### isIgnoreProcedureType

    public boolean isIgnoreProcedureType()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the value for `ignoreProcedureType`.
    Specified by:
      `isIgnoreProcedureType` in interface `DatabaseConnectionProperties`
    Returns:
      value for `ignoreProcedureType`

  - ### setIgnoreProcedureType

    public void setIgnoreProcedureType(boolean ignoreProcedureType)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the value `ignoreProcedureType`.

    When set to true, the `CallableStatement` implementation in Jaybird will ignore metadata information about the stored procedure type and default to using `EXECUTE PROCEDURE`, unless the type is explicitly set using `FirebirdCallableStatement.setSelectableProcedure(boolean)`. This can be useful in situations where a stored procedure is selectable, but tooling or code expects an executable stored procedure.

    Specified by:
      `setIgnoreProcedureType` in interface `DatabaseConnectionProperties`
    Parameters:
      `ignoreProcedureType` - `true` Ignore procedure type

  - ### getDecfloatRound

    public String getDecfloatRound()
    Specified by:
      `getDecfloatRound` in interface `DatabaseConnectionProperties`
    Returns:
      the server-side `DECFLOAT` rounding mode, `null` applies the Firebird server default

  - ### setDecfloatRound

    public void setDecfloatRound(String decfloatRound)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the `DECFLOAT` rounding mode
    Specified by:
      `setDecfloatRound` in interface `DatabaseConnectionProperties`
    Parameters:
      `decfloatRound` - Firebird 4+ server-side `DECFLOAT` rounding mode (`ceiling, up, half_up, half_even, half_down, down, floor, reround`); `null` to apply the Firebird server default (`half_up` in Firebird 4)

  - ### getDecfloatTraps

    public String getDecfloatTraps()
    Specified by:
      `getDecfloatTraps` in interface `DatabaseConnectionProperties`
    Returns:
      the server-side `DECFLOAT` error traps, `null` applies the Firebird server default

  - ### setDecfloatTraps

    public void setDecfloatTraps(String decfloatTraps)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the `DECFLOAT` error traps.
    Specified by:
      `setDecfloatTraps` in interface `DatabaseConnectionProperties`
    Parameters:
      `decfloatTraps` - Firebird 4+ server-side `DECFLOAT` error traps; comma-separated list with options `Division_by_zero, Inexact, Invalid_operation, Overflow, Underflow`; `null` to apply Firebird server default (`Division_by_zero,Invalid_operation,Overflow` in Firebird 4)

  - ### getTpbMapping

    public String getTpbMapping()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the used TPB mapping.
    Specified by:
      `getTpbMapping` in interface `DatabaseConnectionProperties`
    Returns:
      resource bundle name of the TPB mapping
    See Also:
      - `DatabaseConnectionProperties.setTpbMapping(String)`

  - ### setTpbMapping

    public void setTpbMapping(String tpbMapping)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets a resource bundle name with the TPB mapping.

    For compatibility reasons, the prefix `"res:"` is allowed, but this works exactly the same as without a prefix. We strongly recommend not to use the `"res:"` prefix, future versions of Jaybird (Jaybird 7 or later) may stop supporting this.

    The resource bundle should contain a mapping between the transaction isolation level (name of the constant in the `Connection` interface and a comma-separated list of TPB parameters).

    Specified by:
      `setTpbMapping` in interface `DatabaseConnectionProperties`
    Parameters:
      `tpbMapping` - name of the resource bundle

  - ### getDefaultTransactionIsolation

    public int getDefaultTransactionIsolation()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the default transaction isolation level. This is the transaction isolation level for the newly created connections.
    Specified by:
      `getDefaultTransactionIsolation` in interface `DatabaseConnectionProperties`
    Returns:
      default transaction isolation level.

  - ### setDefaultTransactionIsolation

    public void setDefaultTransactionIsolation(int defaultIsolationLevel)
    Description copied from interface: `DatabaseConnectionProperties`
    Set the default transaction isolation level.
    Specified by:
      `setDefaultTransactionIsolation` in interface `DatabaseConnectionProperties`
    Parameters:
      `defaultIsolationLevel` - default transaction isolation level.

  - ### getDefaultIsolation

    public String getDefaultIsolation()
    Description copied from interface: `DatabaseConnectionProperties`
    Get the default transaction isolation level as string. This method is complementary to `DatabaseConnectionProperties.getDefaultTransactionIsolation()`, however it returns a string name instead of a numeric constant.
    Specified by:
      `getDefaultIsolation` in interface `DatabaseConnectionProperties`
    Returns:
      default transaction isolation as string.
    See Also:
      - `DatabaseConnectionProperties.setDefaultIsolation(String)`

  - ### setDefaultIsolation

    public void setDefaultIsolation(String isolation)
    Description copied from interface: `DatabaseConnectionProperties`
    Set the default transaction isolation level as string. This method is complementary to `DatabaseConnectionProperties.setDefaultTransactionIsolation(int)`, however it takes a string as parameter instead of a numeric constant.

    Following strings are allowed:

    - `"TRANSACTION_READ_COMMITTED"` for a READ COMMITTED isolation level.
    - `"TRANSACTION_REPEATABLE_READ"` for a REPEATABLE READ isolation level.
    - `"TRANSACTION_SERIALIZABLE"` for a SERIALIZABLE isolation level.
    - Integer string values matching the isolation levels
    Specified by:
      `setDefaultIsolation` in interface `DatabaseConnectionProperties`
    Parameters:
      `isolation` - string constant representing a default isolation level.

  - ### getScrollableCursor

    public String getScrollableCursor()
    Specified by:
      `getScrollableCursor` in interface `DatabaseConnectionProperties`
    Returns:
      Configuration of scrollable cursors, either `EMULATED` (default) or `SERVER` (case-insensitive)
    See Also:
      - `DatabaseConnectionProperties.setScrollableCursor(String)`

  - ### setScrollableCursor

    public void setScrollableCursor(String scrollableCursor)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the type of scrollable cursor.

    Possible values are (case-insensitive):

    - `EMULATED` (default) - emulate scrollable cursors in memory by fetching all rows
    - `SERVER` - user server-side scrollable cursor (requires Firebird 5.0 and pure-java connection). Falls back to `EMULATED` behaviour when server-side support is not available, or when holdable cursors are requested
    Specified by:
      `setScrollableCursor` in interface `DatabaseConnectionProperties`
    Parameters:
      `scrollableCursor` - Scrollable cursor type, one of `EMULATED` or `SERVER` (case-insensitive)

  - ### isUseServerBatch

    public boolean isUseServerBatch()
    Specified by:
      `isUseServerBatch` in interface `DatabaseConnectionProperties`
    Returns:
      `true` (default) use server-side batch if supported by server, `false` always use emulated batch
    See Also:
      - `DatabaseConnectionProperties.setUseServerBatch(boolean)`

  - ### setUseServerBatch

    public void setUseServerBatch(boolean useServerBatch)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets whether to use server-side batch support, if available.

    Currently, server-side batch is only supported with Firebird 4.0 or higher, with a pure Java connection, using a `PreparedStatement`, but not a `CallableStatement`, and only when not requesting generated keys.

    The implementation will fall back to emulated batches if either the server version doesn't support batches, or if the statement cannot be executed using the server-side batch mechanism for other reasons (e.g. requesting generated keys).

    Specified by:
      `setUseServerBatch` in interface `DatabaseConnectionProperties`
    Parameters:
      `useServerBatch` - `true`, use server-side batch support if possible, `false` always use emulated batch

  - ### getServerBatchBufferSize

    public int getServerBatchBufferSize()
    Specified by:
      `getServerBatchBufferSize` in interface `DatabaseConnectionProperties`
    Returns:
      batch buffer size in bytes, `< 0` to use server-side default (16MB as of Firebird 4.0), `0` (default) to use server-side maximum (256MB as of Firebird 4.0), values exceeding server-side maximum will set server-side maximum
    See Also:
      - `DatabaseConnectionProperties.setServerBatchBufferSize(int)`

  - ### setServerBatchBufferSize

    public void setServerBatchBufferSize(int serverBatchBufferSize)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the server batch buffer size (if server batch is supported and enabled).
    Specified by:
      `setServerBatchBufferSize` in interface `DatabaseConnectionProperties`
    Parameters:
      `serverBatchBufferSize` - server batch buffer size in bytes, use `< 0` to set server-side default (16MB as of Firebird 4.0), use `0` to use server-side maximum (256MB as of Firebird 4.0), values exceeding server-side maximum will set server-side maximum

  - ### getParallelWorkers

    public int getParallelWorkers()
    Specified by:
      `getParallelWorkers` in interface `AttachmentProperties`
    Returns:
      number of parallel workers, `-1` means no value was set (or it was explicitly set to `-1`)

  - ### setParallelWorkers

    public void setParallelWorkers(int parallelWorkers)
    Description copied from interface: `AttachmentProperties`
    Sets the number of parallel workers of the connection.

    Requires Firebird 5.0 or higher, and a Firebird server configured with `MaxParallelWorkers` higher than specified by `parallelWorkers`.

    NOTE: For service attachments, this property controls behaviour only for specific operations, and requires Jaybird to explicitly set the parallel workers for that operation.

    Specified by:
      `setParallelWorkers` in interface `AttachmentProperties`
    Parameters:
      `parallelWorkers` - number of parallel workers

  - ### getSocketFactory

    public String getSocketFactory()
    Description copied from interface: `AttachmentProperties`
    The class name of a custom socket factory to be used for pure Java connections.
    Specified by:
      `getSocketFactory` in interface `AttachmentProperties`
    Returns:
      fully-qualified class name of a `SocketFactory` implementation, or (default) `null` for the default socket factory
    See Also:
      - `AttachmentProperties.setSocketFactory(String)`

  - ### setSocketFactory

    public void setSocketFactory(String socketFactory)
    Description copied from interface: `AttachmentProperties`
    Sets the class name of a custom socket factory to be used for pure Java connections.

    The class must extend `SocketFactory` and have a public single-arg constructor accepting a `Properties`, or a public no-arg constructor. The `Properties` object passed in the first case contains custom connection properties with the suffix `@socketFactory`, and — possibly — other selected properties.

    Specified by:
      `setSocketFactory` in interface `AttachmentProperties`
    Parameters:
      `socketFactory` - fully-qualified class name of a `SocketFactory` implementation, or `null` for the default socket factory

  - ### isUseCatalogAsPackage

    public boolean isUseCatalogAsPackage()
    Specified by:
      `isUseCatalogAsPackage` in interface `DatabaseConnectionProperties`
    Returns:
      `true` database metadata uses catalogs to report packages, `false` (default) no catalogs, and packages and their procedures and functions are not accessible
    See Also:
      - `DatabaseConnectionProperties.setUseCatalogAsPackage(boolean)`

  - ### setUseCatalogAsPackage

    public void setUseCatalogAsPackage(boolean useCatalogAsPackage)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets whether to use catalogs to report packages in database metadata.

    When set to `true`, database metadata will return the names of packages from `DatabaseMetaData.getCatalogs()`, and `DatabaseMetaData.getFunctions(String, String, String)`, `DatabaseMetaData.getFunctionColumns(String, String, String, String)`, `DatabaseMetaData.getProcedures(String, String, String)`, and `DatabaseMetaData.getProcedureColumns(String, String, String, String)` will include information on packaged procedures and functions.

    The behaviour of the input parameter `catalog` of these methods is modified compared to the default behaviour:

    - `null`: both packaged and top-level procedures/functions are searched
    - `""` (empty string): only top-level procedures/functions are searched
    - non-empty string: only procedures/functions in the named package are searched (NOTE: exact match, case-sensitive)

    The returned result set is modified compared to the default behaviour:

    - `PROCEDURE_CAT`/`FUNCTION_CAT`: for top-level procedures/functions, its value is `""` (empty string) — not `null` — to account for behaviour of parameter `package` when searching metadata
    - `SPECIFIC_NAME`: for packaged procedures/functions will report `<quoted-package-name>.<quoted-routine-name>`

    Return values of other metadata methods are changed to match: `DatabaseMetaData.getCatalogSeparator()`, `DatabaseMetaData.getCatalogTerm()`, `DatabaseMetaData.isCatalogAtStart()`, `DatabaseMetaData.getMaxCatalogNameLength()`, `DatabaseMetaData.supportsCatalogsInDataManipulation()`, `DatabaseMetaData.supportsCatalogsInProcedureCalls()`

    Specified by:
      `setUseCatalogAsPackage` in interface `DatabaseConnectionProperties`
    Parameters:
      `useCatalogAsPackage` - `true` database metadata uses catalogs to report packages, `false` (default) no catalogs, and packages and their procedures and functions are not accessible

  - ### isAllowTxStmts

    public boolean isAllowTxStmts()
    Specified by:
      `isAllowTxStmts` in interface `DatabaseConnectionProperties`
    Returns:
      `true` if execution of `COMMIT [WORK]`, `ROLLBACK [WORK]` or `SET TRANSACTION [..]` is allowed, `false` (default) to throw an exception when attempting to execute or prepare such statements
    See Also:
      - `DatabaseConnectionProperties.setAllowTxStmts(boolean)`

  - ### setAllowTxStmts

    public void setAllowTxStmts(boolean allowTxStmts)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets whether transaction management statements with (hard) transaction boundaries are allowed to be prepared or executed.

    Setting to `true` will enable Jaybird to execute equivalent operations through the JDBC API (specifically, `Statement.execute(String)`, `Statement.executeUpdate(String)`, `Statement.executeLargeUpdate(String)` and siblings, and statements prepared with `Connection.prepareStatement(String)` and siblings. Using callable statements (e.g. using `Connection.prepareCall(String)`), `Statement.executeQuery(String)`, or batch execution is never supported.

    The implementation is free to execute the provided statement text or use an equivalent operation that has the same effect.

    Setting this configuration to `true` only affects the JDBC API, and has no effect on direct use of the GDS-ng API.

    Specified by:
      `setAllowTxStmts` in interface `DatabaseConnectionProperties`
    Parameters:
      `allowTxStmts` - `true` to allow execution of `COMMIT [WORK]`, `ROLLBACK [WORK]` or `SET TRANSACTION [..]`, `false` (default) to throw an exception when attempting to execute or prepare such statements

  - ### isExtendedMetadata

    public boolean isExtendedMetadata()
    Specified by:
      `isExtendedMetadata` in interface `DatabaseConnectionProperties`
    Returns:
      `true` (default) if metadata (e.g. `ResultSetMetaData`) will perform additional queries for more detailed information, `false` if only the available bind information will be used
    See Also:
      - `DatabaseConnectionProperties.setExtendedMetadata(boolean)`

  - ### setExtendedMetadata

    public void setExtendedMetadata(boolean extendedMetadata)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets if certain metadata classes will perform additional queries to enrich the information for certain types.

    Currently this is used only by `ResultSetMetaData` for its `getPrecision` and `isAutoIncrement` methods. If disabled, these methods will return an estimated precision, or `false` for auto-increment instead of actual precision and identity column state information.

    Disabling this setting may improve performance of querying metadata information, in exchange for less precise information.

    Specified by:
      `setExtendedMetadata` in interface `DatabaseConnectionProperties`
    Parameters:
      `extendedMetadata` - `true` (default) - metadata (e.g. `ResultSetMetaData`) will perform additional queries for more detailed information, `false` - only the available bind information will be used

  - ### isCreateDatabaseIfNotExist

    public boolean isCreateDatabaseIfNotExist()
    Specified by:
      `isCreateDatabaseIfNotExist` in interface `DatabaseConnectionProperties`
    Returns:
      `false` (default) if failure to connect does nothing, `true` if some classes of connection failures will result in an attempt to create the database
    See Also:
      - `DatabaseConnectionProperties.setCreateDatabaseIfNotExist(boolean)`

  - ### setCreateDatabaseIfNotExist

    public void setCreateDatabaseIfNotExist(boolean createDatabaseIfNotExist)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets if an attempt should be made to create a database if it does not exist.

    If the connection fails because the database cannot be opened, Jaybird will attempt to create the database. Additional or overridden properties can be set using `BaseProperties.setProperty(String, String)` by suffixing the property name with `@create`.

    As Firebird does not clearly report that a database does not exist (e.g. it may exist, but not be accessible to the server, etc.), and the errors may be OS-specific, the attempt to create may fail. Jaybird may try to use some heuristics to avoid creation for some errors, but this is an implementation details which may change in point releases.

    Specified by:
      `setCreateDatabaseIfNotExist` in interface `DatabaseConnectionProperties`
    Parameters:
      `createDatabaseIfNotExist` - `false` (default) if failure to connect does nothing, `true` if some classes of connection failures will result in an attempt to create the database

  - ### getReportSQLWarnings

    public String getReportSQLWarnings()
    Specified by:
      `getReportSQLWarnings` in interface `DatabaseConnectionProperties`
    Returns:
      `ALL` (default) if `SQLWarning` should be reported by `Connection`, `Statement` and `ResultSet`, `NONE` if `SQLWarning` should not be reported
    See Also:
      - `DatabaseConnectionProperties.setReportSQLWarnings(String)`

  - ### setReportSQLWarnings

    public void setReportSQLWarnings(String reportSQLWarnings)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets if `SQLWarning` should be reported by `Connection.getWarnings()`, `Statement.getWarnings()`, and `ResultSet.getWarnings()`.

    Allowed values (case-insensitive):

    - ALL — (default) report all `SQLWarning`
    - NONE — report no `SQLWarning`; this behaviour is not JDBC-compliant

    The default value can be overridden by setting system property `org.firebirdsql.jdbc.defaultReportSQLWarnings`.

    Specified by:
      `setReportSQLWarnings` in interface `DatabaseConnectionProperties`
    Parameters:
      `reportSQLWarnings` - `ALL` (default) if `SQLWarning` should be reported by `Connection`, `Statement` and `ResultSet`, `NONE` if `SQLWarning` should not be reported; setting `null` will use `ALL`

  - ### isAsyncFetch

    public boolean isAsyncFetch()
    Description copied from interface: `DatabaseConnectionProperties`
    Gets if async fetching is enabled or disabled (pure Java only).

    This property may get removed in Jaybird 7 or later, once this async fetching has proven itself.

    Specified by:
      `isAsyncFetch` in interface `DatabaseConnectionProperties`
    Returns:
      `true` (default) async fetching is enabled, `false` async fetching is disabled
    See Also:
      - `DatabaseConnectionProperties.setAsyncFetch(boolean)`

  - ### setAsyncFetch

    public void setAsyncFetch(boolean asyncFetch)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets if async fetching is enabled or disabled (pure Java only).

    The default value can be overridden by setting system property `org.firebirdsql.jdbc.defaultAsyncFetch`.

    This property may get removed in Jaybird 7 or later, once this async fetching has proven itself.

    Specified by:
      `setAsyncFetch` in interface `DatabaseConnectionProperties`
    Parameters:
      `asyncFetch` - `true` (default) async fetching is enabled, `false` async fetching is disabled

  - ### getMaxInlineBlobSize

    public int getMaxInlineBlobSize()
    Specified by:
      `getMaxInlineBlobSize` in interface `DatabaseConnectionProperties`
    Returns:
      the maximum inline blob size (native connections will use their own default if it was not explicitly set)
    See Also:
      - `DatabaseConnectionProperties.setMaxInlineBlobSize(int)`

  - ### setMaxInlineBlobSize

    public void setMaxInlineBlobSize(int maxInlineBlobSize)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the maximum inline blob size. This controls the maximum size of a blob (including segment lengths) that Firebird will send inline on fetch or execute.

    This only applies to Firebird 5.0.3 or higher.

    Default value is 64 KiB. Native connections will use their own default if it was not explicitly set. The default value can be overridden by setting system property `org.firebirdsql.jdbc.defaultMaxInlineBlobSize`.

    Specified by:
      `setMaxInlineBlobSize` in interface `DatabaseConnectionProperties`
    Parameters:
      `maxInlineBlobSize` - maximum inline blob size, a value of `0` will disable sending inline blobs, values greater than 65535 will be effectively ignored (this is not enforced, so if Firebird introduces support for larger values, it will work); negative values will set `0`.

  - ### getMaxBlobCacheSize

    public int getMaxBlobCacheSize()
    Specified by:
      `getMaxBlobCacheSize` in interface `DatabaseConnectionProperties`
    Returns:
      the maximum blob cache size in bytes (native connections will use their own default if it was not explicitly set)
    See Also:
      - `DatabaseConnectionProperties.setMaxBlobCacheSize(int)`

  - ### setMaxBlobCacheSize

    public void setMaxBlobCacheSize(int maxBlobCacheSize)
    Description copied from interface: `DatabaseConnectionProperties`
    Sets the maximum inline blob cache size. This controls the size of the cache to store inline blobs. Only the actual blob length counts towards the cache size.

    This only applies to Firebird 5.0.3 or higher.

    Default value is 10 MiB. Native connections will use their own default if it was not explicitly set. The default value can be overridden by setting system property `org.firebirdsql.jdbc.defaultMaxBlobCacheSize`.

    Disabling the cache by setting it to `0` will not disable inline blobs; make sure you also set `DatabaseConnectionProperties.setMaxInlineBlobSize(int)` to `0` to avoid unnecessary data transfer.

    Specified by:
      `setMaxBlobCacheSize` in interface `DatabaseConnectionProperties`
    Parameters:
      `maxBlobCacheSize` - the maximum blob cache size in bytes, a value of `0` will disable the cache; negative values will set `0`

  - ### getUserName

    @Deprecated(since="5") public String getUserName()
    Deprecated.
    Specified by:
      `getUserName` in interface `FirebirdConnectionProperties`
    Returns:
      name of the user that will be used when connecting to the database.

  - ### setUserName

    @Deprecated(since="5") public void setUserName(String userName)
    Deprecated.
    Specified by:
      `setUserName` in interface `FirebirdConnectionProperties`
    Parameters:
      `userName` - name of the user that will be used when connecting to the database.