Class QueryExecutorImpl

java.lang.Object

org.postgresql.core.QueryExecutorBase

org.postgresql.core.v3.QueryExecutorImpl

All Implemented Interfaces:

QueryExecutor, TypeTransferModeRegistry

public class QueryExecutorImpl
extends QueryExecutorBase

QueryExecutor implementation for the V3 protocol.

Field Summary

Fields

Modifier and Type	Field	Description
private final AdaptiveFetchCache	adaptiveFetchCache
private final boolean	allowEncodingChanges
private String	applicationName	application_name connection property.
private final SimpleQuery	autoSaveQuery
private final SimpleQuery	beginReadOnlyTransactionQuery
private final SimpleQuery	beginTransactionQuery
private final boolean	cleanupSavePoints
private final CommandCompleteParser	commandCompleteParser	CommandComplete(B) messages are quite common, so we reuse instance to parse those
private short	deallocateEpoch
private final SimpleQuery	emptyQuery
private int	estimatedReceiveBufferBytes	The estimated server response size since we last consumed the input stream from the server, in bytes.
private boolean	integerDateTimes	True if server uses integers for date and time fields.
private String	lastSetSearchPathQuery	This caches the latest observed set search_path query so the reset of prepared statement cache can be skipped if using repeated calls for the same set search_path value.
private Object	lockedFor	Supplement to synchronization of public methods on current QueryExecutor.
private static final Logger	LOGGER
private static final int	MAX_BUFFERED_RECV_BYTES
private long	nextUniqueID
private static final Field[]	NO_FIELDS
private static final int	NODATA_QUERY_RESPONSE_SIZE_BYTES
private final ReferenceQueue<Portal>	openPortalCleanupQueue
private final HashMap<PhantomReference<Portal>, String>	openPortalMap
private final ReferenceQueue<SimpleQuery>	parsedQueryCleanupQueue
private final HashMap<PhantomReference<SimpleQuery>, String>	parsedQueryMap
private final Deque<Portal>	pendingBindQueue
private final Deque<SimpleQuery>	pendingDescribePortalQueue
private final Deque<DescribeRequest>	pendingDescribeStatementQueue
private final Deque<ExecuteRequest>	pendingExecuteQueue
private final Deque<SimpleQuery>	pendingParseQueue
(package private) AtomicBoolean	processingCopyResults
private final SimpleQuery	releaseAutoSave
private final ReplicationProtocol	replicationProtocol
private final SimpleQuery	restoreToAutoSave
private final SimpleQuery	sync	This is a fake query object so processResults can distinguish "ReadyForQuery" messages from Sync messages vs from simple execute (aka 'Q').
private TimeZone	timeZone	TimeZone of the current connection (TimeZone backend parameter).
private SQLException	transactionFailCause	The exception that caused the last transaction to fail.
private static final Portal	UNNAMED_PORTAL
private final IntSet	useBinaryReceiveForOids	Bit set that has a bit set for each oid which should be received using binary format.
private final IntSet	useBinarySendForOids	Bit set that has a bit set for each oid which should be sent using binary format.

Fields inherited from class QueryExecutorBase

closeAction, lock, lockCondition, logServerErrorDetail, pgStream, protocolVersion

Fields inherited from interface QueryExecutor

MAX_SAVE_POINTS, QUERY_BOTH_ROWS_AND_STATUS, QUERY_DESCRIBE_ONLY, QUERY_DISALLOW_BATCHING, QUERY_EXECUTE_AS_SIMPLE, QUERY_FORCE_DESCRIBE_PORTAL, QUERY_FORWARD_CURSOR, QUERY_NO_BINARY_TRANSFER, QUERY_NO_METADATA, QUERY_NO_RESULTS, QUERY_ONESHOT, QUERY_READ_ONLY_HINT, QUERY_SUPPRESS_BEGIN

Constructor Summary

Constructors

Constructor	Description
QueryExecutorImpl(PGStream pgStream, int cancelSignalTimeout, Properties info)

Method Summary

