com.informix.jdbc

## Class IfxSqliConnect

- java.lang.Object
- - com.informix.jdbc.IfxSqliConnect

All Implemented Interfaces:
  IfmxConnection, IfxConnection, java.lang.AutoCloseable, java.sql.Connection, java.sql.Wrapper

Direct Known Subclasses:
  IfxSqliConnReUsableConnection, IfxXAReusableConnection

    public class IfxSqliConnect
    extends java.lang.Object
    implements IfxConnection

A Connection represents a session with a specific database. Within the context of a Connection, SQL statements are executed and results are returned.

A Connection's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, etc. This information is obtained with the getMetaData method.

Note: By default the Connection automatically commits changes after executing each statement. If auto commit has been disabled, an explicit commit must be done by the application or database changes will not be saved.

See Also:
  `getConnection`, `Statement`, `ResultSet`, `DatabaseMetaData`

### Field Summary

Fields
`protected static short` `ANSIMODE`
`static short` `ANSIWARN`
`protected Connection` `asfconn`
`protected static java.util.concurrent.ExecutorService` `cleaner`
`protected long` `cleanerMaximumDelay`
`protected long` `cleanerMinimumDelay`
`protected int` `cleanerZeroPointPercentage`
`static boolean` `ConnEst`
`protected java.util.Properties` `connInfo`
`protected java.lang.String` `dbName`
`protected boolean` `delimIdent`
`protected boolean` `encoption`
`protected java.lang.String` `externalVersion`
`protected java.util.Vector<java.io.File>` `fileList`
`protected boolean` `freeclobwithrs`
`static boolean` `GclEnv`
`static short` `HASLOG`
`protected boolean` `ifxAllowOut`
`protected IfxToJavaType` `ifxtojava`
`protected PreparedStatementCache` `implicitCache`
`boolean` `isOpen`
`protected JavaToIfxType` `javatoifx`
`int` `jdbcGeneratedSavepointId_`
`static java.lang.String` `jdbcGeneratedSavepointNamePrefix__`
`protected boolean` `Noansiwarn`
`protected java.util.concurrent.atomic.AtomicInteger` `preparedStatementClosedCount`
`protected java.util.concurrent.atomic.AtomicInteger` `preparedStatementCount`
`protected java.util.concurrent.atomic.AtomicInteger` `preparedStatementReusedCount`
`protected java.lang.String` `productName`
`protected IfxProtocol` `proto`
`protected java.lang.String` `protoClassName`
`protected static java.util.concurrent.BlockingQueue<DelayedWeakReference<IfxSqliConnect>>` `queueOfConnections` All connections instances share a single delay queue and cleaner thread.
`protected boolean` `replCheck`
`protected boolean` `socketTimedOut`
`protected boolean` `softCloseDone`
`protected java.util.Vector<com.informix.jdbc.IfxSqliConnect.StmtList>` `stmtList`
`protected java.lang.ref.ReferenceQueue<IfxStatement>` `stmtReferenceQueue` Each connection has its own reference queue of statements with weak references that have been closed.
`protected static java.util.concurrent.atomic.AtomicLong` `stmtWeakReferenceCloseCount`
`protected java.util.ArrayList<java.lang.ref.WeakReference<java.sql.Savepoint>>` `svptList`
`protected boolean` `useCaseCapName`
`protected boolean` `usePut`
`protected java.lang.String` `userName`

### Fields inherited from interface com.informix.jdbc.IfxConnection

`LOGGING_MODE, MODE_ANSI, NO_DATABASE, NO_LOGGING_MODE, TRANSACTION_LAST_COMMITTED`

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

`TRANSACTION_NONE, TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE`

### Constructor Summary

Constructors
Constructor and Description
`IfxSqliConnect()` Constructor for the connection class: No parameter version is for the server side sub-class to this class to construct w/o opening an ASF connection Parameter version is the normal SQLI way.
`IfxSqliConnect(java.lang.String luser, java.lang.String lpasswd, java.lang.String url, java.util.Properties prop)` Constructor for the connection class:

### Method Summary

