Public

<init>

close

createParameterList

getEncodedStatementName

Returns the fields that this query will return. If the result set fields are not
known returns null.

getFields

getStatementName

hasUnresolvedTypes

isPortalDescribed

isPreparedFor

isStatementDescribed

setCleanupRef

Sets the fields that this query will return.

setFields

setPortalDescribed

setStatementDescribed

setStatementName

toString

unprepare

getFragments

getStatementTypes

setStatementTypes

SimpleQuery

Reading from database using SQL prepared statement

ObjectMapper provides functionality for reading and writing JSON, either to and
from basic POJOs (Pl

com.fasterxml.jackson.databind.ObjectMapper

Fake signature of an existing Java class.

java.io.PrintStream

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

java.lang.Thread

java.security.Permission

javax.naming.Reference

A filter is an object that performs filtering tasks on either the request to a
resource (a servlet o

javax.servlet.Filter

getContentResolver

Return the original filename in the client's filesystem.This may contain path
information depending 

getOriginalFilename

getSystemService

// Assume all statements need at least this much reply buffer space,

/*
       * Estimate the response size of the fields and add it to the expected response size.
       *
       * It's impossible for us to estimate the rowcount. We'll assume one row, as that's the common
       * case for batches and we're leaving plenty of breathing room in this approach. It's still
       * not deadlock-proof though; see pgjdbc github issues #194 and #195.
       */

"Couldn't estimate result size or result size unbounded, "

/*
       * We only describe a statement if we're expecting results from it, so it's legal to batch
       * unprepared statements. We'll abort later if we get any uresults from them where none are
       * expected. For now all we can do is hope the user told us the truth and assume that
       * NODATA_QUERY_RESPONSE_SIZE_BYTES is enough to cover it.
       */

"Forcing Sync, receive buffer full or batching disallowed"

// nb: if we decide to use a portal (usePortal == true) we must also use a named statement

// (oneShot == false) as otherwise the portal will be closed under us unexpectedly when

// Work out how many rows to fetch in this pass.

// We're discarding any results anyway, so limit data transfer to a minimum

// Not using a portal -- fetchSize is irrelevant

// fetchSize > maxRows, use maxRows (nb: fetchSize cannot be 0 if usePortal == true)

// Must do this after sendParse to pick up any changes to the

// Only supply type information when there isn't any

// already, don't arbitrarily overwrite user supplied

// A statement describe will also output a RowDescription,

// so don't reissue it here if we've already done so.

"Simple mode does not support describe requests. sql = "

"Queries that might contain ; must be executed with QueryExecutor.QUERY_EXECUTE_AS_SIMPLE mode. "

// Per https://www.postgresql.org/docs/current/static/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY

// A Bind message can use the unnamed prepared statement to create a named portal.

// If the Bind is successful, an Execute message can reference that named portal until either

//      the end of the current transaction

//   or the named portal is explicitly destroyed

// the usePortal flag controls whether or not we use a *named* portal

/*
       * don't send describe if we already have cached the row description from previous executions
       *
       * XXX Clearing the fields / unpreparing the query (in sendParse) is incorrect, see bug #267.
       * We might clear the cached fields in a later execution of this query if the bind parameter
       * types change, but we're assuming here that they'll still be valid when we come to process
       * the results of this query, so we don't send a new describe here. We re-describe after the
       * fields are cleared, but the result of that gets processed after processing the results from
       * earlier executions that we didn't describe because we didn't think we had to.
       *
       * To work around this, force a Describe at each execution in batches where this can be a
       * problem. It won't cause more round trips so the performance impact is low, and it'll ensure
       * that the field information available when we decoded the results. This is undeniably a
       * hack, but there aren't many good alternatives.
       */

How to use isStatementDescribedmethodin org.postgresql.core.v3.SimpleQuery

Best Java code snippets using org.postgresql.core.v3.SimpleQuery.isStatementDescribed (Showing top 6 results out of 315)

How to use
isStatementDescribed
method
in
org.postgresql.core.v3.SimpleQuery