Modifier and Type	Method	Description
void	addBinaryReceiveOid(int oid)	Adds a single oid that should be received using binary encoding.
void	addBinarySendOid(int oid)	Adds a single oid that should be sent using binary encoding.
void	addQueryToAdaptiveFetchCache(boolean adaptiveFetch, ResultCursor cursor)	Add query to adaptive fetch cache inside QueryExecutor.
void	cancelCopy(CopyOperationImpl op)	Finishes a copy operation and unlocks connection discarding any exchanged data.
ParameterList	createFastpathParameters(int count)	Create a new ParameterList implementation suitable for invoking a fastpath function via QueryExecutor.fastpathCall(int, ParameterList, boolean).
Query	createSimpleQuery(String sql)	Create an unparameterized Query object suitable for execution by this QueryExecutor.
void	doSubprotocolBegin()
long	endCopy(CopyOperationImpl op)	Finishes writing to copy and unlocks connection.
void	execute(Query[] queries, ParameterList[] parameterLists, BatchResultHandler batchHandler, int maxRows, int fetchSize, int flags)	Execute several Query, passing results to a provided ResultHandler.
void	execute(Query[] queries, ParameterList[] parameterLists, BatchResultHandler batchHandler, int maxRows, int fetchSize, int flags, boolean adaptiveFetch)	Execute several Query with adaptive fetch, passing results to a provided ResultHandler.
void	execute(Query query, ParameterList parameters, ResultHandler handler, int maxRows, int fetchSize, int flags)	Execute a Query, passing results to a provided ResultHandler.
void	execute(Query query, ParameterList parameters, ResultHandler handler, int maxRows, int fetchSize, int flags, boolean adaptiveFetch)	Execute a Query with adaptive fetch, passing results to a provided ResultHandler.
byte[]	fastpathCall(int fnid, ParameterList parameters, boolean suppressBegin)	Invoke a backend function via the fastpath interface.
void	fetch(ResultCursor cursor, ResultHandler handler, int fetchSize, boolean adaptiveFetch)	Fetch additional rows from a cursor.
void	flushCopy(CopyOperationImpl op)
private void	flushIfDeadlockRisk(Query query, boolean disallowBatching, ResultHandler resultHandler, BatchResultHandler batchHandler, int flags)
boolean	getAdaptiveFetch()	Get state of adaptive fetch inside QueryExecutor.
int	getAdaptiveFetchSize(boolean adaptiveFetch, ResultCursor cursor)	Get fetch size computed by adaptive fetch size for given query.
String	getApplicationName()	Returns application_name connection property.
Set<? extends Integer>	getBinaryReceiveOids()	Gets the oids that should be received using binary encoding.
Set<? extends Integer>	getBinarySendOids()	Gets the oids that should be sent using binary encoding.
boolean	getIntegerDateTimes()	Returns true if server uses integer instead of double for binary date and time encodings.
ProtocolVersion	getProtocolVersion()
ReplicationProtocol	getReplicationProtocol()
TimeZone	getTimeZone()	Returns backend timezone in java format.
private boolean	hasLock(Object holder)
(package private) boolean	hasLockOn(Object holder)
private void	initCopy(CopyOperationImpl op)	Locks connection and calls initializer for a new CopyOperation Called via startCopy -> processCopyResults.
private void	interpretCommandStatus(String status, ResultHandler handler)
private void	lock(Object obtainer)	Obtain lock over this connection for given object, blocking to wait if necessary.
(package private) CopyOperationImpl	processCopyResults(CopyOperationImpl op, boolean block)	Handles copy sub protocol responses from server.
private void	processDeadParsedQueries()
private void	processDeadPortals()
void	processNotifies()	Prior to attempting to retrieve notifications, we need to pull any recently received notifications off of the network buffers.
void	processNotifies(int timeoutMillis)	Prior to attempting to retrieve notifications, we need to pull any recently received notifications off of the network buffers.
protected void	processResults(ResultHandler handler, int flags)
protected void	processResults(ResultHandler handler, int flags, boolean adaptiveFetch)
(package private) void	readFromCopy(CopyOperationImpl op, boolean block)	Wait for a row of data to be received from server on an active copy operation Connection gets unlocked by processCopyResults() at end of operation.
void	readStartupMessages()
private void	receiveAsyncNotify()
private String	receiveCommandStatus()
private SQLException	receiveErrorResponse()
private byte[]	receiveFastpathResult()
private Field[]	receiveFields()
private SQLWarning	receiveNoticeResponse()
void	receiveParameterStatus()
private void	receiveRFQ()
private void	registerOpenPortal(Portal portal)
private void	registerParsedQuery(SimpleQuery query, String statementName)
private void	releaseSavePoint(boolean autosave)
void	removeBinaryReceiveOid(int oid)	Remove given oid from the list of oids for binary receive encoding.
void	removeBinarySendOid(int oid)	Remove given oid from the list of oids for binary send encoding.
void	removeQueryFromAdaptiveFetchCache(boolean adaptiveFetch, ResultCursor cursor)	Remove query from adaptive fetch cache inside QueryExecutor
private void	rollbackIfRequired(boolean autosave, SQLException e)
private boolean	sendAutomaticSavepoint(Query query, int flags)
private void	sendBind(SimpleQuery query, SimpleParameterList params, Portal portal, boolean noBinaryTransfer)
protected void	sendCloseMessage()	Sends "terminate connection" message to the backend.
private void	sendClosePortal(String portalName)
private void	sendCloseStatement(String statementName)
private void	sendDescribePortal(SimpleQuery query, Portal portal)
private void	sendDescribeStatement(SimpleQuery query, SimpleParameterList params, boolean describeOnly)
private void	sendExecute(SimpleQuery query, Portal portal, int limit)
private void	sendFastpathCall(int fnid, SimpleParameterList params)
private void	sendOneQuery(SimpleQuery query, SimpleParameterList params, int maxRows, int fetchSize, int flags)
private void	sendParse(SimpleQuery query, SimpleParameterList params, boolean oneShot)
private void	sendQuery(Query query, V3ParameterList parameters, int maxRows, int fetchSize, int flags, ResultHandler resultHandler, BatchResultHandler batchHandler, boolean adaptiveFetch)
private ResultHandler	sendQueryPreamble(ResultHandler delegateHandler, int flags)
private void	sendSimpleQuery(SimpleQuery query, SimpleParameterList params)
private void	sendSync()
void	setAdaptiveFetch(boolean adaptiveFetch)	Set state of adaptive fetch inside QueryExecutor.
void	setApplicationName(String applicationName)
void	setBinaryReceiveOids(Set<Integer> oids)	Sets the oids that should be received using binary encoding.
void	setBinarySendOids(Set<Integer> oids)	Sets the oids that should be sent using binary encoding.
private void	setIntegerDateTimes(boolean state)
private void	setSocketTimeout(int millis)
void	setTimeZone(TimeZone timeZone)
private void	skipMessage()	Ignore the response message by reading the message length and skipping over those bytes in the communication stream.
CopyOperation	startCopy(String sql, boolean suppressBegin)	Sends given query to BE to start, initialize and lock connection for a CopyOperation.
private void	unlock(Object holder)	Release lock on this connection presumably held by given object.
private int	updateQueryMode(int flags)
private boolean	useBinary(Field field)	Returns true if the specified field should be retrieved using binary encoding.
boolean	useBinaryForReceive(int oid)	Returns if given oid should be received in binary format.
boolean	useBinaryForSend(int oid)	Returns if given oid should be sent in binary format.
private void	waitOnLock()	Wait until our lock is released.
Query	wrap(List<NativeQuery> queries)	Wrap given native query into a ready for execution format.
void	writeToCopy(CopyOperationImpl op, byte[] data, int off, int siz)	Sends data during a live COPY IN operation.
void	writeToCopy(CopyOperationImpl op, ByteStreamWriter from)	Sends data during a live COPY IN operation.

