Public

<init>

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

cancelCopy

doSubprotocolBegin

Finishes writing to copy and unlocks connection.

endCopy

flushCopy

hasLock

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

initCopy

interpretCommandStatus

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

lock

Handles copy sub protocol responses from server. Unlocks at end of sub protocol,
so operations on pg

processCopyResults

processDeadParsedQueries

processDeadPortals

processResults

Blocks to wait for a row of data to be received from server on an active copy
operation Connection g

readFromCopy

receiveAsyncNotify

receiveCommandStatus

receiveErrorResponse

receiveFastpathResult

receiveFields

receiveNoticeResponse

QueryExecutorImpl

Start an intent from android

Allows reading from and writing to a file in a random-access manner. This is
different from the uni-

java.io.RandomAccessFile

This SocketException may be thrown during socket creation or setting options,
and is the superclass 

java.net.SocketException

Formats and parses dates in a locale-sensitive manner. Formatting turns a Date
into a String, and pa

java.text.SimpleDateFormat

LinkedHashMap is an implementation of Map that guarantees iteration order. All
optional operations a

java.util.LinkedHashMap

This class provides methods that return pseudo-random values.It is dangerous to
seed Random with the

java.util.Random

javax.naming.Reference

scheduleAtFixedRate

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

runOnUiThread

/**
   * 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!
   *
   * @param block whether to block waiting for input
   * @return 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
   * @throws IOException from the underlying connection
   */

// There is a bug in the server's implementation of the copy

// protocol. It returns command complete immediately upon

// receiving the EOF marker in the binary protocol,

// potentially before we've issued CopyDone. When we are not

// blocking, we don't think we are done, so we hold off on

// processing command complete and any subsequent messages

// until we actually are done with the copy.

" <=BE CommandStatus, Ignored until CopyDone"

" <=BE Asynchronous Notification while copying"

"Received CommandComplete ''{0}'' without an active copy operation"

// ErrorMessage (expected response to CopyFail)

// We've received the error and we now expect to receive

// Ready for query, but we must block because it might still be

"Got CopyInResponse from server during an active {0}"

"Got CopyOutResponse from server during an active {0}"

"Got CopyBothResponse from server during an active {0}"

"Got CopyData without an active copy operation"

"Unexpected copydata from server for {0}"

/**
   * Finishes a copy operation and unlocks connection discarding any exchanged data.
   *
   * @param op the copy operation presumably currently holding lock on this connection
   * @throws SQLException on any additional failure
   */

"Tried to cancel an inactive copy operation"

// expected error response to failing copy

"Database connection failed when canceling copy operation"

// Need to ensure the lock isn't held anymore, or else

// future operations, rather than failing due to the

// broken connection, will simply hang waiting for this

"Missing expected error response to copy cancel request"

"Got {0} error responses to single copy cancel request"

/**
     * 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!
     * @param block whether to block waiting for input
     * @return 
     *  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
     * @throws IOException from the underlying connection
     */

// protocol.  It returns command complete immediately upon

// potentially before we've issued CopyDone.  When we are not

// CopyDone (expected after all copydata received)

// not in specification; should never appear

"Got CopyDone while not copying from server"

// keep receiving since we expect a CommandComplete

// ReadyForQuery: After FE:CopyDone => BE:CommandComplete

How to use unlockmethodin org.postgresql.core.v3.QueryExecutorImpl

Best Java code snippets using org.postgresql.core.v3.QueryExecutorImpl.unlock (Showing top 5 results out of 315)

How to use
unlock
method
in
org.postgresql.core.v3.QueryExecutorImpl