Methods
`void` `abort(java.util.concurrent.Executor executor)`
`void` `addToBlobList(IfxSmartBlob x)`
`void` `addToFileList(java.io.File ifxTmp)`
`protected IfxUDTInfo` `addUDTInfo(java.lang.String udtOwner, java.lang.String udtName)` IfxSqliConnect.addUDTInfo() Access the sysxtdtypes and sysattrtypes system catalogs and add these entries to udtMap if useCacheMap is set to true.
`protected void` `changeStmtId(IfxStatement stmt, int id)`
`protected void` `clearTransactions(boolean rollbackXids)`
`void` `clearWarnings()` After this call getWarnings returns null until a new warning is reported for this Connection.
`void` `close()` In some cases, it is desirable to immediately release a Connection's database and JDBC resources instead of waiting for them to be automatically released; the close method provides this immediate release.
`protected void` `closeAllResultSets()`
`protected void` `closeAllStatements()` Close all statements for this connection This method is called from the close method of reusable connection
`void` `commit()` Commit makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by the Connection.
`java.sql.Array` `createArrayOf(java.lang.String typeName, java.lang.Object[] elements)`
`java.sql.Blob` `createBlob()`
`java.sql.Clob` `createClob()`
`java.sql.NClob` `createNClob()`
`IfxProtocol` `createProto()` Create a new protocol instance for this connection
`java.sql.SQLXML` `createSQLXML()`
`java.sql.Statement` `createStatement()` SQL statements without parameters are normally executed using Statement objects.
`java.sql.Statement` `createStatement(int resultSetType, int resultSetConcurrency)` JDBC 2.0 Same as createStatement() above, but allows the default result set type and result set concurrency type to be overridden.
`java.sql.Statement` `createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`java.sql.Struct` `createStruct(java.lang.String typeName, java.lang.Object[] attributes)`
`protected void` `deleteAllFiles()`
`boolean` `doesBlobNeedPurge()`
`protected void` `endMetaDataQuery()`
`protected void` `finalize()`
`protected void` `freeStatementWeakReferences()`
`boolean` `getAutoCommit()` Get the current auto-commit state.
`boolean` `getAutoFree()`
`int` `getBlobCacheSize()`
`protected IfxPreparedStatement` `getCachedPreparedStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`java.lang.String` `getCatalog()` Return the Connection's current catalog name
`java.lang.String` `getclEncoding()`
`java.util.Properties` `getClientInfo()`
`java.lang.String` `getClientInfo(java.lang.String name)`
`java.lang.String` `getclLocale()` Gets the CLIENT_LOCALE locale for connection
`boolean` `getclLocaleProp()`
`java.lang.String` `getConnClassName()` What is the name of the connection class?
`java.lang.String` `getConnectionDbName()` Return current *Internal* name of database (can be null) This method is primarily for IfxDirectProtocol and executeCloseDatabase to find out if we have a db or server connection.
`java.lang.String` `getDatabaseProductVersion()`
`int` `getDatabaseType()` What is the database type? NO_DATABASE, ANSI_MODE, LOGGING or NON_LOGGING?
`java.lang.String` `getdbCentury()`
`java.lang.String` `getdbDate()`
`java.lang.String` `getdbEncoding()` Gets the DB_LOCALE encoding for connection
`java.lang.String` `getdbLocale()` Gets the DB_LOCALE locale for connection
`boolean` `getdbLocaleProp()`
`java.lang.String` `getDbName()` Return current name of database (can be null)
`java.lang.String` `getDbProductName()` Gets the product name for this database
`java.lang.String` `getdbTime()`
`long` `getdbTodayDate()` This method will return the dbTodayDate value
`long` `getdbTodayStart()` This method will return the dbTodayStart value
`java.lang.String` `getDbVersion()` Gets the version for this database
`int` `getFetchBufSize()` This method will return the FET_BUF_SIZE value
`com.informix.jdbc.IfxFParam` `getFPCacheFParam(java.lang.String signature)` Returns a routine's fparam structure based on the routine signature.
`int` `getFPCacheRoutineId(java.lang.String signature)` Returns a routine's id based on the routine signature.
`java.lang.String` `getGeneratedCursor()`
`java.lang.String` `getglDate()`
`java.lang.String` `getglDateTime()`
`java.lang.String` `getHDRType()` get the HDR server type of the connection 'primary|secondary|standard'
`int` `getHoldability()` Map holdability to JDBC3.0 values .
`boolean` `getIFX_USEPUT()`
`boolean` `getIsBigInt()`
`boolean` `getIsBigSerial()`
`java.lang.String` `getJDBCTempDir()` Where the user wants to redirect their temp files
`java.lang.String` `getJDBCVersion()` What is the connection's version?
`boolean` `getMapFloat()` Is JDBC type FLOAT mapped to Informix type Float
`boolean` `getMapReal()` Is Informix type Smallfloat reported as JDBC type REAL
`int` `getMaxLvarcharSize()` Gets maximum size of LVARCHAR supported by server connected to.
`java.sql.DatabaseMetaData` `getMetaData()` A Connection's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, etc.
`int` `getNetworkTimeout()`
`boolean` `getOPTOFC()` Returns true if OPTOFC=1 is set by the user.
`IfxProtocol` `getProto()` Get the protocol instance for this connection
`java.lang.String` `getProtoClassName()` What is the name of the protocol class?
`Trace` `getProtoTrace()` getProtoTrace Return the protocol trace object instantiated in the IfxSqliConnect constructor.
`java.lang.String` `getSchema()`
`int` `getSQLStatementOffset()` Get the error offset of last executed/prepared SQL statement
`Trace` `getTrace()` getTrace Return the trace object instantiated in the IfxSqliConnect constructor.
`int` `getTransactionIsolation()` Get this Connection's current transaction isolation mode
`boolean` `getTrimTrailingSpaces()` Get TrimTrailingSpaces -- if set, trim trailing spaces in IfxChar.fromIfx().
`java.util.Map` `getTypeMap()` JDBC 2.0 Get the type-map object associated with this connection.
`IfxUDTInfo` `getUDTInfo(IfxColumnInfo colinfo)` IfxSqliConnect.getUDTInfo(colinfo) Load up udt medadata using the column metadata, used by direct connections only.
`IfxUDTInfo` `getUDTInfo(IfxColumnInfo colinfo, java.lang.String name)` IfxSqliConnect.getUDTInfo(colinfo, typename) Search for this SQLName in udtMap.
`IfxUDTInfo` `getUDTInfo(int xid)` Get general information about opaque and distinct types and detailed information for complex types.
`IfxUDTInfo` `getUDTInfo(java.lang.String name, java.lang.String owner)` Get general information about opaque and distinct types and detailed information for complex types.
`java.lang.String` `getURL()` Return the original url (not the <ipaddr>:<portno> url - that is for internal use only
`boolean` `getuseDtenv()`
`boolean` `getUsePut()`
`java.lang.String` `getUserName()` What is the connection's userName?
`java.sql.SQLWarning` `getWarnings()` The first warning reported by calls on this Connection is returned.
`java.lang.String` `getXnameByXid(int xid)`
`boolean` `inXATransaction()` Returns true if start has been called to begin (or resume) an XA transaction.
`boolean` `is2GBFetchBufferSupported()` is2GBFetchBufferSupported This method returns true if the server supports 2GB linit for FET_BUF_SIZE
`boolean` `is4ByteOffsetSupported()` is4ByteOffsetSupported() This method returns true if the server supports 4 byte length/offset field of string table (Col names)
`boolean` `is90303()` is90303 This function returns true if the server is 9.0303.
`boolean` `is9301()` is90301 This function returns true if the server is 9.0301.
`boolean` `isANSI()` Is the database ANSI?
`boolean` `isANSIJoin()` isANSIJoin This method returns true if the server can understand the ANSI join syntax (7.31 & 9.2).
`boolean` `isAutoFree()` Returns true if the server supports AutoFree feature
`boolean` `isAutoGeneratedKeysSupported()` isAutoGeneratedKeysSupported This method returns true if the server supports autoGeneratedKeys
`boolean` `isBigintSupported()` isBigIntSupported This method returns true if the server supports Bigint/ Bigserial
`boolean` `isClosed()` Check if a Connection is closed
`boolean` `isCommitEnabled()`
`protected boolean` `isCommitNeeded()`
`boolean` `isDbOpen()` Is there a database associated with the current connection?
`boolean` `isDelimIdentSet()` isDelimIdentSet This method provides access for the variable delimIdent for the IfxDatabaseMetaData class.
`boolean` `isDescribeInputSupported()` isDescribeInputSupported This method returns true if the server supports DESCRIBE INPUT
`boolean` `isDirect()` Whether this is a server-side (direct) connection.
`boolean` `isFPDescribeSupported()` isFPDescribeSupported This method returns true if the server supports FastPath Describe
`boolean` `isGLS()` isGLS This method returns true if the server is GLS capable (7.2+).
`boolean` `isHDREnabled()` Test if the HDR mode on connection
`boolean` `isIEEEM()` isIEEEM Is the server we are connected to on IEEEM format?
`boolean` `isInUserTransaction()` Check if the connection is currently in user transaction.
`boolean` `IsLastCommittedSupported()` Returns true if server supportsLast Committed
`boolean` `isLongID()` Is the server connected to suppors Long ID?
`boolean` `isLvcGtThan2kSupported()` isLvcGtThan2kSupported This method returns true if the server supports >2k LVARCHAR Implemented in 9.40 and onwards.
`boolean` `isMultipleUdrInOutSupported()` isMultipleUdrInOutSupported This method returns true if the server supports inout mode parameters
`boolean` `isMultipleUdrOutSupported()`
`boolean` `isNamedParametersSupported()` isNamedParametersSupported This method returns true if the server supports NamedParameters
`boolean` `isOnLine()` isOnLine This method returns true if the server is online.
`boolean` `isOnLine5SER()`
`boolean` `isPAMAuthentication()`
`boolean` `isPrivateServerEnabled()`
`boolean` `isReadOnly()` Test if the connection is in read-only mode
`boolean` `isRemove64KLimitSupported()` isRemove64KLimitSupported This method returns true if the server supports Removal of 64K Limit
`boolean` `isReplCheckColumnEnabled()`
`boolean` `isSavepointSupported()` isSavepointSupported This method returns true if the server supports Savepoint
`boolean` `isSQBatchSupported()` isSQBatchSupported This method returns true if the server supports SQBATCH
`boolean` `isSysmaster()` isSysmaster This function returns true if sysmaster should be available, (6.0+ and online), false otherwise (se or 5.x).
`boolean` `isUSVER()` isUSVER This function returns true if the server is 9.0+.
`boolean` `isValid(int timeout)` JDBC 4.0 API implementation to work with JDBC 3.0 compliant driver Returns true if the connection has not been closed and is still valid.
`boolean` `isWrapperFor(java.lang.Class<?> iface)`
`boolean` `isXAConnection()` Returns true if the connection is XA as opposed to plain.
`boolean` `isXPS()` isXPS This function returns true if connecting to XPS server.
`boolean` `isXPSVER8_40()` Is the server connected to an 840 server?
`boolean` `isXPSVER8_50()` isXPS This function returns true if connecting to XPS 8.5 + server
`java.lang.Object` `loadUDTba(int xid, byte[] modeba, byte[] nameba, byte[] ownerba, short IfxType, int source, int sourceLength)` IfxSqliConnect.loadUDTba() Called from server jdbc to prepare for a call to loadUDT
`boolean` `lockSession()` lockSession Put the connection in critical session so no other thread can initiate any message exchange to the server.
`boolean` `lockSession(long timeout)`
`protected void` `markCursorsToClosed(boolean checkStmtType)`
`protected void` `markStatementAsReleased()`
`java.lang.String` `nativeSQL(java.lang.String sql)` A driver may convert the JDBC sql grammar into its system's native SQL grammar prior to sending it; nativeSQL returns the native form of the statement that the driver would have sent.
`java.lang.String[]` `parseIfxLocale(java.lang.String glsOrNLSLocale)` This method parses a string specifying a locale in GLS or NLS form and returns a String array with 2 elements in it.
`java.sql.CallableStatement` `prepareCall(java.lang.String sql)` A SQL stored procedure call statement is handled by creating a CallableStatement for it.
`java.sql.CallableStatement` `prepareCall(java.lang.String sql, int resultSetType, int resultSetConcurrency)` JDBC 2.0 Same as prepareCall() above, but allows the default result set type and result set concurrency type to be overridden.
`java.sql.CallableStatement` `prepareCall(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql)` A SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object.
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql, int autoGeneratedKeys)`
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql, int[] columnIndexes)`
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency)` JDBC 2.0 Same as prepareStatement() above, but allows the default result set type and result set concurrency type to be overridden.
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`java.sql.PreparedStatement` `prepareStatement(java.lang.String sql, java.lang.String[] columnNames)`
`void` `releaseBlob()`
`void` `releaseSavepoint(java.sql.Savepoint savepoint)`
`java.lang.Object` `removeFromBlobTable(java.lang.Integer hashKey)`
`protected void` `removeFromStmtList(IfxStatement stmt)`
`protected void` `removeSavepointFromList(java.sql.Savepoint savepoint)`
`protected void` `resetDatabaseProperties()`
`java.lang.String` `retCapName(java.lang.String capName)`
`java.lang.String` `returnEnc()`
`void` `rollback()` Rollback drops all changes made since the previous commit/rollback and releases any database locks currently held by the Connection.
`void` `rollback(java.sql.Savepoint savepoint)`
`void` `scrubConnection()` Called to return a connection to its original state.
`boolean` `scrubConnectionReleasesAllStatements()` Called to determine if calling scrubConnection() will release all Statements.
`void` `setAutoCommit(boolean newAC)` If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual transactions.
`void` `setCatalog(java.lang.String catalog)` A sub-space of this Connection's database may be selected by setting a catalog name.
`void` `setClientInfo(java.util.Properties properties)`
`void` `setClientInfo(java.lang.String name, java.lang.String value)`
`void` `setCommitEnabled(boolean flag)`
`void` `setDatabaseProductVersion(java.lang.String dbVersion)`
`void` `setFPCacheInfo(int routineId, java.lang.String signature, com.informix.jdbc.IfxFParam fparam)` Store fastpath function information.
`void` `setHoldability(int holdability)` Changes the holdability of ResultSet objects created using this Connection object to the given holdability
`void` `setIFX_USEPUT(boolean enable)`
`void` `setIsBigInt(boolean flag)` This function will set and get value based on colinfo information
`void` `setIsBigSerial(boolean flag)`
`protected void` `setLocale(java.lang.String cl)` Called only by IfxDirectConnection to default clLocale/dbLocale to english so dateUtil doesn't use Locale.getDefault() which if Japanese is run, becomes japanese, even tho we are running english tests
`void` `setNetworkTimeout(java.util.concurrent.Executor executor, int milliseconds)`
`protected java.util.Properties` `SetPrimEVars()`
`void` `setReadOnly(boolean mode)` You can put a connection in read-only mode as a hint to enable database optimizations.
`void` `setReplCheckColumnEnabled(boolean flag)`
`java.sql.Savepoint` `setSavepoint()`
`java.sql.Savepoint` `setSavepoint(java.lang.String name)`
`java.sql.Savepoint` `setSavepointUnique(java.lang.String name)`
`void` `setSchema(java.lang.String schema)`
`void` `setServerIsolationLevel()`
`void` `setStructInfo(java.lang.Object obj_udtInfo, short seqno, short levelno, short parentno, byte[] fieldnameba, short fieldno, short type, short length, int xid, byte[] xidOwnerba, byte[] xidNameba)` IfxSqliConnect.setStructInfo()
`void` `setTransactionIsolation(int level)` You can call this method to try to change the transaction isolation level on a newly opened connection, using one of the TRANSACTION_* values.
`protected void` `setTxnIsolationLvl(java.lang.String sql)`
`void` `setTypeMap(java.util.Map<java.lang.String,java.lang.Class<?>> map)` JDBC 2.0 Install a type-map object as the default type-map for this connection.
`protected void` `startMetaDataQuery()`
`boolean` `unlockSession()` unLockSession Release the connection critical session so other thread can initiate message exchange to the server.
`<T> T` `unwrap(java.lang.Class<T> iface)`
`void` `xaSetSerWarnFlags(short flags, java.lang.String name)`

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

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

### Field Detail

#### GclEnv

    public static boolean GclEnv

#### ConnEst

    public static boolean ConnEst

#### fileList

    protected java.util.Vector<java.io.File> fileList

#### implicitCache

    protected final PreparedStatementCache implicitCache

#### HASLOG

    public static final short HASLOG

See Also:
  Constant Field Values

#### ANSIMODE

    protected static final short ANSIMODE

See Also:
  Constant Field Values

#### ANSIWARN

    public static final short ANSIWARN

See Also:
  Constant Field Values

#### isOpen

    public boolean isOpen

#### softCloseDone

    protected boolean softCloseDone

#### externalVersion

    protected java.lang.String externalVersion

#### productName

    protected java.lang.String productName

#### asfconn

    protected Connection asfconn

#### javatoifx

    protected JavaToIfxType javatoifx

#### ifxtojava

    protected IfxToJavaType ifxtojava

#### encoption

    protected boolean encoption

#### proto

    protected IfxProtocol proto

#### connInfo

    protected java.util.Properties connInfo

#### userName

    protected java.lang.String userName

#### dbName

    protected java.lang.String dbName

#### freeclobwithrs

    protected boolean freeclobwithrs

#### Noansiwarn

    protected boolean Noansiwarn

#### delimIdent

    protected boolean delimIdent

#### ifxAllowOut

    protected boolean ifxAllowOut

#### useCaseCapName

    protected boolean useCaseCapName

#### usePut

    protected boolean usePut

#### protoClassName

    protected java.lang.String protoClassName

#### stmtList

    protected java.util.Vector<com.informix.jdbc.IfxSqliConnect.StmtList> stmtList

#### socketTimedOut

    protected boolean socketTimedOut

#### stmtReferenceQueue

    protected java.lang.ref.ReferenceQueue<IfxStatement> stmtReferenceQueue

Each connection has its own reference queue of statements with weak references that have been closed.

#### queueOfConnections

    protected static final java.util.concurrent.BlockingQueue<DelayedWeakReference<IfxSqliConnect>> queueOfConnections

All connections instances share a single delay queue and cleaner thread. The `IfxSqliConnect` constructor(s) register each instance with the queue of connections.

#### cleaner

    protected static java.util.concurrent.ExecutorService cleaner

#### stmtWeakReferenceCloseCount

    protected static java.util.concurrent.atomic.AtomicLong stmtWeakReferenceCloseCount

#### cleanerZeroPointPercentage

    protected final int cleanerZeroPointPercentage

#### cleanerMinimumDelay

    protected final long cleanerMinimumDelay

#### cleanerMaximumDelay

    protected final long cleanerMaximumDelay

#### replCheck

    protected boolean replCheck

#### svptList

    protected java.util.ArrayList<java.lang.ref.WeakReference<java.sql.Savepoint>> svptList

#### preparedStatementCount

    protected final java.util.concurrent.atomic.AtomicInteger preparedStatementCount

#### preparedStatementReusedCount

    protected final java.util.concurrent.atomic.AtomicInteger preparedStatementReusedCount

#### preparedStatementClosedCount

    protected final java.util.concurrent.atomic.AtomicInteger preparedStatementClosedCount

#### jdbcGeneratedSavepointId_

    public int jdbcGeneratedSavepointId_

#### jdbcGeneratedSavepointNamePrefix__

    public static final java.lang.String jdbcGeneratedSavepointNamePrefix__

See Also:
  Constant Field Values

### Constructor Detail

#### IfxSqliConnect

    public IfxSqliConnect()
                   throws java.sql.SQLException

Constructor for the connection class: No parameter version is for the server side sub-class to this class to construct w/o opening an ASF connection Parameter version is the normal SQLI way.

Throws:
  `java.sql.SQLException`

#### IfxSqliConnect

    public IfxSqliConnect(java.lang.String luser,
                  java.lang.String lpasswd,
                  java.lang.String url,
                  java.util.Properties prop)
                   throws java.sql.SQLException

Constructor for the connection class:

Throws:
  `java.sql.SQLException`

### Method Detail

#### removeFromBlobTable

    public java.lang.Object removeFromBlobTable(java.lang.Integer hashKey)

#### doesBlobNeedPurge

    public boolean doesBlobNeedPurge()

#### isDirect

    public boolean isDirect()

Description copied from interface: `IfxConnection`
Whether this is a server-side (direct) connection.

Specified by:
  `isDirect` in interface `IfxConnection`

#### close

    public void close()
               throws java.sql.SQLException

In some cases, it is desirable to immediately release a Connection's database and JDBC resources instead of waiting for them to be automatically released; the close method provides this immediate release.

Note: A Connection is automatically closed when it is garbage collected. Certain fatal errors also result in a closed Connection.

Specified by:
  `close` in interface `java.lang.AutoCloseable`
Specified by:
  `close` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### isClosed

    public boolean isClosed()
                     throws java.sql.SQLException

Check if a Connection is closed

Specified by:
  `isClosed` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### scrubConnection

    public void scrubConnection()
                         throws java.sql.SQLException

Description copied from interface: `IfmxConnection`

Called to return a connection to its original state. scrubConnection() will retain all Statements and reset the connection to its original state. Prior to 2.21.JC3 version, this fuction releases all the Statements and reset the connection to its original state. To determine if Statements are released call scrubConnectionReleasesAllStatements()

Specified by:
  `scrubConnection` in interface `IfmxConnection`
Throws:
  `java.sql.SQLException`

#### clearTransactions

    protected void clearTransactions(boolean rollbackXids)
                              throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### closeAllResultSets

    protected void closeAllResultSets()
                               throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### resetDatabaseProperties

    protected void resetDatabaseProperties()
                                    throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### closeAllStatements

    protected void closeAllStatements()
                               throws java.sql.SQLException

Close all statements for this connection This method is called from the close method of reusable connection

Throws:
  `java.sql.SQLException`

#### scrubConnectionReleasesAllStatements

    public boolean scrubConnectionReleasesAllStatements()

Called to determine if calling scrubConnection() will release all Statements. Note: this method always return false

Specified by:
  `scrubConnectionReleasesAllStatements` in interface `IfmxConnection`
Returns:
  true if Statements are released and false otherwise.

#### commit

    public void commit()
                throws java.sql.SQLException

Commit makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled.

If the current database does not support transactions, an SQLException is thrown.

Uses the IfxProtocol class's executeCommit() method to do the actual committing.

Specified by:
  `commit` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### rollback

    public void rollback()
                  throws java.sql.SQLException

Rollback drops all changes made since the previous commit/rollback and releases any database locks currently held by the Connection. This method should only be used when auto commit has been disabled.

If the current database does not support transactions, an SQLException is thrown.

Uses the IfxProtocol class's executeRollback() method to do the actual rollback.

Specified by:
  `rollback` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setAutoCommit

    public void setAutoCommit(boolean newAC)
                       throws java.sql.SQLException

If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual transactions. Otherwise, its SQL statements are grouped into transactions that are terminated by either commit() or rollback().

By default, new connections are in auto-commit mode. The commit occurs when the statement completes or the next execute occurs, whichever comes first. In the case of statements returning a ResultSet, the statement completes when the last row of the ResultSet has been retrieved or the ResultSet has been closed. In advanced cases, a single statement may return multiple results as well as output parameter values. Here the commit occurs when all results and output param values have been retrieved.

If the database type doesn't support transactions, throw an exception.

Specified by:
  `setAutoCommit` in interface `java.sql.Connection`
Parameters:
  `autoCommit` - true enables auto-commit; false disables auto-commit.
Throws:
  `java.sql.SQLException`

#### getAutoCommit

    public boolean getAutoCommit()
                          throws java.sql.SQLException

Get the current auto-commit state. If you are connected to an ANSI database, by default autoCommit is off and autoCommit is not supported.

Specified by:
  `getAutoCommit` in interface `java.sql.Connection`
Returns:
  Current state of auto-commit mode.
Throws:
  `java.sql.SQLException`
See Also:
  `setAutoCommit(boolean)`

#### clearWarnings

    public void clearWarnings()
                       throws java.sql.SQLException

After this call getWarnings returns null until a new warning is reported for this Connection.

Specified by:
  `clearWarnings` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### returnEnc

    public java.lang.String returnEnc()

#### getWarnings

    public java.sql.SQLWarning getWarnings()
                                    throws java.sql.SQLException

The first warning reported by calls on this Connection is returned.

Note: Subsequent warnings will be chained to this SQLWarning.

Specified by:
  `getWarnings` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createStatement

    public java.sql.Statement createStatement()
                                       throws java.sql.SQLException

SQL statements without parameters are normally executed using Statement objects. If the same SQL statement is executed many times it is more efficient to use a PreparedStatement

Specified by:
  `createStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createStatement

    public java.sql.Statement createStatement(int resultSetType,
                                     int resultSetConcurrency)
                                       throws java.sql.SQLException