Methods inherited from class QueryExecutorBase

abort, addNotification, addWarning, borrowCallableQuery, borrowQuery, borrowQueryByKey, borrowReturningQuery, close, createCloseAction, createQuery, createQueryByKey, createQueryKey, getAutoSave, getBackendPID, getCloseAction, getDatabase, getEncoding, getEscapeSyntaxCallMode, getHostSpec, getNetworkTimeout, getNotifications, getParameterStatus, getParameterStatuses, getPreferQueryMode, getQuoteReturningIdentifiers, getServerVersion, getServerVersionNum, getStandardConformingStrings, getTransactionState, getUser, getWarnings, hasNotifications, isClosed, isColumnSanitiserDisabled, isFlushCacheOnDeallocate, isReWriteBatchedInsertsEnabled, onParameterStatus, releaseQuery, sendQueryCancel, setAutoSave, setBackendKeyData, setEncoding, setFlushCacheOnDeallocate, setNetworkTimeout, setPreferQueryMode, setServerVersion, setServerVersionNum, setStandardConformingStrings, setTransactionState, willHealOnRetry, willHealViaReparse

Methods inherited from class Object

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

Field Details

LOGGER

private static final Logger LOGGER

NO_FIELDS

private static final Field[] NO_FIELDS

timeZone

private TimeZone timeZone

TimeZone of the current connection (TimeZone backend parameter).

applicationName

private String applicationName

application_name connection property.

integerDateTimes

private boolean integerDateTimes

True if server uses integers for date and time fields. False if server uses double.

useBinaryReceiveForOids

private final IntSet useBinaryReceiveForOids

Bit set that has a bit set for each oid which should be received using binary format.

useBinarySendForOids

private final IntSet useBinarySendForOids

Bit set that has a bit set for each oid which should be sent using binary format.

sync

private final SimpleQuery sync

This is a fake query object so processResults can distinguish "ReadyForQuery" messages from Sync messages vs from simple execute (aka 'Q').

deallocateEpoch

private short deallocateEpoch

lastSetSearchPathQuery

private String lastSetSearchPathQuery

This caches the latest observed set search_path query so the reset of prepared statement cache can be skipped if using repeated calls for the same set search_path value.

transactionFailCause

private SQLException transactionFailCause

The exception that caused the last transaction to fail.

replicationProtocol

private final ReplicationProtocol replicationProtocol

commandCompleteParser

private final CommandCompleteParser commandCompleteParser

CommandComplete(B) messages are quite common, so we reuse instance to parse those

adaptiveFetchCache

private final AdaptiveFetchCache adaptiveFetchCache

lockedFor

private Object lockedFor

