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

Making http post requests using okhttp

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

An output stream that writes bytes to a file. If the output file exists, it can
be replaced or appen

java.io.FileOutputStream

A thread is a thread of execution in a program. The Java Virtual Machine allows
an application to ha

java.lang.Thread

Note: Do not use this class since it is obsolete. Please use the Map interface
for new implementatio

java.util.Dictionary

Provides an abstract class to be subclassed to create an HTTP servlet suitable
for a Web site. A sub

javax.servlet.http.HttpServlet

Abstract superclass of object loading (and querying) strategies. This class
implements useful common

org.hibernate.loader.Loader

getSystemService

setRequestProperty

getExternalFilesDir

/**
   * 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