JDBC 2.0 Same as createStatement() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
  `createStatement` in interface `java.sql.Connection`
Parameters:
  `resultSetType` - a result set type, see ResultSet.TYPE_XXX
  `resultSetConcurrency` - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
  a new Statement object
Throws:
  `java.sql.SQLException` - if a database-access error occurs.

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql)
                                                throws java.sql.SQLException

A SQL statement with or without IN parameters can be pre-compiled and stored in a PreparedStatement object. This object can then be used to efficiently execute this statement multiple times.

Note: This method is optimized for handling parametric SQL statements that benefit from precompilation. If the driver supports precompilation, prepareStatement will send the statement to the database for precompilation. Some drivers may not support precompilation. In this case, the statement may not be sent to the database until the PreparedStatement is executed. This has no direct affect on users; however, it does affect which method throws certain SQLExceptions.

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Parameters:
  `sql` - a SQL statement that may contain one or more '?' IN parameter placeholders
Returns:
  a new PreparedStatement object containing the pre-compiled statement
Throws:
  `java.sql.SQLException`

#### getCachedPreparedStatement

    protected IfxPreparedStatement getCachedPreparedStatement(java.lang.String sql,
                                                  int resultSetType,
                                                  int resultSetConcurrency,
                                                  int resultSetHoldability)
                                                       throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                              int autoGeneratedKeys)
                                                throws java.sql.SQLException

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                              int[] columnIndexes)
                                                throws java.sql.SQLException

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                              java.lang.String[] columnNames)
                                                throws java.sql.SQLException

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                              int resultSetType,
                                              int resultSetConcurrency)
                                                throws java.sql.SQLException