Supplement to synchronization of public methods on current QueryExecutor.

Necessary for keeping the connection intact between calls to public methods sharing a state such as COPY subprotocol. waitOnLock() must be called at beginning of each connection access point.

Public methods sharing that state must then be synchronized among themselves. Normal method synchronization typically suffices for that.

See notes on related methods as well as currentCopy() below.

MAX_BUFFERED_RECV_BYTES

private static final int MAX_BUFFERED_RECV_BYTES

See Also:

• Constant Field Values

NODATA_QUERY_RESPONSE_SIZE_BYTES

private static final int NODATA_QUERY_RESPONSE_SIZE_BYTES

See Also:

• Constant Field Values

processingCopyResults

AtomicBoolean processingCopyResults

parsedQueryMap

private final HashMap<PhantomReference<SimpleQuery>, String> parsedQueryMap

parsedQueryCleanupQueue

private final ReferenceQueue<SimpleQuery> parsedQueryCleanupQueue

openPortalMap

private final HashMap<PhantomReference<Portal>, String> openPortalMap

openPortalCleanupQueue

private final ReferenceQueue<Portal> openPortalCleanupQueue

UNNAMED_PORTAL

private static final Portal UNNAMED_PORTAL

pendingParseQueue

private final Deque<SimpleQuery> pendingParseQueue

pendingBindQueue

private final Deque<Portal> pendingBindQueue

pendingExecuteQueue

private final Deque<ExecuteRequest> pendingExecuteQueue

pendingDescribeStatementQueue

private final Deque<DescribeRequest> pendingDescribeStatementQueue

pendingDescribePortalQueue

private final Deque<SimpleQuery> pendingDescribePortalQueue

nextUniqueID

private long nextUniqueID

allowEncodingChanges

private final boolean allowEncodingChanges

cleanupSavePoints

private final boolean cleanupSavePoints

estimatedReceiveBufferBytes

private int estimatedReceiveBufferBytes

The estimated server response size since we last consumed the input stream from the server, in bytes.

Starts at zero, reset by every Sync message. Mainly used for batches.

Used to avoid deadlocks, see MAX_BUFFERED_RECV_BYTES.

beginTransactionQuery

private final SimpleQuery beginTransactionQuery

beginReadOnlyTransactionQuery

private final SimpleQuery beginReadOnlyTransactionQuery

emptyQuery

private final SimpleQuery emptyQuery

autoSaveQuery

private final SimpleQuery autoSaveQuery

releaseAutoSave

private final SimpleQuery releaseAutoSave

restoreToAutoSave

private final SimpleQuery restoreToAutoSave

Constructor Details

QueryExecutorImpl

public QueryExecutorImpl(PGStream pgStream,
 int cancelSignalTimeout,
 Properties info)
                  throws SQLException,
IOException

Throws:

SQLException

IOException

Method Details

getProtocolVersion

public ProtocolVersion getProtocolVersion()

Returns:

the version of the implementation

lock

private void lock(Object obtainer)
           throws PSQLException

Obtain lock over this connection for given object, blocking to wait if necessary.

Parameters:

obtainer - object that gets the lock. Normally current thread.

Throws:

PSQLException - when already holding the lock or getting interrupted.

unlock

private void unlock(Object holder)
             throws PSQLException

Release lock on this connection presumably held by given object.

Parameters:

holder - object that holds the lock. Normally current thread.

Throws:

PSQLException - when this thread does not hold the lock

waitOnLock

private void waitOnLock()
                 throws PSQLException

Wait until our lock is released. Execution of a single synchronized method can then continue without further ado. Must be called at beginning of each synchronized public method.

Throws:

PSQLException

hasLockOn

boolean hasLockOn(Object holder)

Parameters:

holder - object assumed to hold the lock

Returns:

whether given object actually holds the lock

hasLock

private boolean hasLock(Object holder)

Parameters:

holder - object assumed to hold the lock

Returns:

whether given object actually holds the lock

createSimpleQuery

public Query createSimpleQuery(String sql)
                        throws SQLException

Description copied from interface: QueryExecutor

Create an unparameterized Query object suitable for execution by this QueryExecutor. The provided query string is not parsed for parameter placeholders ('?' characters), and the Query.createParameterList() of the returned object will always return an empty ParameterList.

Parameters:

sql - the SQL for the query to create

Returns:

a new Query object

Throws:

SQLException - if something goes wrong

wrap

public Query wrap(List<NativeQuery> queries)

Description copied from interface: QueryExecutor

Wrap given native query into a ready for execution format.

Parameters:

queries - list of queries in native to database syntax

Returns:

query object ready for execution by this query executor

updateQueryMode

private int updateQueryMode(int flags)

execute

public void execute(Query query,
 ParameterList parameters,
 ResultHandler handler,
 int maxRows,
 int fetchSize,
 int flags)
             throws SQLException

Description copied from interface: QueryExecutor

Execute a Query, passing results to a provided ResultHandler.

Parameters:

query - the query to execute; must be a query returned from calling QueryExecutor.wrap(List) on this QueryExecutor object.

parameters - the parameters for the query. Must be non-null if the query takes parameters. Must be a parameter object returned by Query.createParameterList().

handler - a ResultHandler responsible for handling results generated by this query

maxRows - the maximum number of rows to retrieve

fetchSize - if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending

flags - a combination of QUERY_* flags indicating how to handle the query.

Throws:

SQLException - if query execution fails

execute

public void execute(Query query,
 ParameterList parameters,
 ResultHandler handler,
 int maxRows,
 int fetchSize,
 int flags,
 boolean adaptiveFetch)
             throws SQLException

Description copied from interface: QueryExecutor

Execute a Query with adaptive fetch, passing results to a provided ResultHandler.

Parameters:

query - the query to execute; must be a query returned from calling QueryExecutor.wrap(List) on this QueryExecutor object.

parameters - the parameters for the query. Must be non-null if the query takes parameters. Must be a parameter object returned by Query.createParameterList().

handler - a ResultHandler responsible for handling results generated by this query

maxRows - the maximum number of rows to retrieve

fetchSize - if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending

flags - a combination of QUERY_* flags indicating how to handle the query.

adaptiveFetch - state of adaptiveFetch to use during execution

Throws:

SQLException - if query execution fails

sendAutomaticSavepoint

private boolean sendAutomaticSavepoint(Query query,
 int flags)
                                throws IOException

Throws:

IOException

releaseSavePoint

private void releaseSavePoint(boolean autosave)
                       throws SQLException

Throws:

SQLException

rollbackIfRequired

private void rollbackIfRequired(boolean autosave,
 SQLException e)
                         throws SQLException

Throws:

SQLException

execute

public void execute(Query[] queries,
 ParameterList[] parameterLists,
 BatchResultHandler batchHandler,
 int maxRows,
 int fetchSize,
 int flags)
             throws SQLException

Description copied from interface: QueryExecutor

Execute several Query, passing results to a provided ResultHandler.

Parameters:

queries - the queries to execute; each must be a query returned from calling QueryExecutor.wrap(List) on this QueryExecutor object.

parameterLists - the parameter lists for the queries. The parameter lists correspond 1:1 to the queries passed in the queries array. Each must be non- null if the corresponding query takes parameters, and must be a parameter object returned by Query.createParameterList() created by the corresponding query.

batchHandler - a ResultHandler responsible for handling results generated by this query

maxRows - the maximum number of rows to retrieve

fetchSize - if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending

flags - a combination of QUERY_* flags indicating how to handle the query.

Throws:

SQLException - if query execution fails

execute

public void execute(Query[] queries,
 ParameterList[] parameterLists,
 BatchResultHandler batchHandler,
 int maxRows,
 int fetchSize,
 int flags,
 boolean adaptiveFetch)
             throws SQLException

Description copied from interface: QueryExecutor

Execute several Query with adaptive fetch, passing results to a provided ResultHandler.

Parameters:

queries - the queries to execute; each must be a query returned from calling QueryExecutor.wrap(List) on this QueryExecutor object.

parameterLists - the parameter lists for the queries. The parameter lists correspond 1:1 to the queries passed in the queries array. Each must be non- null if the corresponding query takes parameters, and must be a parameter object returned by Query.createParameterList() created by the corresponding query.

batchHandler - a ResultHandler responsible for handling results generated by this query

maxRows - the maximum number of rows to retrieve

fetchSize - if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve before suspending

flags - a combination of QUERY_* flags indicating how to handle the query.

adaptiveFetch - state of adaptiveFetch to use during execution

Throws:

SQLException - if query execution fails

sendQueryPreamble

private ResultHandler sendQueryPreamble(ResultHandler delegateHandler,
 int flags)
                                 throws IOException

Throws:

IOException

fastpathCall

public byte[] fastpathCall(int fnid,
 ParameterList parameters,
 boolean suppressBegin)
                    throws SQLException

Description copied from interface: QueryExecutor

Invoke a backend function via the fastpath interface.

Parameters:

fnid - the OID of the backend function to invoke

parameters - a ParameterList returned from QueryExecutor.createFastpathParameters(int) containing the parameters to pass to the backend function

suppressBegin - if begin should be suppressed

Returns:

the binary-format result of the fastpath call, or null if a void result was returned

Throws:

SQLException - if an error occurs while executing the fastpath call

doSubprotocolBegin

public void doSubprotocolBegin()
                        throws SQLException

Throws:

SQLException

createFastpathParameters

public ParameterList createFastpathParameters(int count)

Description copied from interface: QueryExecutor

Create a new ParameterList implementation suitable for invoking a fastpath function via QueryExecutor.fastpathCall(int, ParameterList, boolean).