JDBC 2.0 Same as prepareStatement() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Parameters:
  `resultSetType` - a result set type, see ResultSet.TYPE_XXX
  `resultSetConcurrency` - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
  a new PreparedStatement object containing the pre-compiled SQL statement
Throws:
  `java.sql.SQLException` - if a database-access error occurs.

#### prepareCall

    public java.sql.CallableStatement prepareCall(java.lang.String sql)
                                           throws java.sql.SQLException

A SQL stored procedure call statement is handled by creating a CallableStatement for it. The CallableStatement provides methods for setting up its IN and OUT parameters, and methods for executing it.

Note: This method is optimized for handling stored procedure call statements. Some drivers may send the call statement to the database when the prepareCall is done; others may wait until the CallableStatement is executed. This has no direct affect on users; however, it does affect which method throws certain SQLExceptions.

Specified by:
  `prepareCall` in interface `java.sql.Connection`
Parameters:
  `sql` - a SQL statement that may contain one or more '?' parameter placeholders
Returns:
  a new CallableStatement object containing the pre-compiled SQL statement
Throws:
  `java.sql.SQLException`

#### prepareCall

    public java.sql.CallableStatement prepareCall(java.lang.String sql,
                                         int resultSetType,
                                         int resultSetConcurrency)
                                           throws java.sql.SQLException

JDBC 2.0 Same as prepareCall() above, but allows the default result set type and result set concurrency type to be overridden.

Specified by:
  `prepareCall` in interface `java.sql.Connection`
Parameters:
  `resultSetType` - a result set type, see ResultSet.TYPE_XXX
  `resultSetConcurrency` - a concurrency type, see ResultSet.CONCUR_XXX
Returns:
  a new CallableStatement object containing the pre-compiled SQL statement
Throws:
  `java.sql.SQLException` - if a database-access error occurs.

#### getTypeMap

    public java.util.Map getTypeMap()
                             throws java.sql.SQLException

JDBC 2.0 Get the type-map object associated with this connection. By default, the map returned is empty.

Specified by:
  `getTypeMap` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setTypeMap

    public void setTypeMap(java.util.Map<java.lang.String,java.lang.Class<?>> map)
                    throws java.sql.SQLException

JDBC 2.0 Install a type-map object as the default type-map for this connection.

Specified by:
  `setTypeMap` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### nativeSQL

    public java.lang.String nativeSQL(java.lang.String sql)
                               throws java.sql.SQLException

A driver may convert the JDBC sql grammar into its system's native SQL grammar prior to sending it; nativeSQL returns the native form of the statement that the driver would have sent.

Keywords:

d (date) Format: {d 'yyyy-mm-dd'}

t (time) Format: {t 'hh:mm:ss'}

ts (timestamp) Format: {ts 'yyyy-mm-dd hh:mm:ss.f...}

fn (scalar functions) Format: {fn <function call> }

escape (escape character) Format: {escape ''}

oj (outer join) Format: {oj } =

LEFT OUTER JOIN [ table | ] on

call (call a func/proc) Format: {call <proc>[(?,?...)]}

{? = call <proc>[(?,?...)]}

Specified by:
  `nativeSQL` in interface `java.sql.Connection`
Parameters:
  `sql` - a SQL statement that may contain one or more '?' parameter placeholders
Throws:
  `java.sql.SQLException`

#### getMetaData

    public java.sql.DatabaseMetaData getMetaData()
                                          throws java.sql.SQLException

A Connection's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, etc. This information is made available through a DatabaseMetaData object.

The IfxDatabaseMetaData object requires the this pointer because it needs the connection object to run queries on the current database (system tables).

Specified by:
  `getMetaData` in interface `java.sql.Connection`
Returns:
  a DatabaseMetaData object for this Connection
Throws:
  `java.sql.SQLException`

#### setCatalog

    public void setCatalog(java.lang.String catalog)
                    throws java.sql.SQLException

A sub-space of this Connection's database may be selected by setting a catalog name. If the driver does not support catalogs it will silently ignore this request.

IfxSqliConnect class does not support catalogs. You can still get the information from the 'catalog' through the IfxDatabaseMetaData object. The methods in that class run queries on system catalogs to retreive the desired info.

Specified by:
  `setCatalog` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getCatalog

    public java.lang.String getCatalog()
                                throws java.sql.SQLException

Return the Connection's current catalog name

The current catalog name is defined to be the current database name.

Specified by:
  `getCatalog` in interface `java.sql.Connection`
Returns:
  the current catalog name or null
Throws:
  `java.sql.SQLException`

#### setReadOnly

    public void setReadOnly(boolean mode)
                     throws java.sql.SQLException

You can put a connection in read-only mode as a hint to enable database optimizations.

IfxSqliConnect doesn't support read-only mode. Return without doing anything.

Note: setReadOnly cannot be called while in the middle of a transaction.

Specified by:
  `setReadOnly` in interface `java.sql.Connection`
Parameters:
  `readOnly` - true enables read-only mode; false disables read-only mode.
Throws:
  `java.sql.SQLException`

#### isReadOnly

    public boolean isReadOnly()
                       throws java.sql.SQLException

Test if the connection is in read-only mode

Specified by:
  `isReadOnly` in interface `java.sql.Connection`
Returns:
  true if connection is read-only
Throws:
  `java.sql.SQLException`

#### getHDRType

    public java.lang.String getHDRType()
                                throws java.sql.SQLException

get the HDR server type of the connection 'primary|secondary|standard'

Specified by:
  `getHDRType` in interface `IfmxConnection`
Returns:
  server type
Throws:
  `java.sql.SQLException`

#### isHDREnabled

    public boolean isHDREnabled()
                         throws java.sql.SQLException

Test if the HDR mode on connection

Specified by:
  `isHDREnabled` in interface `IfmxConnection`
Returns:
  true if connection is read-only
Throws:
  `java.sql.SQLException`

#### getMaxLvarcharSize

    public int getMaxLvarcharSize()
                           throws java.sql.SQLException

Description copied from interface: `IfxConnection`
Gets maximum size of LVARCHAR supported by server connected to.

Specified by:
  `getMaxLvarcharSize` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### setTransactionIsolation

    public void setTransactionIsolation(int level)
                                 throws java.sql.SQLException

You can call this method to try to change the transaction isolation level on a newly opened connection, using one of the TRANSACTION_* values.

Note: setTransactionIsolation can be called while in the middle of a transaction. In this case, the existing transaction is first committed.

Specified by:
  `setTransactionIsolation` in interface `java.sql.Connection`
Parameters:
  `level` - one of the TRANSACTION_* isolation values with the exception of TRANSACTION_NONE; some databases may not support other values
Throws:
  `java.sql.SQLException`
See Also:
  `DatabaseMetaData.supportsTransactionIsolationLevel(int)`

#### getTransactionIsolation

    public int getTransactionIsolation()
                                throws java.sql.SQLException

Get this Connection's current transaction isolation mode

Specified by:
  `getTransactionIsolation` in interface `java.sql.Connection`
Returns:
  the current TRANSACTION_* mode value
Throws:
  `java.sql.SQLException`

#### getDatabaseType

    public int getDatabaseType()
                        throws java.sql.SQLException

Description copied from interface: `IfxConnection`
What is the database type? NO_DATABASE, ANSI_MODE, LOGGING or NON_LOGGING?

Specified by:
  `getDatabaseType` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### isDbOpen

    public boolean isDbOpen()
                     throws java.sql.SQLException

Is there a database associated with the current connection?

Specified by:
  `isDbOpen` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### getConnectionDbName

    public java.lang.String getConnectionDbName()
                                         throws java.sql.SQLException

Return current *Internal* name of database (can be null) This method is primarily for IfxDirectProtocol and executeCloseDatabase to find out if we have a db or server connection. Sqli can't close an explicitly opened database

Throws:
  `java.sql.SQLException`

#### getDbName

    public java.lang.String getDbName()
                               throws java.sql.SQLException

Return current name of database (can be null)

Specified by:
  `getDbName` in interface `IfxConnection`
Returns:
  Name of the database in a String.
Throws:
  `java.sql.SQLException`

#### getURL

    public java.lang.String getURL()
                            throws java.sql.SQLException

Return the original url (not the <ipaddr>:<portno> url - that is for internal use only

Specified by:
  `getURL` in interface `IfxConnection`
Returns:
  the URL in the connection in a String.
Throws:
  `java.sql.SQLException`

#### getUserName

    public java.lang.String getUserName()
                                 throws java.sql.SQLException

What is the connection's userName?

Specified by:
  `getUserName` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### getJDBCVersion

    public java.lang.String getJDBCVersion()
                                    throws java.sql.SQLException

What is the connection's version?

Specified by:
  `getJDBCVersion` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### getDbProductName

    public java.lang.String getDbProductName()
                                      throws java.sql.SQLException

Gets the product name for this database

Specified by:
  `getDbProductName` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### getDbVersion

    public java.lang.String getDbVersion()
                                  throws java.sql.SQLException

Gets the version for this database

Specified by:
  `getDbVersion` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### SetPrimEVars

    protected java.util.Properties SetPrimEVars()
                                         throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### parseIfxLocale

    public java.lang.String[] parseIfxLocale(java.lang.String glsOrNLSLocale)
                                      throws java.sql.SQLException

This method parses a string specifying a locale in GLS or NLS form and returns a String array with 2 elements in it. The String array contains JDK locale and JDK codeset which maps to the informix or NLS locale string retVal[IfxLocales.LOCALE_INDEX] is the JDK locale retVal[IfxLocales.CODESET_INDEX] is the JDK codeset

Parameters:
  `` -
Returns:
Throws:
  `java.sql.SQLException` - when the locale could not be mapped corresponding JDK codeset and locale.

#### isDelimIdentSet

    public boolean isDelimIdentSet()

isDelimIdentSet This method provides access for the variable delimIdent for the IfxDatabaseMetaData class.

Specified by:
  `isDelimIdentSet` in interface `IfxConnection`

#### isGLS

    public boolean isGLS()

Description copied from interface: `IfxConnection`
isGLS This method returns true if the server is GLS capable (7.2+).

Specified by:
  `isGLS` in interface `IfxConnection`

#### isOnLine

    public boolean isOnLine()

Description copied from interface: `IfxConnection`
isOnLine This method returns true if the server is online. False if server is SE servers.

Specified by:
  `isOnLine` in interface `IfxConnection`

#### isOnLine5SER

    public boolean isOnLine5SER()

#### isLongID

    public boolean isLongID()

Description copied from interface: `IfxConnection`
Is the server connected to suppors Long ID?

Specified by:
  `isLongID` in interface `IfxConnection`

#### is90303

    public boolean is90303()

is90303 This function returns true if the server is 9.0303.

Specified by:
  `is90303` in interface `IfxConnection`

#### is9301

    public boolean is9301()

is90301 This function returns true if the server is 9.0301.

Specified by:
  `is9301` in interface `IfxConnection`

#### isNamedParametersSupported

    public boolean isNamedParametersSupported()

isNamedParametersSupported This method returns true if the server supports NamedParameters

#### isSavepointSupported

    public boolean isSavepointSupported()

isSavepointSupported This method returns true if the server supports Savepoint

#### isSQBatchSupported

    public boolean isSQBatchSupported()

isSQBatchSupported This method returns true if the server supports SQBATCH

#### isRemove64KLimitSupported

    public boolean isRemove64KLimitSupported()

isRemove64KLimitSupported This method returns true if the server supports Removal of 64K Limit

#### is4ByteOffsetSupported

    public boolean is4ByteOffsetSupported()

is4ByteOffsetSupported() This method returns true if the server supports 4 byte length/offset field of string table (Col names)

#### is2GBFetchBufferSupported

    public boolean is2GBFetchBufferSupported()

is2GBFetchBufferSupported This method returns true if the server supports 2GB linit for FET_BUF_SIZE

#### isAutoGeneratedKeysSupported

    public boolean isAutoGeneratedKeysSupported()

isAutoGeneratedKeysSupported This method returns true if the server supports autoGeneratedKeys

#### isDescribeInputSupported

    public boolean isDescribeInputSupported()

isDescribeInputSupported This method returns true if the server supports DESCRIBE INPUT

#### isFPDescribeSupported

    public boolean isFPDescribeSupported()

isFPDescribeSupported This method returns true if the server supports FastPath Describe

#### isMultipleUdrInOutSupported

    public boolean isMultipleUdrInOutSupported()

isMultipleUdrInOutSupported This method returns true if the server supports inout mode parameters

#### isLvcGtThan2kSupported

    public boolean isLvcGtThan2kSupported()

isLvcGtThan2kSupported This method returns true if the server supports >2k LVARCHAR Implemented in 9.40 and onwards.

Specified by:
  `isLvcGtThan2kSupported` in interface `IfxConnection`

#### isANSIJoin

    public boolean isANSIJoin()

isANSIJoin This method returns true if the server can understand the ANSI join syntax (7.31 & 9.2).

Specified by:
  `isANSIJoin` in interface `IfxConnection`

#### isXPSVER8_40

    public boolean isXPSVER8_40()

Description copied from interface: `IfxConnection`
Is the server connected to an 840 server?

Specified by:
  `isXPSVER8_40` in interface `IfxConnection`

#### isUSVER

    public boolean isUSVER()

isUSVER This function returns true if the server is 9.0+.

Specified by:
  `isUSVER` in interface `IfxConnection`

#### isXPS

    public boolean isXPS()

isXPS This function returns true if connecting to XPS server.

Specified by:
  `isXPS` in interface `IfxConnection`
Returns:
  true if yes, false otherwise.

#### isXPSVER8_50

    public boolean isXPSVER8_50()

isXPS This function returns true if connecting to XPS 8.5 + server

Specified by:
  `isXPSVER8_50` in interface `IfxConnection`

#### isIEEEM

    public boolean isIEEEM()

isIEEEM Is the server we are connected to on IEEEM format?

Specified by:
  `isIEEEM` in interface `IfxConnection`

#### isSysmaster

    public boolean isSysmaster()

isSysmaster This function returns true if sysmaster should be available, (6.0+ and online), false otherwise (se or 5.x).

Specified by:
  `isSysmaster` in interface `IfxConnection`

#### isAutoFree

    public boolean isAutoFree()

Description copied from interface: `IfxConnection`
Returns true if the server supports AutoFree feature

Specified by:
  `isAutoFree` in interface `IfxConnection`

#### isPrivateServerEnabled

    public boolean isPrivateServerEnabled()

#### isMultipleUdrOutSupported

    public boolean isMultipleUdrOutSupported()

#### isPAMAuthentication

    public boolean isPAMAuthentication()

#### getMapFloat

    public boolean getMapFloat()

Description copied from interface: `IfxConnection`
Is JDBC type FLOAT mapped to Informix type Float

Specified by:
  `getMapFloat` in interface `IfxConnection`

#### getMapReal

    public boolean getMapReal()

Description copied from interface: `IfxConnection`
Is Informix type Smallfloat reported as JDBC type REAL

Specified by:
  `getMapReal` in interface `IfxConnection`

#### getTrace

    public Trace getTrace()

getTrace Return the trace object instantiated in the IfxSqliConnect constructor. Note that if no trace arguments are passed via the URL, an empty trace object is still created.

Specified by:
  `getTrace` in interface `IfxConnection`

#### getProtoTrace

    public Trace getProtoTrace()

getProtoTrace Return the protocol trace object instantiated in the IfxSqliConnect constructor.

Specified by:
  `getProtoTrace` in interface `IfxConnection`

#### lockSession

    public boolean lockSession()

lockSession Put the connection in critical session so no other thread can initiate any message exchange to the server. This is neccessary in the multi-thread environment since the message exchange between client and server need to be atomic for each message. It will block until it can acquire the lock or timed out. In lockSession(), it'll silently check on the lock every 60 seconds to see if the thread holding the lock are still valid. If not, that means some thread had died and we'll return to avoid dead lock situation.

#### lockSession

    public boolean lockSession(long timeout)

#### unlockSession

    public boolean unlockSession()

unLockSession Release the connection critical session so other thread can initiate message exchange to the server.

#### getGeneratedCursor

    public java.lang.String getGeneratedCursor()

Specified by:
  `getGeneratedCursor` in interface `IfxConnection`

#### getProtoClassName

    public java.lang.String getProtoClassName()

Description copied from interface: `IfxConnection`
What is the name of the protocol class?

Specified by:
  `getProtoClassName` in interface `IfxConnection`

#### getConnClassName

    public java.lang.String getConnClassName()

Description copied from interface: `IfxConnection`
What is the name of the connection class?

Specified by:
  `getConnClassName` in interface `IfxConnection`

#### addUDTInfo

    protected IfxUDTInfo addUDTInfo(java.lang.String udtOwner,
                        java.lang.String udtName)
                             throws java.sql.SQLException

IfxSqliConnect.addUDTInfo() Access the sysxtdtypes and sysattrtypes system catalogs and add these entries to udtMap if useCacheMap is set to true. It looks for a specific entry.

Throws:
  `java.sql.SQLException`

#### loadUDTba

    public java.lang.Object loadUDTba(int xid,
                             byte[] modeba,
                             byte[] nameba,
                             byte[] ownerba,
                             short IfxType,
                             int source,
                             int sourceLength)
                               throws java.sql.SQLException

IfxSqliConnect.loadUDTba() Called from server jdbc to prepare for a call to loadUDT

Throws:
  `java.sql.SQLException`

#### setStructInfo

    public void setStructInfo(java.lang.Object obj_udtInfo,
                     short seqno,
                     short levelno,
                     short parentno,
                     byte[] fieldnameba,
                     short fieldno,
                     short type,
                     short length,
                     int xid,
                     byte[] xidOwnerba,
                     byte[] xidNameba)
                       throws java.sql.SQLException

IfxSqliConnect.setStructInfo()

Throws:
  `java.sql.SQLException`

#### getUDTInfo

    public IfxUDTInfo getUDTInfo(IfxColumnInfo colinfo)
                          throws java.sql.SQLException

IfxSqliConnect.getUDTInfo(colinfo) Load up udt medadata using the column metadata, used by direct connections only.

Throws:
  `java.sql.SQLException`

#### getUDTInfo

    public IfxUDTInfo getUDTInfo(IfxColumnInfo colinfo,
                        java.lang.String name)
                          throws java.sql.SQLException

IfxSqliConnect.getUDTInfo(colinfo, typename) Search for this SQLName in udtMap. If it's not found then query the server. colinfo isn't used by the client version of this method.

Specified by:
  `getUDTInfo` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### getUDTInfo

    public IfxUDTInfo getUDTInfo(int xid)
                          throws java.sql.SQLException

Get general information about opaque and distinct types and detailed information for complex types.

Specified by:
  `getUDTInfo` in interface `IfmxConnection`
Parameters:
  `xid` - The extended id.
Returns:
  The detailed type information as an Informix IfxUDTInfo.
Throws:
  `java.sql.SQLException`

#### getUDTInfo

    public IfxUDTInfo getUDTInfo(java.lang.String name,
                        java.lang.String owner)
                          throws java.sql.SQLException

Get general information about opaque and distinct types and detailed information for complex types.

Specified by:
  `getUDTInfo` in interface `IfmxConnection`
Parameters:
  `name` - The data type name.
  `owner` - The owner of the data type (can be null).
Returns:
  The detailed type information as an Informix IfxUDTInfo.
Throws:
  `java.sql.SQLException`

#### getAutoFree

    public boolean getAutoFree()

#### getOPTOFC

    public boolean getOPTOFC()

Returns true if OPTOFC=1 is set by the user.

Returns:

#### getUsePut

    public boolean getUsePut()

#### getIFX_USEPUT

    public boolean getIFX_USEPUT()
                          throws java.sql.SQLException

Specified by:
  `getIFX_USEPUT` in interface `IfmxConnection`
Throws:
  `java.sql.SQLException`

#### setIFX_USEPUT

    public void setIFX_USEPUT(boolean enable)
                       throws java.sql.SQLException

Specified by:
  `setIFX_USEPUT` in interface `IfmxConnection`
Throws:
  `java.sql.SQLException`

#### getTrimTrailingSpaces

    public boolean getTrimTrailingSpaces()

Description copied from interface: `IfxConnection`
Get TrimTrailingSpaces -- if set, trim trailing spaces in IfxChar.fromIfx().

Specified by:
  `getTrimTrailingSpaces` in interface `IfxConnection`

#### getBlobCacheSize

    public int getBlobCacheSize()

Specified by:
  `getBlobCacheSize` in interface `IfxConnection`

#### finalize

    protected void finalize()

Overrides:
  `finalize` in class `java.lang.Object`

#### getdbDate

    public java.lang.String getdbDate()

Specified by:
  `getdbDate` in interface `IfxConnection`

#### getglDate

    public java.lang.String getglDate()

Specified by:
  `getglDate` in interface `IfxConnection`

#### getdbTime

    public java.lang.String getdbTime()

Specified by:
  `getdbTime` in interface `IfxConnection`

#### getglDateTime

    public java.lang.String getglDateTime()

Specified by:
  `getglDateTime` in interface `IfxConnection`

#### getclLocaleProp

    public boolean getclLocaleProp()

Specified by:
  `getclLocaleProp` in interface `IfxConnection`

#### getdbLocaleProp

    public boolean getdbLocaleProp()

Specified by:
  `getdbLocaleProp` in interface `IfxConnection`

#### getuseDtenv

    public boolean getuseDtenv()

Specified by:
  `getuseDtenv` in interface `IfxConnection`

#### getdbCentury

    public java.lang.String getdbCentury()

Specified by:
  `getdbCentury` in interface `IfxConnection`

#### getdbLocale

    public java.lang.String getdbLocale()

Description copied from interface: `IfxConnection`
Gets the DB_LOCALE locale for connection

Specified by:
  `getdbLocale` in interface `IfxConnection`

#### getdbEncoding

    public java.lang.String getdbEncoding()

Description copied from interface: `IfxConnection`
Gets the DB_LOCALE encoding for connection

Specified by:
  `getdbEncoding` in interface `IfxConnection`

#### getclLocale

    public java.lang.String getclLocale()

Description copied from interface: `IfxConnection`
Gets the CLIENT_LOCALE locale for connection

Specified by:
  `getclLocale` in interface `IfxConnection`

#### setLocale

    protected void setLocale(java.lang.String cl)

Called only by IfxDirectConnection to default clLocale/dbLocale to english so dateUtil doesn't use Locale.getDefault() which if Japanese is run, becomes japanese, even tho we are running english tests

#### getclEncoding

    public java.lang.String getclEncoding()

#### getJDBCTempDir

    public java.lang.String getJDBCTempDir()

Description copied from interface: `IfxConnection`
Where the user wants to redirect their temp files

Specified by:
  `getJDBCTempDir` in interface `IfxConnection`

#### isANSI

    public boolean isANSI()

Description copied from interface: `IfxConnection`
Is the database ANSI?

Specified by:
  `isANSI` in interface `IfxConnection`

#### getXnameByXid

    public java.lang.String getXnameByXid(int xid)
                                   throws java.sql.SQLException

Specified by:
  `getXnameByXid` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### xaSetSerWarnFlags

    public void xaSetSerWarnFlags(short flags,
                         java.lang.String name)
                           throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### getProto

    public IfxProtocol getProto()

Description copied from interface: `IfxConnection`
Get the protocol instance for this connection

Specified by:
  `getProto` in interface `IfxConnection`

#### createProto

    public IfxProtocol createProto()

Description copied from interface: `IfxConnection`
Create a new protocol instance for this connection

Specified by:
  `createProto` in interface `IfxConnection`

#### getFetchBufSize

    public int getFetchBufSize()

This method will return the FET_BUF_SIZE value

Specified by:
  `getFetchBufSize` in interface `IfxConnection`

#### getdbTodayDate

    public long getdbTodayDate()

This method will return the dbTodayDate value

Specified by:
  `getdbTodayDate` in interface `IfxConnection`

#### getdbTodayStart

    public long getdbTodayStart()

This method will return the dbTodayStart value

Specified by:
  `getdbTodayStart` in interface `IfxConnection`

#### isXAConnection

    public boolean isXAConnection()

Description copied from interface: `IfxConnection`
Returns true if the connection is XA as opposed to plain.

Specified by:
  `isXAConnection` in interface `IfxConnection`

#### inXATransaction

    public boolean inXATransaction()

Description copied from interface: `IfxConnection`
Returns true if start has been called to begin (or resume) an XA transaction.

Specified by:
  `inXATransaction` in interface `IfxConnection`

#### getFPCacheRoutineId

    public int getFPCacheRoutineId(java.lang.String signature)

Returns a routine's id based on the routine signature.

Specified by:
  `getFPCacheRoutineId` in interface `IfxConnection`
Parameters:
  `signature` - Function signature used as the key to do a look into the fast path cache. If found the routine id will be returned. If not found a -1 will be returned.

#### getFPCacheFParam

    public com.informix.jdbc.IfxFParam getFPCacheFParam(java.lang.String signature)

Returns a routine's fparam structure based on the routine signature.

Specified by:
  `getFPCacheFParam` in interface `IfxConnection`
Parameters:
  `signature` - Function signature used as the key to do a look into the fast path cache. If found the fparam will be returned. If not found a null will be returned.

#### setFPCacheInfo

    public void setFPCacheInfo(int routineId,
                      java.lang.String signature,
                      com.informix.jdbc.IfxFParam fparam)

Store fastpath function information.

Specified by:
  `setFPCacheInfo` in interface `IfxConnection`
Parameters:
  `routineId` - the function id returned by the server.
  `signature` - the routine signature
  `fparam` - the fparam information returned by the server.

#### changeStmtId

    protected void changeStmtId(IfxStatement stmt,
                    int id)

#### markStatementAsReleased

    protected void markStatementAsReleased()

#### markCursorsToClosed

    protected void markCursorsToClosed(boolean checkStmtType)

#### removeFromStmtList

    protected void removeFromStmtList(IfxStatement stmt)

#### freeStatementWeakReferences

    protected void freeStatementWeakReferences()

#### addToBlobList

    public void addToBlobList(IfxSmartBlob x)

#### releaseBlob

    public void releaseBlob()

#### isInUserTransaction

    public boolean isInUserTransaction()

Check if the connection is currently in user transaction.

Returns:
  True if the connection is currently in user transaction. False otherwise.

#### setHoldability

    public void setHoldability(int holdability)
                        throws java.sql.SQLException

Changes the holdability of ResultSet objects created using this Connection object to the given holdability

Specified by:
  `setHoldability` in interface `java.sql.Connection`
Parameters:
  `a` - ResultSet holdability constant; one of ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
Throws:
  `excpetion` - if database error occurs, or if the given parameter is not a ResultSet constant indicating holdability, or the given holdability is not supported
  `java.sql.SQLException`

#### getHoldability

    public int getHoldability()
                       throws java.sql.SQLException

Map holdability to JDBC3.0 values .

Specified by:
  `getHoldability` in interface `java.sql.Connection`
Returns:
Throws:
  `java.sql.SQLException`

#### setSavepoint

    public java.sql.Savepoint setSavepoint()
                                    throws java.sql.SQLException

Specified by:
  `setSavepoint` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setSavepoint

    public java.sql.Savepoint setSavepoint(java.lang.String name)
                                    throws java.sql.SQLException

Specified by:
  `setSavepoint` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setSavepointUnique

    public java.sql.Savepoint setSavepointUnique(java.lang.String name)
                                          throws java.sql.SQLException

Specified by:
  `setSavepointUnique` in interface `IfxConnection`
Throws:
  `java.sql.SQLException`

#### rollback

    public void rollback(java.sql.Savepoint savepoint)
                  throws java.sql.SQLException

Specified by:
  `rollback` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### releaseSavepoint

    public void releaseSavepoint(java.sql.Savepoint savepoint)
                          throws java.sql.SQLException

Specified by:
  `releaseSavepoint` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createStatement

    public java.sql.Statement createStatement(int resultSetType,
                                     int resultSetConcurrency,
                                     int resultSetHoldability)
                                       throws java.sql.SQLException

Specified by:
  `createStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### prepareStatement

    public java.sql.PreparedStatement prepareStatement(java.lang.String sql,
                                              int resultSetType,
                                              int resultSetConcurrency,
                                              int resultSetHoldability)
                                                throws java.sql.SQLException

Specified by:
  `prepareStatement` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### prepareCall

    public java.sql.CallableStatement prepareCall(java.lang.String sql,
                                         int resultSetType,
                                         int resultSetConcurrency,
                                         int resultSetHoldability)
                                           throws java.sql.SQLException

Specified by:
  `prepareCall` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getSQLStatementOffset

    public int getSQLStatementOffset()

Description copied from interface: `IfmxConnection`

Get the error offset of last executed/prepared SQL statement

Specified by:
  `getSQLStatementOffset` in interface `IfmxConnection`
Returns:
  offset of the error into the SQL Statement

#### startMetaDataQuery

    protected void startMetaDataQuery()
                               throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### endMetaDataQuery

    protected void endMetaDataQuery()
                             throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### setServerIsolationLevel

    public void setServerIsolationLevel()
                                 throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### isCommitNeeded

    protected boolean isCommitNeeded()

#### IsLastCommittedSupported

    public boolean IsLastCommittedSupported()

Description copied from interface: `IfxConnection`
Returns true if server supportsLast Committed

Specified by:
  `IsLastCommittedSupported` in interface `IfxConnection`

#### setTxnIsolationLvl

    protected void setTxnIsolationLvl(java.lang.String sql)

#### addToFileList

    public void addToFileList(java.io.File ifxTmp)

#### deleteAllFiles

    protected void deleteAllFiles()
                           throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### removeSavepointFromList

    protected void removeSavepointFromList(java.sql.Savepoint savepoint)
                                    throws java.sql.SQLException

Throws:
  `java.sql.SQLException`

#### isBigintSupported

    public boolean isBigintSupported()

isBigIntSupported This method returns true if the server supports Bigint/ Bigserial

Specified by:
  `isBigintSupported` in interface `IfxConnection`

#### setIsBigInt

    public void setIsBigInt(boolean flag)

Description copied from interface: `IfxConnection`
This function will set and get value based on colinfo information

Specified by:
  `setIsBigInt` in interface `IfxConnection`

#### getIsBigInt

    public boolean getIsBigInt()

Specified by:
  `getIsBigInt` in interface `IfxConnection`

#### setIsBigSerial

    public void setIsBigSerial(boolean flag)

Specified by:
  `setIsBigSerial` in interface `IfxConnection`

#### getIsBigSerial

    public boolean getIsBigSerial()

Specified by:
  `getIsBigSerial` in interface `IfxConnection`

#### isReplCheckColumnEnabled

    public boolean isReplCheckColumnEnabled()

#### setReplCheckColumnEnabled

    public void setReplCheckColumnEnabled(boolean flag)

#### isCommitEnabled

    public boolean isCommitEnabled()

#### setCommitEnabled

    public void setCommitEnabled(boolean flag)

#### createArrayOf

    public java.sql.Array createArrayOf(java.lang.String typeName,
                               java.lang.Object[] elements)
                                 throws java.sql.SQLException

Specified by:
  `createArrayOf` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createBlob

    public java.sql.Blob createBlob()
                             throws java.sql.SQLException

Specified by:
  `createBlob` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createClob

    public java.sql.Clob createClob()
                             throws java.sql.SQLException

Specified by:
  `createClob` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createNClob

    public java.sql.NClob createNClob()
                               throws java.sql.SQLException

Specified by:
  `createNClob` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createSQLXML

    public java.sql.SQLXML createSQLXML()
                                 throws java.sql.SQLException

Specified by:
  `createSQLXML` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### createStruct

    public java.sql.Struct createStruct(java.lang.String typeName,
                               java.lang.Object[] attributes)
                                 throws java.sql.SQLException

Specified by:
  `createStruct` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getClientInfo

    public java.util.Properties getClientInfo()
                                       throws java.sql.SQLException

Specified by:
  `getClientInfo` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getClientInfo

    public java.lang.String getClientInfo(java.lang.String name)
                                   throws java.sql.SQLException

Specified by:
  `getClientInfo` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### isValid

    public boolean isValid(int timeout)
                    throws java.sql.SQLException

Description copied from interface: `IfxConnection`
JDBC 4.0 API implementation to work with JDBC 3.0 compliant driver Returns true if the connection has not been closed and is still valid. The driver shall submit a query on the connection or use some other mechanism that positively verifies the connection is still valid when this method is called. The query submitted by the driver to validate the connection shall be executed in the context of the current transaction. Parameters: timeout - - The time in seconds to wait for the database operation used to validate the connection to complete. If the timeout period expires before the operation completes, this method returns false. A value of 0 indicates a timeout is not applied to the database operation. Returns: true if the connection is valid, false otherwise Throws: SQLException - if the value supplied for timeout is less then 0

Specified by:
  `isValid` in interface `IfxConnection`
Specified by:
  `isValid` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setClientInfo

    public void setClientInfo(java.util.Properties properties)
                       throws java.sql.SQLClientInfoException

Specified by:
  `setClientInfo` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLClientInfoException`

#### setClientInfo

    public void setClientInfo(java.lang.String name,
                     java.lang.String value)
                       throws java.sql.SQLClientInfoException

Specified by:
  `setClientInfo` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLClientInfoException`

#### isWrapperFor

    public boolean isWrapperFor(java.lang.Class<?> iface)
                         throws java.sql.SQLException

Specified by:
  `isWrapperFor` in interface `java.sql.Wrapper`
Throws:
  `java.sql.SQLException`

#### unwrap

    public <T> T unwrap(java.lang.Class<T> iface)
             throws java.sql.SQLException

Specified by:
  `unwrap` in interface `java.sql.Wrapper`
Throws:
  `java.sql.SQLException`

#### retCapName

    public java.lang.String retCapName(java.lang.String capName)

Specified by:
  `retCapName` in interface `IfxConnection`

#### getDatabaseProductVersion

    public java.lang.String getDatabaseProductVersion()

Specified by:
  `getDatabaseProductVersion` in interface `IfxConnection`

#### setDatabaseProductVersion

    public void setDatabaseProductVersion(java.lang.String dbVersion)

#### setSchema

    public void setSchema(java.lang.String schema)
                   throws java.sql.SQLException

Specified by:
  `setSchema` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getSchema

    public java.lang.String getSchema()
                               throws java.sql.SQLException

Specified by:
  `getSchema` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### abort

    public void abort(java.util.concurrent.Executor executor)
               throws java.sql.SQLException

Specified by:
  `abort` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### setNetworkTimeout

    public void setNetworkTimeout(java.util.concurrent.Executor executor,
                         int milliseconds)
                           throws java.sql.SQLException

Specified by:
  `setNetworkTimeout` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`

#### getNetworkTimeout

    public int getNetworkTimeout()
                          throws java.sql.SQLException

Specified by:
  `getNetworkTimeout` in interface `java.sql.Connection`
Throws:
  `java.sql.SQLException`