Parameters:

count - the number of parameters the fastpath call will take

Returns:

a ParameterList suitable for passing to QueryExecutor.fastpathCall(int, ParameterList, boolean).

sendFastpathCall

private void sendFastpathCall(int fnid,
 SimpleParameterList params)
                       throws SQLException,
IOException

Throws:

SQLException

IOException

processNotifies

public void processNotifies()
                     throws SQLException

Description copied from interface: QueryExecutor

Prior to attempting to retrieve notifications, we need to pull any recently received notifications off of the network buffers. The notification retrieval in ProtocolConnection cannot do this as it is prone to deadlock, so the higher level caller must be responsible which requires exposing this method.

Throws:

SQLException - if and error occurs while fetching notifications

processNotifies

public void processNotifies(int timeoutMillis)
                     throws SQLException

Description copied from interface: QueryExecutor

Prior to attempting to retrieve notifications, we need to pull any recently received notifications off of the network buffers. The notification retrieval in ProtocolConnection cannot do this as it is prone to deadlock, so the higher level caller must be responsible which requires exposing this method. This variant supports blocking for the given time in millis.

Parameters:

timeoutMillis - when > 0, block for this time when =0, block forever when < 0, don't block

Throws:

SQLException - if and error occurs while fetching notifications

setSocketTimeout

private void setSocketTimeout(int millis)
                       throws PSQLException

Throws:

PSQLException

receiveFastpathResult

private byte[] receiveFastpathResult()
                              throws IOException,
SQLException

Throws:

IOException

SQLException

startCopy

public CopyOperation startCopy(String sql,
 boolean suppressBegin)
                        throws SQLException

Sends given query to BE to start, initialize and lock connection for a CopyOperation.

Parameters:

sql - COPY FROM STDIN / COPY TO STDOUT statement

suppressBegin - if begin should be suppressed

Returns:

CopyIn or CopyOut operation object

Throws:

SQLException - on failure

initCopy

private void initCopy(CopyOperationImpl op)
               throws SQLException,
IOException

Locks connection and calls initializer for a new CopyOperation Called via startCopy -> processCopyResults.

Parameters:

op - an uninitialized CopyOperation

Throws:

SQLException - on locking failure

IOException - on database connection failure

cancelCopy

public void cancelCopy(CopyOperationImpl op)
                throws SQLException

Finishes a copy operation and unlocks connection discarding any exchanged data.

Parameters:

op - the copy operation presumably currently holding lock on this connection

Throws:

SQLException - on any additional failure

endCopy

public long endCopy(CopyOperationImpl op)
             throws SQLException

Finishes writing to copy and unlocks connection.

Parameters:

op - the copy operation presumably currently holding lock on this connection

Returns:

number of rows updated for server versions 8.2 or newer

Throws:

SQLException - on failure

writeToCopy

public void writeToCopy(CopyOperationImpl op,
 byte[] data,
 int off,
 int siz)
                 throws SQLException

Sends data during a live COPY IN operation. Only unlocks the connection if server suddenly returns CommandComplete, which should not happen

Parameters:

op - the CopyIn operation presumably currently holding lock on this connection

data - bytes to send

off - index of first byte to send (usually 0)

siz - number of bytes to send (usually data.length)

Throws:

SQLException - on failure

writeToCopy

public void writeToCopy(CopyOperationImpl op,
 ByteStreamWriter from)
                 throws SQLException

Sends data during a live COPY IN operation. Only unlocks the connection if server suddenly returns CommandComplete, which should not happen

Parameters:

op - the CopyIn operation presumably currently holding lock on this connection

from - the source of bytes, e.g. a ByteBufferByteStreamWriter

Throws:

SQLException - on failure

flushCopy

public void flushCopy(CopyOperationImpl op)
               throws SQLException

Throws:

SQLException

readFromCopy

void readFromCopy(CopyOperationImpl op,
 boolean block)
           throws SQLException

Wait for a row of data to be received from server on an active copy operation Connection gets unlocked by processCopyResults() at end of operation.

Parameters:

op - the copy operation presumably currently holding lock on this connection

block - whether to block waiting for input

Throws:

SQLException - on any failure

processCopyResults

CopyOperationImpl processCopyResults(CopyOperationImpl op,
 boolean block)
                              throws SQLException,
IOException

Handles copy sub protocol responses from server. Unlocks at end of sub protocol, so operations on pgStream or QueryExecutor are not allowed in a method after calling this!

Parameters:

block - whether to block waiting for input

Returns:

CopyIn when COPY FROM STDIN starts; CopyOut when COPY TO STDOUT starts; null when copy ends; otherwise, the operation given as parameter.

Throws:

SQLException - in case of misuse

IOException - from the underlying connection

flushIfDeadlockRisk

private void flushIfDeadlockRisk(Query query,
 boolean disallowBatching,
 ResultHandler resultHandler,
 BatchResultHandler batchHandler,
 int flags)
                          throws IOException

Throws:

IOException

sendQuery

private void sendQuery(Query query,
 V3ParameterList parameters,
 int maxRows,
 int fetchSize,
 int flags,
 ResultHandler resultHandler,
 BatchResultHandler batchHandler,
 boolean adaptiveFetch)
                throws IOException,
SQLException

Throws:

IOException

SQLException

sendSync

private void sendSync()
               throws IOException

Throws:

IOException

sendParse

private void sendParse(SimpleQuery query,
 SimpleParameterList params,
 boolean oneShot)
                throws IOException

Throws:

IOException

sendBind

private void sendBind(SimpleQuery query,
 SimpleParameterList params,
 Portal portal,
 boolean noBinaryTransfer)
               throws IOException

Throws:

IOException

useBinary

private boolean useBinary(Field field)

Returns true if the specified field should be retrieved using binary encoding.

Parameters:

field - The field whose Oid type to analyse.

Returns:

True if Field.BINARY_FORMAT should be used, false if Field.BINARY_FORMAT.

sendDescribePortal

private void sendDescribePortal(SimpleQuery query,
 Portal portal)
                         throws IOException

Throws:

IOException

sendDescribeStatement

private void sendDescribeStatement(SimpleQuery query,
 SimpleParameterList params,
 boolean describeOnly)
                            throws IOException

Throws:

IOException

sendExecute

private void sendExecute(SimpleQuery query,
 Portal portal,
 int limit)
                  throws IOException

Throws:

IOException

sendClosePortal

private void sendClosePortal(String portalName)
                      throws IOException

Throws:

IOException

sendCloseStatement

private void sendCloseStatement(String statementName)
                         throws IOException

Throws:

IOException

sendOneQuery

private void sendOneQuery(SimpleQuery query,
 SimpleParameterList params,
 int maxRows,
 int fetchSize,
 int flags)
                   throws IOException

Throws:

IOException

sendSimpleQuery

private void sendSimpleQuery(SimpleQuery query,
 SimpleParameterList params)
                      throws IOException

Throws:

IOException

registerParsedQuery

private void registerParsedQuery(SimpleQuery query,
 String statementName)

processDeadParsedQueries

private void processDeadParsedQueries()
                               throws IOException

Throws:

IOException

registerOpenPortal

private void registerOpenPortal(Portal portal)

processDeadPortals

private void processDeadPortals()
                         throws IOException

Throws:

IOException

processResults

protected void processResults(ResultHandler handler,
 int flags)
                       throws IOException

Throws:

IOException

processResults

protected void processResults(ResultHandler handler,
 int flags,
 boolean adaptiveFetch)
                       throws IOException

Throws:

IOException

skipMessage

private void skipMessage()
                  throws IOException

Ignore the response message by reading the message length and skipping over those bytes in the communication stream.

Throws:

IOException

fetch

public void fetch(ResultCursor cursor,
 ResultHandler handler,
 int fetchSize,
 boolean adaptiveFetch)
           throws SQLException

Description copied from interface: QueryExecutor

Fetch additional rows from a cursor.

Parameters:

cursor - the cursor to fetch from

handler - the handler to feed results to

fetchSize - the preferred number of rows to retrieve before suspending

adaptiveFetch - state of adaptiveFetch to use during fetching

Throws:

SQLException - if query execution fails

getAdaptiveFetchSize

public int getAdaptiveFetchSize(boolean adaptiveFetch,
 ResultCursor cursor)

Description copied from interface: QueryExecutor

Get fetch size computed by adaptive fetch size for given query.

Parameters:

adaptiveFetch - state of adaptive fetch, which should be used during retrieving

cursor - Cursor used by resultSet, containing query, have to be able to cast to Portal class.

Returns:

fetch size computed by adaptive fetch size for given query passed inside cursor

setAdaptiveFetch

public void setAdaptiveFetch(boolean adaptiveFetch)

Description copied from interface: QueryExecutor

Set state of adaptive fetch inside QueryExecutor.

Parameters:

adaptiveFetch - desired state of adaptive fetch

getAdaptiveFetch

public boolean getAdaptiveFetch()

Description copied from interface: QueryExecutor

Get state of adaptive fetch inside QueryExecutor.

Returns:

state of adaptive fetch inside QueryExecutor

addQueryToAdaptiveFetchCache

public void addQueryToAdaptiveFetchCache(boolean adaptiveFetch,
 ResultCursor cursor)

Description copied from interface: QueryExecutor

Add query to adaptive fetch cache inside QueryExecutor.

Parameters:

adaptiveFetch - state of adaptive fetch used during adding query

cursor - Cursor used by resultSet, containing query, have to be able to cast to Portal class.

removeQueryFromAdaptiveFetchCache

public void removeQueryFromAdaptiveFetchCache(boolean adaptiveFetch,
 ResultCursor cursor)

Description copied from interface: QueryExecutor

Remove query from adaptive fetch cache inside QueryExecutor

Parameters:

adaptiveFetch - state of adaptive fetch used during removing query

cursor - Cursor used by resultSet, containing query, have to be able to cast to Portal class.

receiveFields

private Field[] receiveFields()
                       throws IOException

Throws:

IOException

receiveAsyncNotify

private void receiveAsyncNotify()
                         throws IOException

Throws:

IOException

receiveErrorResponse

private SQLException receiveErrorResponse()
                                   throws IOException

Throws:

IOException

receiveNoticeResponse

private SQLWarning receiveNoticeResponse()
                                  throws IOException

Throws:

IOException

receiveCommandStatus

private String receiveCommandStatus()
                             throws IOException

Throws:

IOException

interpretCommandStatus

private void interpretCommandStatus(String status,
 ResultHandler handler)

receiveRFQ

private void receiveRFQ()
                 throws IOException

Throws:

IOException

sendCloseMessage

protected void sendCloseMessage()
                         throws IOException

Description copied from class: QueryExecutorBase

Sends "terminate connection" message to the backend.

Specified by:

sendCloseMessage in class QueryExecutorBase

Throws:

IOException - in case connection termination fails

readStartupMessages

public void readStartupMessages()
                         throws IOException,
SQLException

Throws:

IOException

SQLException

receiveParameterStatus

public void receiveParameterStatus()
                            throws IOException,
SQLException

Throws:

IOException

SQLException

setTimeZone

public void setTimeZone(TimeZone timeZone)

getTimeZone

public TimeZone getTimeZone()

Description copied from interface: QueryExecutor

Returns backend timezone in java format.

Returns:

backend timezone in java format.

setApplicationName

public void setApplicationName(String applicationName)

getApplicationName

public String getApplicationName()

Description copied from interface: QueryExecutor

Returns application_name connection property.

Returns:

application_name connection property

getReplicationProtocol

public ReplicationProtocol getReplicationProtocol()

Returns:

the ReplicationProtocol instance for this connection.

addBinaryReceiveOid

public void addBinaryReceiveOid(int oid)

Description copied from interface: QueryExecutor

Adds a single oid that should be received using binary encoding.

Parameters:

oid - The oid to request with binary encoding.

removeBinaryReceiveOid

public void removeBinaryReceiveOid(int oid)

Description copied from interface: QueryExecutor

Remove given oid from the list of oids for binary receive encoding.

Note: the binary receive for the oid can be re-activated later.

Parameters:

oid - The oid to request with binary encoding.

getBinaryReceiveOids

public Set<? extends Integer> getBinaryReceiveOids()

Description copied from interface: QueryExecutor

Gets the oids that should be received using binary encoding.

Note: this returns an unmodifiable set, and its contents might not reflect the current state.

Returns:

The oids to request with binary encoding.

useBinaryForReceive

public boolean useBinaryForReceive(int oid)

Description copied from interface: TypeTransferModeRegistry

Returns if given oid should be received in binary format.

Parameters:

oid - type oid

Returns:

true if given oid should be received in binary format

setBinaryReceiveOids

public void setBinaryReceiveOids(Set<Integer> oids)

Description copied from interface: QueryExecutor

Sets the oids that should be received using binary encoding.

Parameters:

oids - The oids to request with binary encoding.

addBinarySendOid

public void addBinarySendOid(int oid)

Description copied from interface: QueryExecutor

Adds a single oid that should be sent using binary encoding.

Parameters:

oid - The oid to send with binary encoding.

removeBinarySendOid

public void removeBinarySendOid(int oid)

Description copied from interface: QueryExecutor

Remove given oid from the list of oids for binary send encoding.

Note: the binary send for the oid can be re-activated later.

Parameters:

oid - The oid to send with binary encoding.

getBinarySendOids

public Set<? extends Integer> getBinarySendOids()

Description copied from interface: QueryExecutor

Gets the oids that should be sent using binary encoding.

Note: this returns an unmodifiable set, and its contents might not reflect the current state.

Returns:

useBinaryForOids The oids to send with binary encoding.

useBinaryForSend

public boolean useBinaryForSend(int oid)

Description copied from interface: TypeTransferModeRegistry

Returns if given oid should be sent in binary format.

Parameters:

oid - type oid

Returns:

true if given oid should be sent in binary format

setBinarySendOids

public void setBinarySendOids(Set<Integer> oids)

Description copied from interface: QueryExecutor

Sets the oids that should be sent using binary encoding.

Parameters:

oids - The oids to send with binary encoding.

setIntegerDateTimes

private void setIntegerDateTimes(boolean state)

getIntegerDateTimes

public boolean getIntegerDateTimes()

Description copied from interface: QueryExecutor

Returns true if server uses integer instead of double for binary date and time encodings.

Returns:

the server integer_datetime setting.