# PostgreSQL JDBC Driver
PostgreSQL JDBC Driver (PgJDBC for short) allows Java programs to connect to a PostgreSQL database using standard, database independent Java code. Is an open source JDBC driver written in Pure Java (Type 4), and communicates in the PostgreSQL native network protocol.
### Status
[](https://github.com/pgjdbc/pgjdbc/actions/workflows/main.yml)
[](https://ci.appveyor.com/project/davecramer/pgjdbc/branch/master)
[](http://codecov.io/github/pgjdbc/pgjdbc?branch=master)
[](https://opensource.org/licenses/BSD-2-Clause)
[](https://gitter.im/pgjdbc/pgjdbc?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[](https://maven-badges.herokuapp.com/maven-central/org.postgresql/postgresql)
[](http://javadoc.io/doc/org.postgresql/postgresql)
## Supported PostgreSQL and Java versions
The current version of the driver should be compatible with **PostgreSQL 8.4 and higher** using the version 3.0 of the protocol and **Java 8** (JDBC 4.2) or above. Unless you have unusual requirements (running old applications or JVMs), this is the driver you should be using.
PgJDBC regression tests are run against all PostgreSQL versions since 9.1, including "build PostgreSQL from git master" version. There are other derived forks of PostgreSQL but they have not been certified to run with PgJDBC. If you find a bug or regression on supported versions, please file an [Issue](https://github.com/pgjdbc/pgjdbc/issues).
> **Note:** PgJDBC versions since 42.8.0 are not guaranteed to work with PostgreSQL older than 9.1.
## Get the Driver
Most people do not need to compile PgJDBC. You can download the precompiled driver (jar) from the [PostgreSQL JDBC site](https://jdbc.postgresql.org/download/) or using your chosen dependency management tool:
### Maven Central
You can search on The Central Repository with GroupId and ArtifactId [org.postgresql:postgresql][mvn-search].
[](https://maven-badges.herokuapp.com/maven-central/org.postgresql/postgresql)
```xml
The DriverManager will try to load as many drivers as it can find and then for any given * connection request, it will ask each driver in turn to try to connect to the target URL.
* *It is strongly recommended that each Driver class should be small and standalone so that the * Driver class can be loaded and queried without bringing in vast quantities of supporting code.
* *When a Driver class is loaded, it should create an instance of itself and register it with the * DriverManager. This means that a user can load and register a driver by doing * Class.forName("foo.bah.Driver")
* * @see org.postgresql.PGConnection * @see java.sql.Driver */ public class Driver implements java.sql.Driver { private static /* @Nullable */ Driver registeredDriver; private static final Logger PARENT_LOGGER = Logger.getLogger("org.postgresql"); private static final Logger LOGGER = Logger.getLogger("org.postgresql.Driver"); private static final SharedTimer SHARED_TIMER = new SharedTimer(); static { try { // moved the registerDriver from the constructor to here // because some clients call the driver themselves (I know, as // my early jdbc work did - and that was based on other examples). // Placing it here, means that the driver is registered once only. register(); } catch (SQLException e) { throw new ExceptionInInitializerError(e); } } // Helper to retrieve default properties from classloader resource // properties files. private /* @Nullable */ Properties defaultProperties; private final ResourceLock lock = new ResourceLock(); private Properties getDefaultProperties() throws IOException { try (ResourceLock ignore = lock.obtain()) { if (defaultProperties != null) { return defaultProperties; } // Make sure we load properties with the maximum possible privileges. try { defaultProperties = doPrivileged(new PrivilegedExceptionActionThe driver should raise an SQLException if it is the right driver to connect to the given URL, * but has trouble connecting to the database.
* *The java.util.Properties argument can be used to pass arbitrary string tag/value pairs as * connection arguments.
* *Normally, at least "user" and "password" properties should be included in the properties. For a
* list of supported character encoding , see
* http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html Note that you will
* probably want to have set up the Postgres database itself to use the same encoding, with the
* {@code -E
Our protocol takes the forms:
* ** jdbc:postgresql://host:port/database?param1=val1&... ** * @param url the URL of the database to connect to * @param info a list of arbitrary tag/value pairs as connection arguments * @return a connection to the URL or null if it isnt us * @exception SQLException if a database access error occurs or the url is * {@code null} * @see java.sql.Driver#connect */ @Override public /* @Nullable */ Connection connect(String url, /* @Nullable */ Properties info) throws SQLException { if (url == null) { throw new SQLException("url is null"); } // get defaults Properties defaults; if (!url.startsWith("jdbc:postgresql:")) { return null; } try { defaults = getDefaultProperties(); } catch (IOException ioe) { throw new PSQLException(GT.tr("Error loading default settings from driverconfig.properties"), PSQLState.UNEXPECTED_ERROR, ioe); } // override defaults with provided properties Properties props = new Properties(defaults); if (info != null) { Set
Note that depending on the values the human has supplied so far, additional values may become * necessary, so it may be necessary to iterate through several calls to getPropertyInfo
* * @param url the Url of the database to connect to * @param info a proposed list of tag/value pairs that will be sent on connect open. * @return An array of DriverPropertyInfo objects describing possible properties. This array may * be an empty array if no properties are required * @see java.sql.Driver#getPropertyInfo */ @Override public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) { Properties copy = new Properties(info); Properties parse = parseURL(url, copy); if (parse != null) { copy = parse; } PGProperty[] knownProperties = PGProperty.values(); DriverPropertyInfo[] props = new DriverPropertyInfo[knownProperties.length]; for (int i = 0; i < props.length; i++) { props[i] = knownProperties[i].toDriverPropertyInfo(copy); } return props; } @Override public int getMajorVersion() { return DriverInfo.MAJOR_VERSION; } @Override public int getMinorVersion() { return DriverInfo.MINOR_VERSION; } /** * Returns the server version series of this driver and the specific build number. * * @return JDBC driver version * @deprecated use {@link #getMajorVersion()} and {@link #getMinorVersion()} instead */ @Deprecated public static String getVersion() { return DriverInfo.DRIVER_FULL_NAME; } /** * Report whether the driver is a genuine JDBC compliant driver. A driver may only report "true" * here if it passes the JDBC compliance tests, otherwise it is required to return false. JDBC * compliance requires full support for the JDBC API and full support for SQL 92 Entry Level. * *For PostgreSQL, this is not yet possible, as we are not SQL92 compliant (yet).
*/ @Override public boolean jdbcCompliant() { return false; } /** * Constructs a new DriverURL, splitting the specified URL into its component parts. * * @param url JDBC URL to parse * @param defaults Default properties * @return Properties with elements added from the url */ public static /* @Nullable */ Properties parseURL(String url, /* @Nullable */ Properties defaults) { // priority 1 - URL values Properties priority1Url = new Properties(); // priority 2 - Properties given as argument to DriverManager.getConnection() // argument "defaults" EXCLUDING defaults // priority 3 - Values retrieved by "service" Properties priority3Service = new Properties(); // priority 4 - Properties loaded by Driver.loadDefaultProperties() (user, org/postgresql/driverconfig.properties) // argument "defaults" INCLUDING defaults // priority 5 - PGProperty defaults for PGHOST, PGPORT, PGDBNAME String urlServer = url; String urlArgs = ""; int qPos = url.indexOf('?'); if (qPos != -1) { urlServer = url.substring(0, qPos); urlArgs = url.substring(qPos + 1); } if (!urlServer.startsWith("jdbc:postgresql:")) { LOGGER.log(Level.FINE, "JDBC URL must start with \"jdbc:postgresql:\" but was: {0}", url); return null; } urlServer = urlServer.substring("jdbc:postgresql:".length()); if ("//".equals(urlServer) || "///".equals(urlServer)) { urlServer = ""; } else if (urlServer.startsWith("//")) { urlServer = urlServer.substring(2); long slashCount = urlServer.chars().filter(ch -> ch == '/').count(); if (slashCount > 1) { LOGGER.log(Level.WARNING, "JDBC URL contains too many / characters: {0}", url); return null; } int slash = urlServer.indexOf('/'); if (slash == -1) { LOGGER.log(Level.WARNING, "JDBC URL must contain a / at the end of the host or port: {0}", url); return null; } if (!urlServer.endsWith("/")) { String value = urlDecode(urlServer.substring(slash + 1)); if (value == null) { return null; } PGProperty.PG_DBNAME.set(priority1Url, value); } urlServer = urlServer.substring(0, slash); String[] addresses = urlServer.split(","); StringBuilder hosts = new StringBuilder(); StringBuilder ports = new StringBuilder(); for (String address : addresses) { int portIdx = address.lastIndexOf(':'); if (portIdx != -1 && address.lastIndexOf(']') < portIdx) { String portStr = address.substring(portIdx + 1); ports.append(portStr); CharSequence hostStr = address.subSequence(0, portIdx); if (hostStr.length() == 0) { hosts.append(PGProperty.PG_HOST.getDefaultValue()); } else { hosts.append(hostStr); } } else { ports.append(PGProperty.PG_PORT.getDefaultValue()); hosts.append(address); } ports.append(','); hosts.append(','); } ports.setLength(ports.length() - 1); hosts.setLength(hosts.length() - 1); PGProperty.PG_HOST.set(priority1Url, hosts.toString()); PGProperty.PG_PORT.set(priority1Url, ports.toString()); } else if (urlServer.startsWith("/")) { return null; } else { String value = urlDecode(urlServer); if (value == null) { return null; } priority1Url.setProperty(PGProperty.PG_DBNAME.getName(), value); } // parse the args part of the url String[] args = urlArgs.split("&"); String serviceName = null; for (String token : args) { if (token.isEmpty()) { continue; } int pos = token.indexOf('='); if (pos == -1) { priority1Url.setProperty(token, ""); } else { String pName = PGPropertyUtil.translatePGServiceToPGProperty(token.substring(0, pos)); String pValue = urlDecode(token.substring(pos + 1)); if (pValue == null) { return null; } if (PGProperty.SERVICE.getName().equals(pName)) { serviceName = pValue; } else { priority1Url.setProperty(pName, pValue); } } } // load pg_service.conf if (serviceName != null) { LOGGER.log(Level.FINE, "Processing option [?service={0}]", serviceName); Properties result = PgServiceConfParser.getServiceProperties(serviceName); if (result == null) { LOGGER.log(Level.WARNING, "Definition of service [{0}] not found", serviceName); return null; } priority3Service.putAll(result); } // combine result based on order of priority Properties result = new Properties(); result.putAll(priority1Url); if (defaults != null) { // priority 2 - forEach() returns all entries EXCEPT defaults defaults.forEach(result::putIfAbsent); } priority3Service.forEach(result::putIfAbsent); if (defaults != null) { // priority 4 - stringPropertyNames() returns all entries INCLUDING defaults defaults.stringPropertyNames().forEach(s -> result.putIfAbsent(s, castNonNull(defaults.getProperty(s)))); } // priority 5 - PGProperty defaults for PGHOST, PGPORT, PGDBNAME result.putIfAbsent(PGProperty.PG_PORT.getName(), castNonNull(PGProperty.PG_PORT.getDefaultValue())); result.putIfAbsent(PGProperty.PG_HOST.getName(), castNonNull(PGProperty.PG_HOST.getDefaultValue())); if (PGProperty.USER.getOrDefault(result) != null) { result.putIfAbsent(PGProperty.PG_DBNAME.getName(), castNonNull(PGProperty.USER.getOrDefault(result))); } // consistency check if (!PGPropertyUtil.propertiesConsistencyCheck(result)) { return null; } // try to load .pgpass if password is missing if (PGProperty.PASSWORD.getOrDefault(result) == null) { String password = PgPassParser.getPassword( PGProperty.PG_HOST.getOrDefault(result), PGProperty.PG_PORT.getOrDefault(result), PGProperty.PG_DBNAME.getOrDefault(result), PGProperty.USER.getOrDefault(result) ); if (password != null && !password.isEmpty()) { PGProperty.PASSWORD.set(result, password); } } // return result; } // decode url, on failure log and return null private static /* @Nullable */ String urlDecode(String url) { try { return URLCoder.decode(url); } catch (IllegalArgumentException e) { LOGGER.log(Level.FINE, "Url [{0}] parsing failed with error [{1}]", new Object[]{url, e.getMessage()}); } return null; } /** * @return the address portion of the URL */ private static HostSpec[] hostSpecs(Properties props) { String[] hosts = castNonNull(PGProperty.PG_HOST.getOrDefault(props)).split(","); String[] ports = castNonNull(PGProperty.PG_PORT.getOrDefault(props)).split(","); String localSocketAddress = PGProperty.LOCAL_SOCKET_ADDRESS.getOrDefault(props); HostSpec[] hostSpecs = new HostSpec[hosts.length]; for (int i = 0; i < hostSpecs.length; i++) { hostSpecs[i] = new HostSpec(hosts[i], Integer.parseInt(ports[i]), localSocketAddress); } return hostSpecs; } /** * @return the timeout from the URL, in milliseconds */ private static long timeout(Properties props) { String timeout = PGProperty.LOGIN_TIMEOUT.getOrDefault(props); if (timeout != null) { try { return (long) (Float.parseFloat(timeout) * 1000); } catch (NumberFormatException e) { LOGGER.log(Level.WARNING, "Couldn't parse loginTimeout value: {0}", timeout); } } return (long) DriverManager.getLoginTimeout() * 1000; } /** * This method was added in v6.5, and simply throws an SQLException for an unimplemented method. I * decided to do it this way while implementing the JDBC2 extensions to JDBC, as it should help * keep the overall driver size down. It now requires the call Class and the function name to help * when the driver is used with closed software that don't report the stack trace * * @param callClass the call Class * @param functionName the name of the unimplemented function with the type of its arguments * @return PSQLException with a localized message giving the complete description of the * unimplemented function */ public static SQLFeatureNotSupportedException notImplemented(Class callClass, String functionName) { return new SQLFeatureNotSupportedException( GT.tr("Method {0} is not yet implemented.", callClass.getName() + "." + functionName), PSQLState.NOT_IMPLEMENTED.getState()); } @Override public Logger getParentLogger() { return PARENT_LOGGER; } public static SharedTimer getSharedTimer() { return SHARED_TIMER; } /** * Register the driver against {@link DriverManager}. This is done automatically when the class is * loaded. Dropping the driver from DriverManager's list is possible using {@link #deregister()} * method. * * @throws IllegalStateException if the driver is already registered * @throws SQLException if registering the driver fails */ public static void register() throws SQLException { if (isRegistered()) { throw new IllegalStateException( "Driver is already registered. It can only be registered once."); } Driver registeredDriver = new Driver(); DriverManager.registerDriver(registeredDriver); Driver.registeredDriver = registeredDriver; } /** * According to JDBC specification, this driver is registered against {@link DriverManager} when * the class is loaded. To avoid leaks, this method allow unregistering the driver so that the * class can be gc'ed if necessary. * * @throws IllegalStateException if the driver is not registered * @throws SQLException if deregistering the driver fails */ public static void deregister() throws SQLException { if (registeredDriver == null) { throw new IllegalStateException( "Driver is not registered (or it has not been registered using Driver.register() method)"); } DriverManager.deregisterDriver(registeredDriver); registeredDriver = null; } /** * @return {@code true} if the driver is registered against {@link DriverManager} */ public static boolean isRegistered() { return registeredDriver != null; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/PGConnection.java 0100664 0000000 0000000 00000034216 00000250600 025036 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql; import org.postgresql.copy.CopyManager; import org.postgresql.fastpath.Fastpath; import org.postgresql.jdbc.AutoSave; import org.postgresql.jdbc.PreferQueryMode; import org.postgresql.largeobject.LargeObjectManager; import org.postgresql.replication.PGReplicationConnection; import org.postgresql.util.GT; import org.postgresql.util.PGobject; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import org.postgresql.util.PasswordUtil; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.Array; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Arrays; import java.util.Map; /** * This interface defines the public PostgreSQL extensions to java.sql.Connection. All Connections * returned by the PostgreSQL driver implement PGConnection. */ public interface PGConnection { /** * Creates an {@link Array} wrapping elements. This is similar to * {@link java.sql.Connection#createArrayOf(String, Object[])}, but also * provides support for primitive arrays. * * @param typeName * The SQL name of the type to map the elements to. * Must not be {@code null}. * @param elements * The array of objects to map. A {@code null} value will result in * an {@link Array} representing {@code null}. * @return An {@link Array} wrapping elements. * @throws SQLException * If for some reason the array cannot be created. * @see java.sql.Connection#createArrayOf(String, Object[]) */ Array createArrayOf(String typeName, /* @Nullable */ Object elements) throws SQLException; /** * This method returns any notifications that have been received since the last call to this * method. Returns null if there have been no notifications. * * @return notifications that have been received * @throws SQLException if something wrong happens * @since 7.3 */ PGNotification[] getNotifications() throws SQLException; /** * This method returns any notifications that have been received since the last call to this * method. Returns null if there have been no notifications. A timeout can be specified so the * driver waits for notifications. * * @param timeoutMillis when 0, blocks forever. when > 0, blocks up to the specified number of millis * or until at least one notification has been received. If more than one notification is * about to be received, these will be returned in one batch. * @return notifications that have been received * @throws SQLException if something wrong happens * @since 43 */ PGNotification[] getNotifications(int timeoutMillis) throws SQLException; /** * This returns the COPY API for the current connection. * * @return COPY API for the current connection * @throws SQLException if something wrong happens * @since 8.4 */ CopyManager getCopyAPI() throws SQLException; /** * This returns the LargeObject API for the current connection. * * @return LargeObject API for the current connection * @throws SQLException if something wrong happens * @since 7.3 */ LargeObjectManager getLargeObjectAPI() throws SQLException; /** * This returns the Fastpath API for the current connection. * *
* Note: This API is somewhat obsolete, as one may achieve similar performance
* and greater functionality by setting up a prepared statement to define
* the function call. Then, executing the statement with binary transmission of parameters
* and results substitutes for a fast-path function call.
* @return Fastpath API for the current connection
* @throws SQLException if something wrong happens
* @since 7.3
*/
Fastpath getFastpathAPI() throws SQLException;
/**
* This allows client code to add a handler for one of org.postgresql's more unique data types. It
* is approximately equivalent to addDataType(type, Class.forName(name)).
*
* @param type JDBC type name
* @param className class name
* @throws RuntimeException if the type cannot be registered (class not found, etc).
* @deprecated As of 8.0, replaced by {@link #addDataType(String, Class)}. This deprecated method
* does not work correctly for registering classes that cannot be directly loaded by
* the JDBC driver's classloader.
*/
@Deprecated
void addDataType(String type, String className);
/**
* This allows client code to add a handler for one of org.postgresql's more unique data types.
*
*
NOTE: This is not part of JDBC, but an extension.
* *The best way to use this is as follows:
* *
* ...
* ((org.postgresql.PGConnection)myconn).addDataType("mytype", my.class.name.class);
* ...
*
*
* where myconn is an open Connection to org.postgresql.
* *The handling class must extend org.postgresql.util.PGobject
* * @param type the PostgreSQL type to register * @param klass the class implementing the Java representation of the type; this class must * implement {@link org.postgresql.util.PGobject}). * @throws SQLException ifklass does not implement
* {@link org.postgresql.util.PGobject}).
* @see org.postgresql.util.PGobject
* @since 8.0
*/
void addDataType(String type, Class klass) throws SQLException;
/**
* Set the default statement reuse threshold before enabling server-side prepare. See
* {@link org.postgresql.PGStatement#setPrepareThreshold(int)} for details.
*
* @param threshold the new threshold
* @since build 302
*/
void setPrepareThreshold(int threshold);
/**
* Get the default server-side prepare reuse threshold for statements created from this
* connection.
*
* @return the current threshold
* @since build 302
*/
int getPrepareThreshold();
/**
* Set the default fetch size for statements created from this connection.
*
* @param fetchSize new default fetch size
* @throws SQLException if specified negative fetchSize parameter
* @see Statement#setFetchSize(int)
*/
void setDefaultFetchSize(int fetchSize) throws SQLException;
/**
* Get the default fetch size for statements created from this connection.
*
* @return current state for default fetch size
* @see PGProperty#DEFAULT_ROW_FETCH_SIZE
* @see Statement#getFetchSize()
*/
int getDefaultFetchSize();
/**
* Return the process ID (PID) of the backend server process handling this connection.
*
* @return PID of backend server process.
*/
int getBackendPID();
/**
* Sends a query cancellation for this connection.
* @throws SQLException if there are problems cancelling the query
*/
void cancelQuery() throws SQLException;
/**
* Return the given string suitably quoted to be used as an identifier in an SQL statement string.
* Quotes are added only if necessary (i.e., if the string contains non-identifier characters or
* would be case-folded). Embedded quotes are properly doubled.
*
* @param identifier input identifier
* @return the escaped identifier
* @throws SQLException if something goes wrong
*/
String escapeIdentifier(String identifier) throws SQLException;
/**
* Return the given string suitably quoted to be used as a string literal in an SQL statement
* string. Embedded single-quotes and backslashes are properly doubled. Note that quote_literal
* returns null on null input.
*
* @param literal input literal
* @return the quoted literal
* @throws SQLException if something goes wrong
*/
String escapeLiteral(String literal) throws SQLException;
/**
* Returns the query mode for this connection.
*
* When running in simple query mode, certain features are not available: callable statements, * partial result set fetch, bytea type, etc.
* *The list of supported features is subject to change.
* * @return the preferred query mode * @see PreferQueryMode */ PreferQueryMode getPreferQueryMode(); /** * Connection configuration regarding automatic per-query savepoints. * * @return connection configuration regarding automatic per-query savepoints * @see PGProperty#AUTOSAVE */ AutoSave getAutosave(); /** * Configures if connection should use automatic savepoints. * @param autoSave connection configuration regarding automatic per-query savepoints * @see PGProperty#AUTOSAVE */ void setAutosave(AutoSave autoSave); /** * @return replication API for the current connection */ PGReplicationConnection getReplicationAPI(); /** * Change a user's password to the specified new password. * ** If the specific encryption type is not specified, this method defaults to querying the database server for the server's default password_encryption. * This method does not send the new password in plain text to the server. * Instead, it encrypts the password locally and sends the encoded hash so that the plain text password is never sent on the wire. *
* ** Acceptable values for encryptionType are null, "md5", or "scram-sha-256". * Users should avoid "md5" unless they are explicitly targeting an older server that does not support the more secure SCRAM. *
* * @param user The username of the database user * @param newPassword The new password for the database user. The implementation will zero * out the array after use * @param encryptionType The type of password encryption to use or null if the database server default should be used. * @throws SQLException If the password could not be altered */ default void alterUserPassword(String user, char[] newPassword, /* @Nullable */ String encryptionType) throws SQLException { try (Statement stmt = ((Connection) this).createStatement()) { if (encryptionType == null) { try (ResultSet rs = stmt.executeQuery("SHOW password_encryption")) { if (!rs.next()) { throw new PSQLException(GT.tr("Expected a row when reading password_encryption but none was found"), PSQLState.NO_DATA); } encryptionType = rs.getString(1); if (encryptionType == null) { throw new PSQLException(GT.tr("SHOW password_encryption returned null value"), PSQLState.NO_DATA); } } } String sql = PasswordUtil.genAlterUserPasswordSQL(user, newPassword, encryptionType); stmt.execute(sql); } finally { Arrays.fill(newPassword, (char) 0); } } /** * Returns the current values of all parameters reported by the server. * *PostgreSQL reports values for a subset of parameters (GUCs) to the client
* at connect-time, then sends update messages whenever the values change
* during a session. PgJDBC records the latest values and exposes it to client
* applications via getParameterStatuses().
PgJDBC exposes individual accessors for some of these parameters as * listed below. They are more backwards-compatible and should be preferred * where possible.
* *Not all parameters are reported, only those marked
* GUC_REPORT in the source code. The pg_settings
* view does not expose information about which parameters are reportable.
* PgJDBC's map will only contain the parameters the server reports values
* for, so you cannot use this method as a substitute for running a
* SHOW paramname; or SELECT
* current_setting('paramname'); query for arbitrary parameters.
Parameter names are case-insensitive and case-preserving
* in this map, like in PostgreSQL itself. So DateStyle and
* datestyle are the same key.
* As of PostgreSQL 11 the reportable parameter list, and related PgJDBC * interfaces or assessors, are: *
* *application_name -
* {@link java.sql.Connection#getClientInfo()},
* {@link java.sql.Connection#setClientInfo(java.util.Properties)}
* and ApplicationName connection property.
* client_encoding - PgJDBC always sets this to UTF8.
* See allowEncodingChanges connection property.
* DateStyle - PgJDBC requires this to always be set to ISOstandard_conforming_strings - indirectly via {@link #escapeLiteral(String)}TimeZone - set from JDK timezone see {@link java.util.TimeZone#getDefault()}
* and {@link java.util.TimeZone#setDefault(TimeZone)}
* integer_datetimesIntervalStyleserver_encodingserver_versionis_superuser session_authorizationNote that some PgJDBC operations will change server parameters * automatically.
* * @return unmodifiable map of case-insensitive parameter names to parameter values * @since 42.2.6 */ MapThe timeout is specified in seconds and a value of zero means that it is disabled.
*/ CONNECT_TIMEOUT( "connectTimeout", "10", "The timeout value in seconds used for socket connect operations."), /** * Specify the schema (or several schema separated by commas) to be set in the search-path. This schema will be used to resolve * unqualified object names used in statements over this connection. */ CURRENT_SCHEMA( "currentSchema", null, "Specify the schema (or several schema separated by commas) to be set in the search-path"), /** * Specifies the maximum number of fields to be cached per connection. A value of {@code 0} disables the cache. */ DATABASE_METADATA_CACHE_FIELDS( "databaseMetadataCacheFields", "65536", "Specifies the maximum number of fields to be cached per connection. A value of {@code 0} disables the cache."), /** * Specifies the maximum size (in megabytes) of fields to be cached per connection. A value of {@code 0} disables the cache. */ DATABASE_METADATA_CACHE_FIELDS_MIB( "databaseMetadataCacheFieldsMiB", "5", "Specifies the maximum size (in megabytes) of fields to be cached per connection. A value of {@code 0} disables the cache."), /** * Default parameter for {@link java.sql.Statement#getFetchSize()}. A value of {@code 0} means * that need fetch all rows at once */ DEFAULT_ROW_FETCH_SIZE( "defaultRowFetchSize", "0", "Positive number of rows that should be fetched from the database when more rows are needed for ResultSet by each fetch iteration"), /** * Enable optimization that disables column name sanitiser. */ DISABLE_COLUMN_SANITISER( "disableColumnSanitiser", "false", "Enable optimization that disables column name sanitiser"), /** * Specifies how the driver transforms JDBC escape call syntax into underlying SQL, for invoking procedures or functions. (backend >= 11) * In {@code escapeSyntaxCallMode=select} mode (the default), the driver always uses a SELECT statement (allowing function invocation only). * In {@code escapeSyntaxCallMode=callIfNoReturn} mode, the driver uses a CALL statement (allowing procedure invocation) if there is no return parameter specified, otherwise the driver uses a SELECT statement. * In {@code escapeSyntaxCallMode=call} mode, the driver always uses a CALL statement (allowing procedure invocation only). */ ESCAPE_SYNTAX_CALL_MODE( "escapeSyntaxCallMode", "select", "Specifies how the driver transforms JDBC escape call syntax into underlying SQL, for invoking procedures or functions. (backend >= 11)" + "In escapeSyntaxCallMode=select mode (the default), the driver always uses a SELECT statement (allowing function invocation only)." + "In escapeSyntaxCallMode=callIfNoReturn mode, the driver uses a CALL statement (allowing procedure invocation) if there is no return parameter specified, otherwise the driver uses a SELECT statement." + "In escapeSyntaxCallMode=call mode, the driver always uses a CALL statement (allowing procedure invocation only).", false, new String[]{"select", "callIfNoReturn", "call"}), /** * Group startup parameters in a transaction * This is important in pool-by-transaction scenarios in order to make sure that all the statements * reaches the same connection that is being initialized. All of the startup parameters will be wrapped * in a transaction * Note this is off by default as pgbouncer in statement mode * @deprecated since we can send the startup parameters as a multistatment transaction */ @Deprecated GROUP_STARTUP_PARAMETERS( "groupStartupParameters", "false", "This is important in pool-by-transaction scenarios in order to make sure that all " + "the statements reaches the same connection that is being initialized." ), GSS_ENC_MODE( "gssEncMode", "allow", "Force Encoded GSS Mode", false, new String[]{"disable", "allow", "prefer", "require"} ), /** * Force one of *This mode is meant for debugging purposes and/or for cases when extended protocol cannot be used (e.g. logical replication protocol)
*/ PREFER_QUERY_MODE( "preferQueryMode", "extended", "Specifies which mode is used to execute queries to database: simple means ('Q' execute, no parse, no bind, text mode only), " + "extended means always use bind/execute messages, extendedForPrepared means extended for prepared statements only, " + "extendedCacheEverything means use extended protocol and try cache every statement (including Statement.execute(String sql)) in a query cache.", false, new String[]{"extended", "extendedForPrepared", "extendedCacheEverything", "simple"}), /** * Specifies the maximum number of entries in cache of prepared statements. A value of {@code 0} * disables the cache. */ PREPARED_STATEMENT_CACHE_QUERIES( "preparedStatementCacheQueries", "256", "Specifies the maximum number of entries in per-connection cache of prepared statements. A value of {@code 0} disables the cache."), /** * Specifies the maximum size (in megabytes) of the prepared statement cache. A value of {@code 0} * disables the cache. */ PREPARED_STATEMENT_CACHE_SIZE_MIB( "preparedStatementCacheSizeMiB", "5", "Specifies the maximum size (in megabytes) of a per-connection prepared statement cache. A value of {@code 0} disables the cache."), /** * Sets the default threshold for enabling server-side prepare. A value of {@code -1} stands for * forceBinary */ PREPARE_THRESHOLD( "prepareThreshold", "5", "Statement prepare threshold. A value of {@code -1} stands for forceBinary"), /** * Force use of a particular protocol version when connecting, if set, disables protocol version * fallback. */ PROTOCOL_VERSION( "protocolVersion", "3", "Force use of a particular protocol version when connecting, currently only version 3 is supported.", false, new String[]{"3"}), /** * Quote returning columns. * There are some ORM's that quote everything, including returning columns * If we quote them, then we end up sending ""colname"" to the backend * which will not be found */ QUOTE_RETURNING_IDENTIFIERS( "quoteReturningIdentifiers", "true", "Quote identifiers provided in returning array", false), /** * Puts this connection in read-only mode. */ READ_ONLY( "readOnly", "false", "Puts this connection in read-only mode"), /** * Connection parameter to control behavior when * {@link Connection#setReadOnly(boolean)} is set to {@code true}. */ READ_ONLY_MODE( "readOnlyMode", "transaction", "Controls the behavior when a connection is set to be read only, one of 'ignore', 'transaction', or 'always' " + "When 'ignore', setting readOnly has no effect. " + "When 'transaction' setting readOnly to 'true' will cause transactions to BEGIN READ ONLY if autocommit is 'false'. " + "When 'always' setting readOnly to 'true' will set the session to READ ONLY if autoCommit is 'true' " + "and the transaction to BEGIN READ ONLY if autocommit is 'false'.", false, new String[]{"ignore", "transaction", "always"}), /** * Socket read buffer size (SO_RECVBUF). A value of {@code -1}, which is the default, means system * default. */ RECEIVE_BUFFER_SIZE( "receiveBufferSize", "-1", "Socket read buffer size"), /** * Connection parameter passed in the startup message. This parameter accepts two values; "true" * and "database". Passing "true" tells the backend to go into walsender mode, wherein a small set * of replication commands can be issued instead of SQL statements. Only the simple query protocol * can be used in walsender mode. Passing "database" as the value instructs walsender to connect * to the database specified in the dbname parameter, which will allow the connection to be used * for logical replication from that database. * *Parameter should be use together with {@link PGProperty#ASSUME_MIN_SERVER_VERSION} with * parameter >= 9.4 (backend >= 9.4)
*/ REPLICATION( "replication", null, "Connection parameter passed in startup message, one of 'true' or 'database' " + "Passing 'true' tells the backend to go into walsender mode, " + "wherein a small set of replication commands can be issued instead of SQL statements. " + "Only the simple query protocol can be used in walsender mode. " + "Passing 'database' as the value instructs walsender to connect " + "to the database specified in the dbname parameter, " + "which will allow the connection to be used for logical replication " + "from that database. " + "(backend >= 9.4)"), /** * Configure optimization to enable batch insert re-writing. */ REWRITE_BATCHED_INSERTS( "reWriteBatchedInserts", "false", "Enable optimization to rewrite and collapse compatible INSERT statements that are batched."), /** * Socket write buffer size (SO_SNDBUF). A value of {@code -1}, which is the default, means system * default. */ SEND_BUFFER_SIZE( "sendBufferSize", "-1", "Socket write buffer size"), /** * Service name to use for additional parameters. It specifies a service name in "pg_service * .conf" that holds additional connection parameters. This allows applications to specify only * a service name so connection parameters can be centrally maintained. */ SERVICE( "service", null, "Service name to be searched in pg_service.conf resource"), /** * Socket factory used to create socket. A null value, which is the default, means system default. */ SOCKET_FACTORY( "socketFactory", null, "Specify a socket factory for socket creation"), /** * The String argument to give to the constructor of the Socket Factory. */ SOCKET_FACTORY_ARG( "socketFactoryArg", null, "Argument forwarded to constructor of SocketFactory class."), /** * The timeout value used for socket read operations. If reading from the server takes longer than * this value, the connection is closed. This can be used as both a brute force global query * timeout and a method of detecting network problems. The timeout is specified in seconds and a * value of zero means that it is disabled. */ SOCKET_TIMEOUT( "socketTimeout", "0", "The timeout value in seconds max(2147484) used for socket read operations."), /** * Control use of SSL: empty or {@code true} values imply {@code sslmode==verify-full} */ SSL( "ssl", null, "Control use of SSL (any non-null value causes SSL to be required)"), /** * File containing the SSL Certificate. Default will be the file {@code postgresql.crt} in {@code * $HOME/.postgresql} (*nix) or {@code %APPDATA%\postgresql} (windows). */ SSL_CERT( "sslcert", null, "The location of the client's SSL certificate"), /** * Classname of the SSL Factory to use (instance of {@link javax.net.ssl.SSLSocketFactory}). */ SSL_FACTORY( "sslfactory", "org.postgresql.ssl.LibPQFactory", "Provide a SSLSocketFactory class when using SSL."), /** * The String argument to give to the constructor of the SSL Factory. */ SSL_FACTORY_ARG( "sslfactoryarg", null, "Argument forwarded to constructor of SSLSocketFactory class."), /** * Classname of the SSL HostnameVerifier to use (instance of {@link javax.net.ssl.HostnameVerifier}). */ SSL_HOSTNAME_VERIFIER( "sslhostnameverifier", null, "A class, implementing javax.net.ssl.HostnameVerifier that can verify the server"), /** * File containing the SSL Key. Default will be the file {@code postgresql.pk8} in {@code $HOME/.postgresql} (*nix) * or {@code %APPDATA%\postgresql} (windows). */ SSL_KEY( "sslkey", null, "The location of the client's PKCS#8 SSL key"), /** * Parameter governing the use of SSL. The allowed values are {@code disable}, {@code allow}, * {@code prefer}, {@code require}, {@code verify-ca}, {@code verify-full}. * If {@code ssl} property is empty or set to {@code true} it implies {@code verify-full}. * Default mode is "require" */ SSL_MODE( "sslmode", null, "Parameter governing the use of SSL", false, new String[]{"disable", "allow", "prefer", "require", "verify-ca", "verify-full"}), /** * Normally a GSS connection is attempted first. If this is set to {@code direct} * then the GSS connection attempt will not be made */ SSL_NEGOTIATION( "sslNegotiation", "postgres", "This option controls whether the driver will perform its protocol\n" + "negotiation to request encryption from the server or will just\n" + "directly make a standard SSL connection. Traditional PostgreSQL\n" + "protocol negotiation is the default and the most flexible with\n" + "different server configurations. If the server is known to support\n" + "direct SSL connections then the latter requires one\n" + "fewer round trip reducing connection latency and also allows the use\n" + "of protocol agnostic SSL network tools.", false, new String[]{"postgres", "direct"}), /** * The SSL password to use in the default CallbackHandler. */ SSL_PASSWORD( "sslpassword", null, "The password for the client's ssl key (ignored if sslpasswordcallback is set)"), /** * The classname instantiating {@link javax.security.auth.callback.CallbackHandler} to use. */ SSL_PASSWORD_CALLBACK( "sslpasswordcallback", null, "A class, implementing javax.security.auth.callback.CallbackHandler that can handle PasswordCallback for the ssl password."), /** * After requesting an upgrade to SSL from the server there are reports of the server not responding due to a failover * without a timeout here, the client can wait forever. This timeout will be set before the request and reset after */ SSL_RESPONSE_TIMEOUT( "sslResponseTimeout", "5000", "Time in milliseconds we wait for a response from the server after requesting SSL upgrade"), /** * File containing the root certificate when validating server ({@code sslmode} = {@code * verify-ca} or {@code verify-full}). Default will be the file {@code root.crt} in {@code * $HOME/.postgresql} (*nix) or {@code %APPDATA%\postgresql} (windows). */ SSL_ROOT_CERT( "sslrootcert", null, "The location of the root certificate for authenticating the server."), /** * Specifies the name of the SSPI service class that forms the service class part of the SPN. The * default, {@code POSTGRES}, is almost always correct. */ SSPI_SERVICE_CLASS( "sspiServiceClass", "POSTGRES", "The Windows SSPI service class for SPN"), /** * Bind String to either {@code unspecified} or {@code varchar}. Default is {@code varchar} for * 8.0+ backends. */ STRING_TYPE( "stringtype", null, "The type to bind String parameters as (usually 'varchar', 'unspecified' allows implicit casting to other types)", false, new String[]{"unspecified", "varchar"}), TARGET_SERVER_TYPE( "targetServerType", "any", "Specifies what kind of server to connect", false, new String []{"any", "primary", "master", "slave", "secondary", "preferSlave", "preferSecondary", "preferPrimary"}), /** * Enable or disable TCP keep-alive. The default is {@code false}. */ TCP_KEEP_ALIVE( "tcpKeepAlive", "false", "Enable or disable TCP keep-alive. The default is {@code false}."), TCP_NO_DELAY( "tcpNoDelay", "true", "Enable or disable TCP no delay. The default is (@code true}." ), /** * Specifies the length to return for types of unknown length. */ UNKNOWN_LENGTH( "unknownLength", Integer.toString(Integer.MAX_VALUE), "Specifies the length to return for types of unknown length"), /** * Username to connect to the database as. */ USER( "user", null, "Username to connect to the database as.", true), /** * Use SPNEGO in SSPI authentication requests. */ USE_SPNEGO( "useSpnego", "false", "Use SPNEGO in SSPI authentication requests"), /** * Factory class to instantiate factories for XML processing. * The default factory disables external entity processing. * Legacy behavior with external entity processing can be enabled by specifying a value of LEGACY_INSECURE. * Or specify a custom class that implements {@link org.postgresql.xml.PGXmlFactoryFactory}. */ XML_FACTORY_FACTORY( "xmlFactoryFactory", "", "Factory class to instantiate factories for XML processing"), ; private final String name; private final /* @Nullable */ String defaultValue; private final boolean required; private final String description; @SuppressWarnings("ImmutableEnumChecker") private final String /* @Nullable */ [] choices; PGProperty(String name, /* @Nullable */ String defaultValue, String description) { this(name, defaultValue, description, false); } PGProperty(String name, /* @Nullable */ String defaultValue, String description, boolean required) { this(name, defaultValue, description, required, (String[]) null); } PGProperty(String name, /* @Nullable */ String defaultValue, String description, boolean required, String /* @Nullable */ [] choices) { this.name = name; this.defaultValue = defaultValue; this.required = required; this.description = description; this.choices = choices; } private static final MapsetPrepareThreshold(1).
*
* @param flag use server prepare
* @throws SQLException if something goes wrong
* @since 7.3
* @deprecated As of build 302, replaced by {@link #setPrepareThreshold(int)}
*/
@Deprecated
void setUseServerPrepare(boolean flag) throws SQLException;
/**
* Checks if this statement will be executed as a server-prepared statement. A return value of
* true indicates that the next execution of the statement will be done as a
* server-prepared statement, assuming the underlying protocol supports it.
*
* @return true if the next reuse of this statement will use a server-prepared statement
*/
boolean isUseServerPrepare();
/**
* Sets the reuse threshold for using server-prepared statements.
*
* If threshold is a non-zero value N, the Nth and subsequent reuses of a
* PreparedStatement will use server-side prepare.
If threshold is zero, server-side prepare will not be used.
The reuse threshold is only used by PreparedStatement and CallableStatement objects; it is * ignored for plain Statements.
* * @param threshold the new threshold for this statement * @throws SQLException if an exception occurs while changing the threshold * @since build 302 */ void setPrepareThreshold(int threshold) throws SQLException; /** * Gets the server-side prepare reuse threshold in use for this statement. * * @return the current threshold * @see #setPrepareThreshold(int) * @since build 302 */ int getPrepareThreshold(); /** * Turn on/off adaptive fetch for statement. Existing resultSets won't be affected by change * here. * * @param adaptiveFetch desired state of adaptive fetch. */ void setAdaptiveFetch(boolean adaptiveFetch); /** * Get state of adaptive fetch for statement. * * @return state of adaptive fetch (turned on or off) */ boolean getAdaptiveFetch(); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/package-info.java 0100664 0000000 0000000 00000001126 00000250600 025026 0 ustar 00 0000000 0000000 /* * Copyright (c) 2020, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ /* @DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.FIELD) */ /* @DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.PARAMETER) */ /* @DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.RETURN) */ package org.postgresql; // import org.checkerframework.checker.nullness.qual.NonNull; // import org.checkerframework.framework.qual.DefaultQualifier; // import org.checkerframework.framework.qual.TypeUseLocation; postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/ 0040775 0000000 0000000 00000000000 00000250600 022614 5 ustar 00 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/CopyDual.java 0100664 0000000 0000000 00000000556 00000250600 025202 0 ustar 00 0000000 0000000 /* * Copyright (c) 2016, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; /** * Bidirectional via copy stream protocol. Via bidirectional copy protocol work PostgreSQL * replication. * * @see CopyIn * @see CopyOut */ public interface CopyDual extends CopyIn, CopyOut { } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/CopyIn.java 0100664 0000000 0000000 00000003235 00000250600 024660 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; import org.postgresql.util.ByteStreamWriter; import java.sql.SQLException; /** * Copy bulk data from client into a PostgreSQL table very fast. */ public interface CopyIn extends CopyOperation { /** * Writes specified part of given byte array to an open and writable copy operation. * * @param buf array of bytes to write * @param off offset of first byte to write (normally zero) * @param siz number of bytes to write (normally buf.length) * @throws SQLException if the operation fails */ void writeToCopy(byte[] buf, int off, int siz) throws SQLException; /** * Writes a ByteStreamWriter to an open and writable copy operation. * * @param from the source of bytes, e.g. a ByteBufferByteStreamWriter * @throws SQLException if the operation fails */ void writeToCopy(ByteStreamWriter from) throws SQLException; /** * Force any buffered output to be sent over the network to the backend. In general this is a * useless operation as it will get pushed over in due time or when endCopy is called. Some * specific modified server versions (Truviso) want this data sooner. If you are unsure if you * need to use this method, don't. * * @throws SQLException if the operation fails. */ void flushCopy() throws SQLException; /** * Finishes copy operation successfully. * * @return number of updated rows for server 8.2 or newer (see getHandledRowCount()) * @throws SQLException if the operation fails. */ long endCopy() throws SQLException; } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/CopyManager.java 0100664 0000000 0000000 00000021575 00000250600 025673 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; import org.postgresql.core.BaseConnection; import org.postgresql.core.Encoding; import org.postgresql.core.QueryExecutor; import org.postgresql.util.ByteStreamWriter; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.Reader; import java.io.Writer; import java.sql.SQLException; /** * API for PostgreSQL COPY bulk data transfer. */ public class CopyManager { // I don't know what the best buffer size is, so we let people specify it if // they want, and if they don't know, we don't make them guess, so that if we // do figure it out we can just set it here and they reap the rewards. // Note that this is currently being used for both a number of bytes and a number // of characters. static final int DEFAULT_BUFFER_SIZE = 65536; private final Encoding encoding; private final QueryExecutor queryExecutor; private final BaseConnection connection; public CopyManager(BaseConnection connection) throws SQLException { this.encoding = connection.getEncoding(); this.queryExecutor = connection.getQueryExecutor(); this.connection = connection; } public CopyIn copyIn(String sql) throws SQLException { CopyOperation op = queryExecutor.startCopy(sql, connection.getAutoCommit()); if (op == null || op instanceof CopyIn) { return (CopyIn) op; } else { op.cancelCopy(); throw new PSQLException(GT.tr("Requested CopyIn but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE); } } public CopyOut copyOut(String sql) throws SQLException { CopyOperation op = queryExecutor.startCopy(sql, connection.getAutoCommit()); if (op == null || op instanceof CopyOut) { return (CopyOut) op; } else { op.cancelCopy(); throw new PSQLException(GT.tr("Requested CopyOut but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE); } } public CopyDual copyDual(String sql) throws SQLException { CopyOperation op = queryExecutor.startCopy(sql, connection.getAutoCommit()); if (op == null || op instanceof CopyDual) { return (CopyDual) op; } else { op.cancelCopy(); throw new PSQLException(GT.tr("Requested CopyDual but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE); } } /** * Pass results of a COPY TO STDOUT query from database into a Writer. * * @param sql COPY TO STDOUT statement * @param to the Writer to write the results to (row by row). * The Writer is not closed at the end of the Copy Out operation. * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage errors * @throws IOException upon writer or database connection failure */ public long copyOut(final String sql, Writer to) throws SQLException, IOException { byte[] buf; CopyOut cp = copyOut(sql); try { while ((buf = cp.readFromCopy()) != null) { to.write(encoding.decode(buf)); } return cp.getHandledRowCount(); } catch (IOException ioEX) { // if not handled this way the close call will hang, at least in 8.2 if (cp.isActive()) { cp.cancelCopy(); } try { // read until exhausted or operation cancelled SQLException while ((buf = cp.readFromCopy()) != null) { } } catch (SQLException sqlEx) { // typically after several kB } throw ioEX; } finally { // see to it that we do not leave the connection locked if (cp.isActive()) { cp.cancelCopy(); } } } /** * Pass results of a COPY TO STDOUT query from database into an OutputStream. * * @param sql COPY TO STDOUT statement * @param to the stream to write the results to (row by row) * The stream is not closed at the end of the operation. This is intentional so the * caller can continue to write to the output stream * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage errors * @throws IOException upon output stream or database connection failure */ public long copyOut(final String sql, OutputStream to) throws SQLException, IOException { byte[] buf; CopyOut cp = copyOut(sql); try { while ((buf = cp.readFromCopy()) != null) { to.write(buf); } return cp.getHandledRowCount(); } catch (IOException ioEX) { // if not handled this way the close call will hang, at least in 8.2 if (cp.isActive()) { cp.cancelCopy(); } try { // read until exhausted or operation cancelled SQLException while ((buf = cp.readFromCopy()) != null) { } } catch (SQLException sqlEx) { // typically after several kB } throw ioEX; } finally { // see to it that we do not leave the connection locked if (cp.isActive()) { cp.cancelCopy(); } } } /** * Use COPY FROM STDIN for very fast copying from a Reader into a database table. * * @param sql COPY FROM STDIN statement * @param from a CSV file or such * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage issues * @throws IOException upon reader or database connection failure */ public long copyIn(final String sql, Reader from) throws SQLException, IOException { return copyIn(sql, from, DEFAULT_BUFFER_SIZE); } /** * Use COPY FROM STDIN for very fast copying from a Reader into a database table. * * @param sql COPY FROM STDIN statement * @param from a CSV file or such * @param bufferSize number of characters to buffer and push over network to server at once * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage issues * @throws IOException upon reader or database connection failure */ public long copyIn(final String sql, Reader from, int bufferSize) throws SQLException, IOException { char[] cbuf = new char[bufferSize]; int len; CopyIn cp = copyIn(sql); try { while ((len = from.read(cbuf)) >= 0) { if (len > 0) { byte[] buf = encoding.encode(new String(cbuf, 0, len)); cp.writeToCopy(buf, 0, buf.length); } } return cp.endCopy(); } finally { // see to it that we do not leave the connection locked if (cp.isActive()) { cp.cancelCopy(); } } } /** * Use COPY FROM STDIN for very fast copying from an InputStream into a database table. * * @param sql COPY FROM STDIN statement * @param from a CSV file or such * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage issues * @throws IOException upon input stream or database connection failure */ public long copyIn(final String sql, InputStream from) throws SQLException, IOException { return copyIn(sql, from, DEFAULT_BUFFER_SIZE); } /** * Use COPY FROM STDIN for very fast copying from an InputStream into a database table. * * @param sql COPY FROM STDIN statement * @param from a CSV file or such * @param bufferSize number of bytes to buffer and push over network to server at once * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage issues * @throws IOException upon input stream or database connection failure */ public long copyIn(final String sql, InputStream from, int bufferSize) throws SQLException, IOException { byte[] buf = new byte[bufferSize]; int len; CopyIn cp = copyIn(sql); try { while ((len = from.read(buf)) >= 0) { if (len > 0) { cp.writeToCopy(buf, 0, len); } } return cp.endCopy(); } finally { // see to it that we do not leave the connection locked if (cp.isActive()) { cp.cancelCopy(); } } } /** * Use COPY FROM STDIN for very fast copying from an ByteStreamWriter into a database table. * * @param sql COPY FROM STDIN statement * @param from the source of bytes, e.g. a ByteBufferByteStreamWriter * @return number of rows updated for server 8.2 or newer; -1 for older * @throws SQLException on database usage issues * @throws IOException upon input stream or database connection failure */ public long copyIn(String sql, ByteStreamWriter from) throws SQLException, IOException { CopyIn cp = copyIn(sql); try { cp.writeToCopy(from); return cp.endCopy(); } finally { // see to it that we do not leave the connection locked if (cp.isActive()) { cp.cancelCopy(); } } } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/CopyOperation.java 0100664 0000000 0000000 00000002407 00000250600 026252 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; import java.sql.SQLException; /** * Exchange bulk data between client and PostgreSQL database tables. See CopyIn and CopyOut for full * interfaces for corresponding copy directions. */ public interface CopyOperation { /** * @return number of fields in each row for this operation */ int getFieldCount(); /** * @return overall format of each row: 0 = textual, 1 = binary */ int getFormat(); /** * @param field number of field (0..fieldCount()-1) * @return format of requested field: 0 = textual, 1 = binary */ int getFieldFormat(int field); /** * @return is connection reserved for this Copy operation? */ boolean isActive(); /** * Cancels this copy operation, discarding any exchanged data. * * @throws SQLException if cancelling fails */ void cancelCopy() throws SQLException; /** * After successful end of copy, returns the number of database records handled in that operation. * Only implemented in PostgreSQL server version 8.2 and up. Otherwise, returns -1. * * @return number of handled rows or -1 */ long getHandledRowCount(); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/CopyOut.java 0100664 0000000 0000000 00000002226 00000250600 025060 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; public interface CopyOut extends CopyOperation { /** * Blocks wait for a row of data to be received from server on an active copy operation. * * @return byte array received from server, null if server complete copy operation * @throws SQLException if something goes wrong for example socket timeout */ byte /* @Nullable */ [] readFromCopy() throws SQLException; /** * Wait for a row of data to be received from server on an active copy operation. * * @param block {@code true} if need wait data from server otherwise {@code false} and will read * pending message from server * @return byte array received from server, if pending message from server absent and use no * blocking mode return null * @throws SQLException if something goes wrong for example socket timeout */ byte /* @Nullable */ [] readFromCopy(boolean block) throws SQLException; } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/PGCopyInputStream.java 0100664 0000000 0000000 00000010501 00000250600 027006 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.PGConnection; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.io.InputStream; import java.sql.SQLException; import java.util.Arrays; /** * InputStream for reading from a PostgreSQL COPY TO STDOUT operation. */ public class PGCopyInputStream extends InputStream implements CopyOut { private /* @Nullable */ CopyOut op; private byte /* @Nullable */ [] buf; private int at; private int len; /** * Uses given connection for specified COPY TO STDOUT operation. * * @param connection database connection to use for copying (protocol version 3 required) * @param sql COPY TO STDOUT statement * @throws SQLException if initializing the operation fails */ public PGCopyInputStream(PGConnection connection, String sql) throws SQLException { this(connection.getCopyAPI().copyOut(sql)); } /** * Use given CopyOut operation for reading. * * @param op COPY TO STDOUT operation */ public PGCopyInputStream(CopyOut op) { this.op = op; } private CopyOut getOp() { return castNonNull(op); } private byte /* @Nullable */ [] fillBuffer() throws IOException { if (at >= len) { try { buf = getOp().readFromCopy(); } catch (SQLException sqle) { throw new IOException(GT.tr("Copying from database failed: {0}", sqle.getMessage()), sqle); } if (buf == null) { at = -1; } else { at = 0; len = buf.length; } } return buf; } private void checkClosed() throws IOException { if (op == null) { throw new IOException(GT.tr("This copy stream is closed.")); } } @Override public int available() throws IOException { checkClosed(); return buf != null ? len - at : 0; } @Override public int read() throws IOException { checkClosed(); byte[] buf = fillBuffer(); return buf != null ? (buf[at++] & 0xFF) : -1; } @Override public int read(byte[] buf) throws IOException { return read(buf, 0, buf.length); } @Override public int read(byte[] buf, int off, int siz) throws IOException { checkClosed(); int got = 0; byte[] data = fillBuffer(); for (; got < siz && data != null; data = fillBuffer()) { int length = Math.min(siz - got, len - at); System.arraycopy(data, at, buf, off + got, length); at += length; got += length; } return got == 0 && data == null ? -1 : got; } @Override public byte /* @Nullable */ [] readFromCopy() throws SQLException { byte[] result = null; try { byte[] buf = fillBuffer(); if (buf != null) { if (at > 0 || len < buf.length) { result = Arrays.copyOfRange(buf, at, len); } else { result = buf; } // Mark the buffer as fully read at = len; } } catch (IOException ioe) { throw new PSQLException(GT.tr("Read from copy failed."), PSQLState.CONNECTION_FAILURE, ioe); } return result; } @Override public byte /* @Nullable */ [] readFromCopy(boolean block) throws SQLException { return readFromCopy(); } @Override public void close() throws IOException { // Don't complain about a double close. CopyOut op = this.op; if (op == null) { return; } if (op.isActive()) { try { op.cancelCopy(); } catch (SQLException se) { throw new IOException("Failed to close copy reader.", se); } } this.op = null; } @Override public void cancelCopy() throws SQLException { getOp().cancelCopy(); } @Override public int getFormat() { return getOp().getFormat(); } @Override public int getFieldFormat(int field) { return getOp().getFieldFormat(field); } @Override public int getFieldCount() { return getOp().getFieldCount(); } @Override public boolean isActive() { return op != null && op.isActive(); } @Override public long getHandledRowCount() { return getOp().getHandledRowCount(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/copy/PGCopyOutputStream.java 0100664 0000000 0000000 00000012315 00000250600 027214 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.copy; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.PGConnection; import org.postgresql.util.ByteStreamWriter; import org.postgresql.util.GT; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.io.OutputStream; import java.sql.SQLException; /** * OutputStream for buffered input into a PostgreSQL COPY FROM STDIN operation. */ public class PGCopyOutputStream extends OutputStream implements CopyIn { private /* @Nullable */ CopyIn op; private final byte[] copyBuffer; private final byte[] singleByteBuffer = new byte[1]; private int at; /** * Uses given connection for specified COPY FROM STDIN operation. * * @param connection database connection to use for copying (protocol version 3 required) * @param sql COPY FROM STDIN statement * @throws SQLException if initializing the operation fails */ public PGCopyOutputStream(PGConnection connection, String sql) throws SQLException { this(connection, sql, CopyManager.DEFAULT_BUFFER_SIZE); } /** * Uses given connection for specified COPY FROM STDIN operation. * * @param connection database connection to use for copying (protocol version 3 required) * @param sql COPY FROM STDIN statement * @param bufferSize try to send this many bytes at a time * @throws SQLException if initializing the operation fails */ public PGCopyOutputStream(PGConnection connection, String sql, int bufferSize) throws SQLException { this(connection.getCopyAPI().copyIn(sql), bufferSize); } /** * Use given CopyIn operation for writing. * * @param op COPY FROM STDIN operation */ public PGCopyOutputStream(CopyIn op) { this(op, CopyManager.DEFAULT_BUFFER_SIZE); } /** * Use given CopyIn operation for writing. * * @param op COPY FROM STDIN operation * @param bufferSize try to send this many bytes at a time */ public PGCopyOutputStream(CopyIn op, int bufferSize) { this.op = op; copyBuffer = new byte[bufferSize]; } private CopyIn getOp() { return castNonNull(op); } @Override public void write(int b) throws IOException { checkClosed(); if (b < 0 || b > 255) { throw new IOException(GT.tr("Cannot write to copy a byte of value {0}", b)); } singleByteBuffer[0] = (byte) b; write(singleByteBuffer, 0, 1); } @Override public void write(byte[] buf) throws IOException { write(buf, 0, buf.length); } @Override public void write(byte[] buf, int off, int siz) throws IOException { checkClosed(); try { writeToCopy(buf, off, siz); } catch (SQLException se) { throw new IOException("Write to copy failed.", se); } } private void checkClosed() throws IOException { if (op == null) { throw new IOException(GT.tr("This copy stream is closed.")); } } @Override public void close() throws IOException { // Don't complain about a double close. CopyIn op = this.op; if (op == null) { return; } if (op.isActive()) { try { endCopy(); } catch (SQLException se) { throw new IOException("Ending write to copy failed.", se); } } this.op = null; } @Override public void flush() throws IOException { checkClosed(); try { getOp().writeToCopy(copyBuffer, 0, at); at = 0; getOp().flushCopy(); } catch (SQLException e) { throw new IOException("Unable to flush stream", e); } } @Override public void writeToCopy(byte[] buf, int off, int siz) throws SQLException { if (at > 0 && siz > copyBuffer.length - at) { // would not fit into rest of our buf, so flush buf getOp().writeToCopy(copyBuffer, 0, at); at = 0; } if (siz > copyBuffer.length) { // would still not fit into buf, so just pass it through getOp().writeToCopy(buf, off, siz); } else { // fits into our buf, so save it there System.arraycopy(buf, off, copyBuffer, at, siz); at += siz; } } @Override public void writeToCopy(ByteStreamWriter from) throws SQLException { if (at > 0) { // flush existing buffer so order is preserved getOp().writeToCopy(copyBuffer, 0, at); at = 0; } getOp().writeToCopy(from); } @Override public int getFormat() { return getOp().getFormat(); } @Override public int getFieldFormat(int field) { return getOp().getFieldFormat(field); } @Override public void cancelCopy() throws SQLException { getOp().cancelCopy(); } @Override public int getFieldCount() { return getOp().getFieldCount(); } @Override public boolean isActive() { return op != null && getOp().isActive(); } @Override public void flushCopy() throws SQLException { getOp().flushCopy(); } @Override public long endCopy() throws SQLException { if (at > 0) { getOp().writeToCopy(copyBuffer, 0, at); } getOp().endCopy(); return getHandledRowCount(); } @Override public long getHandledRowCount() { return getOp().getHandledRowCount(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/ 0040775 0000000 0000000 00000000000 00000250600 022572 5 ustar 00 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/AsciiStringInterner.java 0100664 0000000 0000000 00000026055 00000250600 027370 0 ustar 00 0000000 0000000 /* * Copyright (c) 2020, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; import static org.postgresql.util.internal.Nullness.castNonNull; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.lang.ref.SoftReference; import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; /** * Provides the canonicalization/interning of {@code String} instances which contain only ascii characters, * keyed by the {@code byte[]} representation (in ascii). * ** The values are stored in {@link SoftReference}s, allowing them to be garbage collected if not in use and there is * memory pressure. *
* ** NOTE: Instances are safe for concurrent use. *
* * @author Brett Okken */ final class AsciiStringInterner { private abstract static class BaseKey { private final int hash; BaseKey(int hash) { this.hash = hash; } @Override public final int hashCode() { return hash; } @Override public final boolean equals(/* @Nullable */ Object obj) { if (obj == this) { return true; } if (!(obj instanceof BaseKey)) { return false; } final BaseKey other = (BaseKey) obj; return equalsBytes(other); } abstract boolean equalsBytes(BaseKey other); abstract boolean equals(byte[] other, int offset, int length); abstract void appendString(StringBuilder sb); } /** * Only used for lookups, never to actually store entries. */ private static class TempKey extends BaseKey { final byte[] bytes; final int offset; final int length; TempKey(int hash, byte[] bytes, int offset, int length) { super(hash); this.bytes = bytes; this.offset = offset; this.length = length; } @Override boolean equalsBytes(BaseKey other) { return other.equals(bytes, offset, length); } @Override public boolean equals(byte[] other, int offset, int length) { return arrayEquals(this.bytes, this.offset, this.length, other, offset, length); } @Override void appendString(StringBuilder sb) { for (int i = offset, j = offset + length; i < j; i++) { sb.append((char) bytes[i]); } } } /** * Instance used for inserting values into the cache. The {@code byte[]} must be a copy * that will never be mutated. */ private static final class Key extends BaseKey { final byte[] key; Key(byte[] key, int hash) { super(hash); this.key = key; } /** * {@inheritDoc} */ @Override boolean equalsBytes(BaseKey other) { return other.equals(key, 0, key.length); } @Override public boolean equals(byte[] other, int offset, int length) { return arrayEquals(this.key, 0, this.key.length, other, offset, length); } /** * {@inheritDoc} */ @Override void appendString(StringBuilder sb) { for (int i = 0; i < key.length; i++) { sb.append((char) key[i]); } } } /** * Custom {@link SoftReference} implementation which maintains a reference to the key in the cache, * which allows aggressive cleaning when garbage collector collects the {@code String} instance. */ private final class StringReference extends SoftReference* If non-ascii bytes are discovered, the encoding will be used to * {@link Encoding#decode(byte[], int, int) decode} and that value will be returned (but not stored). *
* * @param bytes The bytes of the String. Must not be {@code null}. * @param offset Offset into bytes to start. * @param length The number of bytes in bytes which are relevant. * @param encoding To use if non-ascii bytes seen. * @return Decoded {@code String} from bytes. * @throws IOException If error decoding from Encoding. */ public String getString(byte[] bytes, int offset, int length, Encoding encoding) throws IOException { if (length == 0) { return ""; } final int hash = hashKey(bytes, offset, length); // 0 indicates the presence of a non-ascii character - defer to encoding to create the string if (hash == 0) { return encoding.decode(bytes, offset, length); } cleanQueue(); // create a TempKey with the byte[] given final TempKey tempKey = new TempKey(hash, bytes, offset, length); SoftReference* If all are valid ascii (i.e. {@code >= 0}) and a corresponding {@code String} value exists, it * will be returned. If no value exists, a {@code String} will be created, but not stored. *
* ** If non-ascii bytes are discovered, the encoding will be used to * {@link Encoding#decode(byte[], int, int) decode} and that value will be returned (but not stored). *
* * @param bytes The bytes of the String. Must not be {@code null}. * @param offset Offset into bytes to start. * @param length The number of bytes in bytes which are relevant. * @param encoding To use if non-ascii bytes seen. * @return Decoded {@code String} from bytes. * @throws IOException If error decoding from Encoding. */ public String getStringIfPresent(byte[] bytes, int offset, int length, Encoding encoding) throws IOException { if (length == 0) { return ""; } final int hash = hashKey(bytes, offset, length); // 0 indicates the presence of a non-ascii character - defer to encoding to create the string if (hash == 0) { return encoding.decode(bytes, offset, length); } cleanQueue(); // create a TempKey with the byte[] given final TempKey tempKey = new TempKey(hash, bytes, offset, length); SoftReference* The {@code static boolean equals(byte[].class, int, int, byte[], int, int} method in {@link java.util.Arrays} * is optimized for longer {@code byte[]} instances than is expected to be seen here. *
*/ static boolean arrayEquals(byte[] a, int aOffset, int aLength, byte[] b, int bOffset, int bLength) { if (aLength != bLength) { return false; } //TODO: in jdk9, could use VarHandle to read 4 bytes at a time as an int for comparison // or 8 bytes as a long - though we likely expect short values here for (int i = 0; i < aLength; i++) { if (a[aOffset + i] != b[bOffset + i]) { return false; } } return true; } /** * {@inheritDoc} */ @Override public String toString() { final StringBuilder sb = new StringBuilder(32 + (8 * cache.size())); sb.append("AsciiStringInterner ["); cache.forEach((k, v) -> { sb.append('\''); k.appendString(sb); sb.append("', "); }); //replace trailing ', ' with ']'; final int length = sb.length(); if (length > 21) { sb.setLength(sb.length() - 2); } sb.append(']'); return sb.toString(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/BaseConnection.java 0100664 0000000 0000000 00000020063 00000250600 026325 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; import org.postgresql.PGConnection; import org.postgresql.PGProperty; import org.postgresql.jdbc.FieldMetadata; import org.postgresql.jdbc.TimestampUtils; import org.postgresql.util.LruCache; import org.postgresql.xml.PGXmlFactoryFactory; // import org.checkerframework.checker.nullness.qual.Nullable; // import org.checkerframework.checker.nullness.qual.PolyNull; // import org.checkerframework.dataflow.qual.Pure; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.util.TimerTask; import java.util.logging.Logger; /** * Driver-internal connection interface. Application code should not use this interface. */ public interface BaseConnection extends PGConnection, Connection { /** * Cancel the current query executing on this connection. * * @throws SQLException if something goes wrong. */ @Override void cancelQuery() throws SQLException; /** * Execute a SQL query that returns a single resultset. Never causes a new transaction to be * started regardless of the autocommit setting. * * @param s the query to execute * @return the (non-null) returned resultset * @throws SQLException if something goes wrong. */ ResultSet execSQLQuery(String s) throws SQLException; ResultSet execSQLQuery(String s, int resultSetType, int resultSetConcurrency) throws SQLException; /** * Execute a SQL query that does not return results. Never causes a new transaction to be started * regardless of the autocommit setting. * * @param s the query to execute * @throws SQLException if something goes wrong. */ void execSQLUpdate(String s) throws SQLException; /** * Get the QueryExecutor implementation for this connection. * * @return the (non-null) executor */ QueryExecutor getQueryExecutor(); /** * Internal protocol for work with physical and logical replication. Physical replication available * only since PostgreSQL version 9.1. Logical replication available only since PostgreSQL version 9.4. * * @return not null replication protocol */ ReplicationProtocol getReplicationProtocol(); /** * Construct and return an appropriate object for the given type and value. This only considers * the types registered via {@link org.postgresql.PGConnection#addDataType(String, Class)} and * {@link org.postgresql.PGConnection#addDataType(String, String)}. * *If no class is registered as handling the given type, then a generic * {@link org.postgresql.util.PGobject} instance is returned.
* *value or byteValue must be non-null
* @param type the backend typename * @param value the type-specific string representation of the value * @param byteValue the type-specific binary representation of the value * @return an appropriate object; never null. * @throws SQLException if something goes wrong */ Object getObject(String type, /* @Nullable */ String value, byte /* @Nullable */ [] byteValue) throws SQLException; /* @Pure */ Encoding getEncoding() throws SQLException; TypeInfo getTypeInfo(); /** * Check if we have at least a particular server version. * *The input version is of the form xxyyzz, matching a PostgreSQL version like xx.yy.zz. So 9.0.12 * is 90012.
* * @param ver the server version to check, of the form xxyyzz eg 90401 * @return true if the server version is at least "ver". */ boolean haveMinimumServerVersion(int ver); /** * Check if we have at least a particular server version. * *The input version is of the form xxyyzz, matching a PostgreSQL version like xx.yy.zz. So 9.0.12 * is 90012.
* * @param ver the server version to check * @return true if the server version is at least "ver". */ boolean haveMinimumServerVersion(Version ver); /** * Encode a string using the database's client_encoding (usually UTF8, but can vary on older * server versions). This is used when constructing synthetic resultsets (for example, in metadata * methods). * * @param str the string to encode * @return an encoded representation of the string * @throws SQLException if something goes wrong. */ byte /* @PolyNull */ [] encodeString(/* @PolyNull */ String str) throws SQLException; /** * Escapes a string for use as string-literal within an SQL command. The method chooses the * applicable escaping rules based on the value of {@link #getStandardConformingStrings()}. * * @param str a string value * @return the escaped representation of the string * @throws SQLException if the string contains a {@code \0} character */ String escapeString(String str) throws SQLException; /** * Returns whether the server treats string-literals according to the SQL standard or if it uses * traditional PostgreSQL escaping rules. Versions up to 8.1 always treated backslashes as escape * characters in string-literals. Since 8.2, this depends on the value of the * {@code standard_conforming_strings} server variable. * * @return true if the server treats string literals according to the SQL standard * @see QueryExecutor#getStandardConformingStrings() */ boolean getStandardConformingStrings(); // Ew. Quick hack to give access to the connection-specific utils implementation. @Deprecated TimestampUtils getTimestampUtils(); // Get the per-connection logger. Logger getLogger(); // Get the bind-string-as-varchar config flag boolean getStringVarcharFlag(); /** * Get the current transaction state of this connection. * * @return current transaction state of this connection */ TransactionState getTransactionState(); /** * Returns true if value for the given oid should be sent using binary transfer. False if value * should be sent using text transfer. * * @param oid The oid to check. * @return True for binary transfer, false for text transfer. */ boolean binaryTransferSend(int oid); /** * Return whether to disable column name sanitation. * * @return true column sanitizer is disabled */ boolean isColumnSanitiserDisabled(); /** * Schedule a TimerTask for later execution. The task will be scheduled with the shared Timer for * this connection. * * @param timerTask timer task to schedule * @param milliSeconds delay in milliseconds */ void addTimerTask(TimerTask timerTask, long milliSeconds); /** * Invoke purge() on the underlying shared Timer so that internal resources will be released. */ void purgeTimerTasks(); /** * Return metadata cache for given connection. * * @return metadata cache */ LruCacheIf the "protocolVersion" property is specified, only that protocol version is tried. Otherwise, * all protocols are tried in order, falling back to older protocols as necessary.
* *Currently, protocol versions 3 (7.4+) is supported.
* * @param hostSpecs at least one host and port to connect to; multiple elements for round-robin * failover * @param info extra properties controlling the connection; notably, "password" if present * supplies the password to authenticate with. * @return the new, initialized, connection * @throws SQLException if the connection could not be established. */ public static QueryExecutor openConnection(HostSpec[] hostSpecs, Properties info) throws SQLException { String protoName = PGProperty.PROTOCOL_VERSION.getOrDefault(info); if (protoName != null && !protoName.isEmpty() && (protoName.equalsIgnoreCase("3") || protoName.equalsIgnoreCase("3.0") || protoName.equalsIgnoreCase("3.2"))) { ConnectionFactory connectionFactory = new ConnectionFactoryImpl(); QueryExecutor queryExecutor = connectionFactory.openConnectionImpl( hostSpecs, info); if (queryExecutor != null) { return queryExecutor; } } throw new PSQLException( GT.tr("A connection could not be made using the requested protocol {0}.", protoName), PSQLState.CONNECTION_UNABLE_TO_CONNECT); } /** * Implementation of {@link #openConnection} for a particular protocol version. Implemented by * subclasses of {@link ConnectionFactory}. * * @param hostSpecs at least one host and port to connect to; multiple elements for round-robin * failover * @param info extra properties controlling the connection; notably, "password" if present * supplies the password to authenticate with. * @return the new, initialized, connection, ornull if this protocol version is not
* supported by the server.
* @throws SQLException if the connection could not be established for a reason other than
* protocol version incompatibility.
*/
public abstract QueryExecutor openConnectionImpl(HostSpec[] hostSpecs, Properties info) throws SQLException;
/**
* Safely close the given stream.
*
* @param newStream The stream to close.
*/
protected void closeStream(/* @Nullable */ PGStream newStream) {
if (newStream != null) {
try {
newStream.close();
} catch (IOException e) {
LOGGER.log(Level.WARNING, "Failed to closed stream with error: {0}", e);
}
}
}
}
postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/Encoding.java 0100664 0000000 0000000 00000030307 00000250600 025163 0 ustar 00 0000000 0000000 /*
* Copyright (c) 2003, PostgreSQL Global Development Group
* See the LICENSE file in the project root for more information.
*/
package org.postgresql.core;
// import org.checkerframework.checker.nullness.qual.PolyNull;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Representation of a particular character encoding.
*/
public class Encoding {
private static final Logger LOGGER = Logger.getLogger(Encoding.class.getName());
private static final Encoding DEFAULT_ENCODING = new Encoding();
private static final Encoding UTF8_ENCODING = new Encoding(StandardCharsets.UTF_8, true);
/*
* Preferred JVM encodings for backend encodings.
*/
private static final HashMap* This is intended for use with {@code String} constants. *
* * @param string The string to maintain canonicalized reference to. Must not be {@code null}. * @see Encoding#decodeCanonicalized(byte[], int, int) */ public static void canonicalize(String string) { INTERNER.putString(string); } /** * Get the name of the (JVM) encoding used. * * @return the JVM encoding name used by this instance. */ public String name() { return encoding.name(); } /** * Encode a string to an array of bytes. * * @param s the string to encode * @return a bytearray containing the encoded string * @throws IOException if something goes wrong */ public byte /* @PolyNull */ [] encode(/* @PolyNull */ String s) throws IOException { if (s == null) { return null; } return s.getBytes(encoding); } /** * Decode an array of bytes possibly into a canonicalized string. * ** Only ascii compatible encoding support canonicalization and only ascii {@code String} values are eligible * to be canonicalized. *
* * @param encodedString a byte array containing the string to decode * @param offset the offset inencodedString of the first byte of the encoded
* representation
* @param length the length, in bytes, of the encoded representation
* @return the decoded string
* @throws IOException if something goes wrong
*/
public String decodeCanonicalized(byte[] encodedString, int offset, int length) throws IOException {
if (length == 0) {
return "";
}
// if fastASCIINumbers is false, then no chance of the byte[] being ascii compatible characters
return fastASCIINumbers ? INTERNER.getString(encodedString, offset, length, this)
: decode(encodedString, offset, length);
}
public String decodeCanonicalizedIfPresent(byte[] encodedString, int offset, int length) throws IOException {
if (length == 0) {
return "";
}
// if fastASCIINumbers is false, then no chance of the byte[] being ascii compatible characters
return fastASCIINumbers ? INTERNER.getStringIfPresent(encodedString, offset, length, this)
: decode(encodedString, offset, length);
}
/**
* Decode an array of bytes possibly into a canonicalized string.
*
* * Only ascii compatible encoding support canonicalization and only ascii {@code String} values are eligible * to be canonicalized. *
* * @param encodedString a byte array containing the string to decode * @return the decoded string * @throws IOException if something goes wrong */ public String decodeCanonicalized(byte[] encodedString) throws IOException { return decodeCanonicalized(encodedString, 0, encodedString.length); } /** * Decode an array of bytes into a string. * * @param encodedString a byte array containing the string to decode * @param offset the offset inencodedString of the first byte of the encoded
* representation
* @param length the length, in bytes, of the encoded representation
* @return the decoded string
* @throws IOException if something goes wrong
*/
public String decode(byte[] encodedString, int offset, int length) throws IOException {
return new String(encodedString, offset, length, encoding);
}
/**
* Decode an array of bytes into a string.
*
* @param encodedString a byte array containing the string to decode
* @return the decoded string
* @throws IOException if something goes wrong
*/
public String decode(byte[] encodedString) throws IOException {
return decode(encodedString, 0, encodedString.length);
}
/**
* Get a Reader that decodes the given InputStream using this encoding.
*
* @param in the underlying stream to decode from
* @return a non-null Reader implementation.
* @throws IOException if something goes wrong
*/
public Reader getDecodingReader(InputStream in) throws IOException {
return new InputStreamReader(in, encoding);
}
/**
* Get a Writer that encodes to the given OutputStream using this encoding.
*
* @param out the underlying stream to encode to
* @return a non-null Writer implementation.
* @throws IOException if something goes wrong
*/
public Writer getEncodingWriter(OutputStream out) throws IOException {
return new OutputStreamWriter(out, encoding);
}
/**
* Get an Encoding using the default encoding for the JVM.
*
* @return an Encoding instance
*/
public static Encoding defaultEncoding() {
return DEFAULT_ENCODING;
}
@Override
public String toString() {
return encoding.name();
}
/**
* Checks whether this encoding is compatible with ASCII for the number characters '-' and
* '0'..'9'. Where compatible means that they are encoded with exactly same values.
*
* @return If faster ASCII number parsing can be used with this encoding.
*/
private static boolean testAsciiNumbers(Charset encoding) {
// TODO: test all postgres supported encoding to see if there are
// any which do _not_ have ascii numbers in same location
// at least all the encoding listed in the encodings hashmap have
// working ascii numbers
String test = "-0123456789";
byte[] bytes = test.getBytes(encoding);
String res = new String(bytes, StandardCharsets.US_ASCII);
return test.equals(res);
}
}
postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/EncodingPredictor.java 0100664 0000000 0000000 00000011603 00000250600 027035 0 ustar 00 0000000 0000000 /*
* Copyright (c) 2003, PostgreSQL Global Development Group
* See the LICENSE file in the project root for more information.
*/
package org.postgresql.core;
// import org.checkerframework.checker.nullness.qual.Nullable;
import java.io.IOException;
/**
* Predicts encoding for error messages based on some heuristics.
*
* In general, instances of PGStream are not threadsafe; the caller must ensure that only one thread * at a time is accessing a particular PGStream instance.
*/ public class PGStream implements Closeable, Flushable { private final SocketFactory socketFactory; private final HostSpec hostSpec; private final int maxSendBufferSize; private Socket connection; private VisibleBufferedInputStream pgInput; private PgBufferedOutputStream pgOutput; private /* @Nullable */ ProtocolVersion protocolVersion; public boolean isGssEncrypted() { return gssEncrypted; } boolean gssEncrypted; public void setSecContext(GSSContext secContext) throws GSSException { MessageProp messageProp = new MessageProp(0, true); pgInput = new VisibleBufferedInputStream(new GSSInputStream(pgInput, secContext, messageProp ), 8192); // See https://www.postgresql.org/docs/current/protocol-flow.html#PROTOCOL-FLOW-GSSAPI // Note that the server will only accept encrypted packets from the client which are less than // 16kB; gss_wrap_size_limit() should be used by the client to determine the size of // the unencrypted message which will fit within this limit and larger messages should be // broken up into multiple gss_wrap() calls // See https://github.com/postgres/postgres/blob/acecd6746cdc2df5ba8dcc2c2307c6560c7c2492/src/backend/libpq/be-secure-gssapi.c#L348 // Backend includes "int4 messageSize" into 16384 limit, so we subtract 4. pgOutput = new GSSOutputStream(pgOutput, secContext, messageProp, 16384 - 4); gssEncrypted = true; } private long nextStreamAvailableCheckTime; // This is a workaround for SSL sockets: sslInputStream.available() might return 0 // so we perform "1ms reads" once in a while private int minStreamAvailableCheckDelay = 1000; private Encoding encoding; private Writer encodingWriter; private long maxResultBuffer = -1; private long resultBufferByteCount; private int maxRowSizeBytes = -1; /** * Constructor: Connect to the PostgreSQL back end and return a stream connection. * * @param socketFactory socket factory to use when creating sockets * @param hostSpec the host and port to connect to * @param timeout timeout in milliseconds, or 0 if no timeout set * @throws IOException if an IOException occurs below it. * @deprecated use {@link #PGStream(SocketFactory, org.postgresql.util.HostSpec, int, int)} */ @Deprecated @SuppressWarnings({"method.invocation", "initialization.fields.uninitialized"}) public PGStream(SocketFactory socketFactory, HostSpec hostSpec, int timeout) throws IOException { this(socketFactory, hostSpec, timeout, 8192); } /** * Constructor: Connect to the PostgreSQL back end and return a stream connection. * * @param socketFactory socket factory to use when creating sockets * @param hostSpec the host and port to connect to * @param timeout timeout in milliseconds, or 0 if no timeout set * @param maxSendBufferSize maximum amount of bytes buffered before sending to the backend * @throws IOException if an IOException occurs below it. */ @SuppressWarnings({"method.invocation", "initialization.fields.uninitialized"}) public PGStream(SocketFactory socketFactory, HostSpec hostSpec, int timeout, int maxSendBufferSize) throws IOException { this.socketFactory = socketFactory; this.hostSpec = hostSpec; this.maxSendBufferSize = maxSendBufferSize; Socket socket = createSocket(timeout); changeSocket(socket); setEncoding(Encoding.getJVMEncoding("UTF-8")); } @SuppressWarnings({"method.invocation", "initialization.fields.uninitialized"}) public PGStream(PGStream pgStream, int timeout) throws IOException { /* Some defaults */ int sendBufferSize = 1024; int receiveBufferSize = 1024; int soTimeout = 0; boolean keepAlive = false; boolean tcpNoDelay = true; /* Get the existing values before closing the stream */ try { sendBufferSize = pgStream.getSocket().getSendBufferSize(); receiveBufferSize = pgStream.getSocket().getReceiveBufferSize(); soTimeout = pgStream.getSocket().getSoTimeout(); keepAlive = pgStream.getSocket().getKeepAlive(); tcpNoDelay = pgStream.getSocket().getTcpNoDelay(); } catch ( SocketException ex ) { // ignore it } //close the existing stream pgStream.close(); this.socketFactory = pgStream.socketFactory; this.hostSpec = pgStream.hostSpec; this.maxSendBufferSize = pgStream.maxSendBufferSize; Socket socket = createSocket(timeout); changeSocket(socket); setEncoding(Encoding.getJVMEncoding("UTF-8")); // set the buffer sizes and timeout socket.setReceiveBufferSize(receiveBufferSize); socket.setSendBufferSize(sendBufferSize); setNetworkTimeout(soTimeout); socket.setKeepAlive(keepAlive); socket.setTcpNoDelay(tcpNoDelay); } /** * Constructor: Connect to the PostgreSQL back end and return a stream connection. * * @param socketFactory socket factory * @param hostSpec the host and port to connect to * @throws IOException if an IOException occurs below it. * @deprecated use {@link #PGStream(SocketFactory, org.postgresql.util.HostSpec, int, int)} */ @Deprecated public PGStream(SocketFactory socketFactory, HostSpec hostSpec) throws IOException { this(socketFactory, hostSpec, 0); } public HostSpec getHostSpec() { return hostSpec; } public Socket getSocket() { return connection; } public SocketFactory getSocketFactory() { return socketFactory; } /** * Check for pending backend messages without blocking. Might return false when there actually are * messages waiting, depending on the characteristics of the underlying socket. This is used to * detect asynchronous notifies from the backend, when available. * * @return true if there is a pending backend message * @throws IOException if something wrong happens */ public boolean hasMessagePending() throws IOException { boolean available = false; // In certain cases, available returns 0, yet there are bytes if (pgInput.available() > 0) { return true; } long now = System.nanoTime() / 1000000; if (now < nextStreamAvailableCheckTime && minStreamAvailableCheckDelay != 0) { // Do not use ".peek" too often return false; } int soTimeout = getNetworkTimeout(); connection.setSoTimeout(1); try { if (!pgInput.ensureBytes(1, false)) { return false; } available = pgInput.peek() != -1; } catch (SocketTimeoutException e) { return false; } finally { connection.setSoTimeout(soTimeout); } /* If none available then set the next check time In the event that there more async bytes available we will continue to get them all see issue 1547 https://github.com/pgjdbc/pgjdbc/issues/1547 */ if (!available) { nextStreamAvailableCheckTime = now + minStreamAvailableCheckDelay; } return available; } public void setMinStreamAvailableCheckDelay(int delay) { this.minStreamAvailableCheckDelay = delay; } private Socket createSocket(int timeout) throws IOException { Socket socket = null; try { socket = socketFactory.createSocket(); String localSocketAddress = hostSpec.getLocalSocketAddress(); if (localSocketAddress != null) { socket.bind(new InetSocketAddress(InetAddress.getByName(localSocketAddress), 0)); } if (!socket.isConnected()) { // When using a SOCKS proxy, the host might not be resolvable locally, // thus we defer resolution until the traffic reaches the proxy. If there // is no proxy, we must resolve the host to an IP to connect the socket. InetSocketAddress address = hostSpec.shouldResolve() ? new InetSocketAddress(hostSpec.getHost(), hostSpec.getPort()) : InetSocketAddress.createUnresolved(hostSpec.getHost(), hostSpec.getPort()); socket.connect(address, timeout); } return socket; } catch ( Exception ex ) { if (socket != null) { try { socket.close(); } catch ( Exception ex1 ) { ex.addSuppressed(ex1); } } throw ex; } } /** * Switch this stream to using a new socket. Any existing socket is not closed; it's * assumed that we are changing to a new socket that delegates to the original socket (e.g. SSL). * * @param socket the new socket to change to * @throws IOException if something goes wrong */ public void changeSocket(Socket socket) throws IOException { assert connection != socket : "changeSocket is called with the current socket as argument." + " This is a no-op, however, it re-allocates buffered streams, so refrain from" + " excessive changeSocket calls"; this.connection = socket; // Submitted by Jason VennerThe returned Writer should not be closed, as it's a shared object. Writer.flush needs to be * called when switching between use of the Writer and use of the PGStream write methods, but it * won't actually flush output all the way out -- call {@link #flush} to actually ensure all * output has been pushed to the server.
* * @return the shared Writer instance * @throws IOException if something goes wrong. */ public Writer getEncodingWriter() throws IOException { if (encodingWriter == null) { throw new IOException("No encoding has been set on this connection"); } return encodingWriter; } /** * Sends a single character to the back end. * * @param val the character to be sent * @throws IOException if an I/O error occurs */ public void sendChar(int val) throws IOException { pgOutput.write(val); } /** * Sends a 4-byte integer to the back end. * * @param val the integer to be sent * @throws IOException if an I/O error occurs */ public void sendInteger4(int val) throws IOException { pgOutput.writeInt4(val); } /** * Sends a 2-byte integer (short) to the back end. * * @param val the integer to be sent * @throws IOException if an I/O error occurs or {@code val} cannot be encoded in 2 bytes */ public void sendInteger2(int val) throws IOException { if (val < 0 || val > 65535) { throw new IllegalArgumentException("Tried to send an out-of-range integer as a 2-byte unsigned int value: " + val); } pgOutput.writeInt2(val); } /** * Send an array of bytes to the backend. * * @param buf The array of bytes to be sent * @throws IOException if an I/O error occurs */ public void send(byte[] buf) throws IOException { pgOutput.write(buf); } /** * Send a fixed-size array of bytes to the backend. If {@code buf.length < siz}, pad with zeros. * If {@code buf.length > siz}, truncate the array. * * @param buf the array of bytes to be sent * @param siz the number of bytes to be sent * @throws IOException if an I/O error occurs */ public void send(byte[] buf, int siz) throws IOException { send(buf, 0, siz); } /** * Send a fixed-size array of bytes to the backend. If {@code length < siz}, pad with zeros. If * {@code length > siz}, truncate the array. * * @param buf the array of bytes to be sent * @param off offset in the array to start sending from * @param siz the number of bytes to be sent * @throws IOException if an I/O error occurs */ public void send(byte[] buf, int off, int siz) throws IOException { int bufamt = buf.length - off; pgOutput.write(buf, off, Math.min(bufamt, siz)); if (siz > bufamt) { pgOutput.writeZeros(siz - bufamt); } } /** * Send a fixed-size array of bytes to the backend. If {@code length < siz}, pad with zeros. If * {@code length > siz}, truncate the array. * * @param writer the stream writer to invoke to send the bytes * @throws IOException if an I/O error occurs */ public void send(ByteStreamWriter writer) throws IOException { final FixedLengthOutputStream fixedLengthStream = new FixedLengthOutputStream(writer.getLength(), pgOutput); try { writer.writeTo(new ByteStreamWriter.ByteStreamTarget() { @Override public OutputStream getOutputStream() { return fixedLengthStream; } }); } catch (IOException ioe) { throw ioe; } catch (Exception re) { throw new IOException("Error writing bytes to stream", re); } pgOutput.writeZeros(fixedLengthStream.remaining()); } /** * Receives a single character from the backend, without advancing the current protocol stream * position. * * @return the character received * @throws IOException if an I/O Error occurs */ public int peekChar() throws IOException { int c = pgInput.peek(); if (c < 0) { throw new EOFException(); } return c; } /** * Receives a single character from the backend. * * @return the character received * @throws IOException if an I/O Error occurs */ public int receiveChar() throws IOException { int c = pgInput.read(); if (c < 0) { throw new EOFException(); } return c; } /** * Receives a four byte integer from the backend. * * @return the integer received from the backend * @throws IOException if an I/O error occurs */ public int receiveInteger4() throws IOException { return pgInput.readInt4(); } /** * Receives a two byte integer from the backend as an unsigned integer (0..65535). * * @return the integer received from the backend * @throws IOException if an I/O error occurs */ public int receiveInteger2() throws IOException { return pgInput.readInt2(); } /** * Receives a fixed-size string from the backend. * * @param len the length of the string to receive, in bytes. * @return the decoded string * @throws IOException if something wrong happens */ public String receiveString(int len) throws IOException { if (!pgInput.ensureBytes(len)) { throw new EOFException(); } String res = encoding.decode(pgInput.getBuffer(), pgInput.getIndex(), len); pgInput.skip(len); return res; } /** * Receives a fixed-size string from the backend, and tries to avoid "UTF-8 decode failed" * errors. * * @param len the length of the string to receive, in bytes. * @return the decoded string * @throws IOException if something wrong happens */ public EncodingPredictor.DecodeResult receiveErrorString(int len) throws IOException { if (!pgInput.ensureBytes(len)) { throw new EOFException(); } EncodingPredictor.DecodeResult res; try { String value = encoding.decode(pgInput.getBuffer(), pgInput.getIndex(), len); // no autodetect warning as the message was converted on its own res = new EncodingPredictor.DecodeResult(value, null); } catch (IOException e) { res = EncodingPredictor.decode(pgInput.getBuffer(), pgInput.getIndex(), len); if (res == null) { Encoding enc = Encoding.defaultEncoding(); String value = enc.decode(pgInput.getBuffer(), pgInput.getIndex(), len); res = new EncodingPredictor.DecodeResult(value, enc.name()); } } pgInput.skip(len); return res; } /** * Receives a null-terminated string from the backend. If we don't see a null, then we assume * something has gone wrong. * * @return string from back end * @throws IOException if an I/O error occurs, or end of file */ public String receiveString() throws IOException { int len = pgInput.scanCStringLength(); String res = encoding.decode(pgInput.getBuffer(), pgInput.getIndex(), len - 1); pgInput.skip(len); return res; } /** * Receives a null-terminated string from the backend and attempts to decode to a * {@link Encoding#decodeCanonicalized(byte[], int, int) canonical} {@code String}. * If we don't see a null, then we assume something has gone wrong. * * @return string from back end * @throws IOException if an I/O error occurs, or end of file * @see Encoding#decodeCanonicalized(byte[], int, int) */ public String receiveCanonicalString() throws IOException { int len = pgInput.scanCStringLength(); String res = encoding.decodeCanonicalized(pgInput.getBuffer(), pgInput.getIndex(), len - 1); pgInput.skip(len); return res; } /** * Receives a null-terminated string from the backend and attempts to decode to a * {@link Encoding#decodeCanonicalizedIfPresent(byte[], int, int) canonical} {@code String}. * If we don't see a null, then we assume something has gone wrong. * * @return string from back end * @throws IOException if an I/O error occurs, or end of file * @see Encoding#decodeCanonicalizedIfPresent(byte[], int, int) */ public String receiveCanonicalStringIfPresent() throws IOException { int len = pgInput.scanCStringLength(); String res = encoding.decodeCanonicalizedIfPresent(pgInput.getBuffer(), pgInput.getIndex(), len - 1); pgInput.skip(len); return res; } /** * Read a tuple from the back end. A tuple is a two dimensional array of bytes. This variant reads * the V3 protocol's tuple representation. * * @return tuple from the back end * @throws IOException if a data I/O error occurs * @throws SQLException if read more bytes than set maxResultBuffer */ public Tuple receiveTupleV3() throws IOException, OutOfMemoryError, SQLException { int messageSize = receiveInteger4(); // MESSAGE SIZE int nf = receiveInteger2(); //size = messageSize - 4 bytes of message size - 2 bytes of field count - 4 bytes for each column length int dataToReadSize = messageSize - 4 - 2 - 4 * nf; setMaxRowSizeBytes(dataToReadSize); byte[][] answer = new byte[nf][]; increaseByteCounter(dataToReadSize); OutOfMemoryError oom = null; for (int i = 0; i < nf; i++) { int size = receiveInteger4(); if (size != -1) { try { answer[i] = new byte[size]; receive(answer[i], 0, size); } catch (OutOfMemoryError oome) { oom = oome; skip(size); } } } if (oom != null) { throw oom; } return new Tuple(answer); } /** * Reads in a given number of bytes from the backend. * * @param siz number of bytes to read * @return array of bytes received * @throws IOException if a data I/O error occurs */ public byte[] receive(int siz) throws IOException { byte[] answer = new byte[siz]; receive(answer, 0, siz); return answer; } /** * Reads in a given number of bytes from the backend. * * @param buf buffer to store result * @param off offset in buffer * @param siz number of bytes to read * @throws IOException if a data I/O error occurs */ public void receive(byte[] buf, int off, int siz) throws IOException { int s = 0; while (s < siz) { int w = pgInput.read(buf, off + s, siz - s); if (w < 0) { throw new EOFException(); } s += w; } } public void skip(int size) throws IOException { long s = 0; while (s < size) { s += pgInput.skip(size - s); } } /** * Copy data from an input stream to the connection. * * @param inStream the stream to read data from * @param remaining the number of bytes to copy * @throws IOException if error occurs when writing the data to the output stream * @throws SourceStreamIOException if error occurs when reading the data from the input stream */ public void sendStream(InputStream inStream, int remaining) throws IOException { pgOutput.write(inStream, remaining); } /** * Writes the given amount of zero bytes to the output stream * @param length the number of zeros to write * @throws IOException in case writing to the output stream fails * @throws SourceStreamIOException in case reading from the source stream fails */ public void sendZeros(int length) throws IOException { pgOutput.writeZeros(length); } /** * Flush any pending output to the backend. * * @throws IOException if an I/O error occurs */ @Override public void flush() throws IOException { if (encodingWriter != null) { encodingWriter.flush(); } pgOutput.flush(); } /** * Consume an expected EOF from the backend. * * @throws IOException if an I/O error occurs * @throws SQLException if we get something other than an EOF */ public void receiveEOF() throws SQLException, IOException { int c = pgInput.read(); if (c < 0) { return; } throw new PSQLException(GT.tr("Expected an EOF from server, got: {0}", c), PSQLState.COMMUNICATION_ERROR); } /** * Closes the connection. * * @throws IOException if an I/O Error occurs */ @Override public void close() throws IOException { if (encodingWriter != null) { encodingWriter.close(); } pgOutput.close(); pgInput.close(); connection.close(); } public void setNetworkTimeout(int milliseconds) throws IOException { connection.setSoTimeout(milliseconds); pgInput.setTimeoutRequested(milliseconds != 0); } public int getNetworkTimeout() throws IOException { return connection.getSoTimeout(); } /** * Method to set MaxResultBuffer inside PGStream. * * @param value value of new max result buffer as string (cause we can expect % or chars to use * multiplier) * @throws PSQLException exception returned when occurred parsing problem. */ public void setMaxResultBuffer(/* @Nullable */ String value) throws PSQLException { maxResultBuffer = PGPropertyMaxResultBufferParser.parseProperty(value); } /** * Get MaxResultBuffer from PGStream. * * @return size of MaxResultBuffer */ public long getMaxResultBuffer() { return maxResultBuffer; } /** * The idea behind this method is to keep in maxRowSize the size of biggest read data row. As * there may be many data rows send after each other for a query, then value in maxRowSize would * contain value noticed so far, because next data rows and their sizes are not read for that * moment. We want it increasing, because the size of the biggest among data rows will be used * during computing new adaptive fetch size for the query. * * @param rowSizeBytes new value to be set as maxRowSizeBytes */ public void setMaxRowSizeBytes(int rowSizeBytes) { if (rowSizeBytes > maxRowSizeBytes) { maxRowSizeBytes = rowSizeBytes; } } /** * Get actual max row size noticed so far. * * @return value of max row size */ public int getMaxRowSizeBytes() { return maxRowSizeBytes; } /** * Clear value of max row size noticed so far. */ public void clearMaxRowSizeBytes() { maxRowSizeBytes = -1; } /** * Clear count of byte buffer. */ public void clearResultBufferCount() { resultBufferByteCount = 0; } public /* @Nullable */ ProtocolVersion getProtocolVersion() { return protocolVersion; } public void setProtocolVersion(ProtocolVersion protocolVersion) { this.protocolVersion = protocolVersion; } /** * Increase actual count of buffer. If buffer count is bigger than max result buffer limit, then * gonna return an exception. * * @param value size of bytes to add to byte buffer. * @throws SQLException exception returned when result buffer count is bigger than max result * buffer. */ private void increaseByteCounter(long value) throws SQLException { if (maxResultBuffer != -1) { resultBufferByteCount += value; if (resultBufferByteCount > maxResultBuffer) { throw new PSQLException(GT.tr( "Result set exceeded maxResultBuffer limit. Received: {0}; Current limit: {1}", String.valueOf(resultBufferByteCount), String.valueOf(maxResultBuffer)), PSQLState.COMMUNICATION_ERROR); } } } public boolean isClosed() { return connection.isClosed(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/ParameterList.java 0100664 0000000 0000000 00000022226 00000250600 026212 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core; import org.postgresql.core.v3.SqlSerializationContext; import org.postgresql.util.ByteStreamWriter; // import org.checkerframework.checker.index.qual.NonNegative; // import org.checkerframework.checker.index.qual.Positive; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.InputStream; import java.sql.SQLException; /** * Abstraction of a list of parameters to be substituted into a Query. The protocol-specific details * of how to efficiently store and stream the parameters is hidden behind implementations of this * interface. * *In general, instances of ParameterList are associated with a particular Query object (the one * that created them) and shouldn't be used against another Query.
* *Parameter indexes are 1-based to match JDBC's PreparedStatement, i.e. the first parameter has * index 1.
* * @author Oliver Jowett (oliver@opencloud.com) */ public interface ParameterList { void registerOutParameter(/* @Positive */ int index, int sqlType) throws SQLException; /** * Get the number of parameters in this list. This value never changes for a particular instance, * and might be zero. * * @return the number of parameters in this list. */ /* @NonNegative */ int getParameterCount(); /** * Get the number of IN parameters in this list. * * @return the number of IN parameters in this list */ /* @NonNegative */ int getInParameterCount(); /** * Get the number of OUT parameters in this list. * * @return the number of OUT parameters in this list */ /* @NonNegative */ int getOutParameterCount(); /** * Return the oids of the parameters in this list. May be null for a ParameterList that does not * support typing of parameters. * * @return oids of the parameters */ int[] getTypeOIDs(); /** * Binds an integer value to a parameter. The type of the parameter is implicitly 'int4'. * * @param index the 1-based parameter index to bind. * @param value the integer value to use. * @throws SQLException on error or ifindex is out of range
*/
void setIntParameter(/* @Positive */ int index, int value) throws SQLException;
/**
* Binds a String value that is an unquoted literal to the server's query parser (for example, a
* bare integer) to a parameter. Associated with the parameter is a typename for the parameter
* that should correspond to an entry in pg_types.
*
* @param index the 1-based parameter index to bind.
* @param value the unquoted literal string to use.
* @param oid the type OID of the parameter, or 0 to infer the type.
* @throws SQLException on error or if index is out of range
*/
void setLiteralParameter(/* @Positive */ int index,
String value, int oid) throws SQLException;
/**
* Binds a String value that needs to be quoted for the server's parser to understand (for
* example, a timestamp) to a parameter. Associated with the parameter is a typename for the
* parameter that should correspond to an entry in pg_types.
*
* @param index the 1-based parameter index to bind.
* @param value the quoted string to use.
* @param oid the type OID of the parameter, or 0 to infer the type.
* @throws SQLException on error or if index is out of range
*/
void setStringParameter(/* @Positive */ int index, String value, int oid) throws SQLException;
/**
* Binds a binary bytea value stored as a bytearray to a parameter. The parameter's type is
* implicitly set to 'bytea'. The bytearray's contains should remain unchanged until query
* execution has completed.
*
* @param index the 1-based parameter index to bind.
* @param data an array containing the raw data value
* @param offset the offset within data of the start of the parameter data.
* @param length the number of bytes of parameter data within data to use.
* @throws SQLException on error or if index is out of range
*/
void setBytea(/* @Positive */ int index, byte[] data,
/* @NonNegative */ int offset, /* @NonNegative */ int length) throws SQLException;
/**
* Binds a binary bytea value stored as an InputStream. The parameter's type is implicitly set to
* 'bytea'. The stream should remain valid until query execution has completed.
*
* @param index the 1-based parameter index to bind.
* @param stream a stream containing the parameter data.
* @param length the number of bytes of parameter data to read from stream.
* @throws SQLException on error or if index is out of range
*/
void setBytea(/* @Positive */ int index, InputStream stream, /* @NonNegative */ int length) throws SQLException;
/**
* Binds a binary bytea value stored as an InputStream. The parameter's type is implicitly set to
* 'bytea'. The stream should remain valid until query execution has completed.
*
* @param index the 1-based parameter index to bind.
* @param stream a stream containing the parameter data.
* @throws SQLException on error or if index is out of range
*/
void setBytea(/* @Positive */ int index, InputStream stream) throws SQLException;
/**
* Binds a binary bytea value stored as a ByteStreamWriter. The parameter's type is implicitly set to
* 'bytea'. The stream should remain valid until query execution has completed.
*
* @param index the 1-based parameter index to bind.
* @param writer a writer that can write the bytes for the parameter
* @throws SQLException on error or if index is out of range
*/
void setBytea(/* @Positive */ int index, ByteStreamWriter writer) throws SQLException;
/**
* Binds a text value stored as an InputStream that is a valid UTF-8 byte stream.
* Any byte-order marks (BOM) in the stream are passed to the backend.
* The parameter's type is implicitly set to 'text'.
* The stream should remain valid until query execution has completed.
*
* @param index the 1-based parameter index to bind.
* @param stream a stream containing the parameter data.
* @throws SQLException on error or if index is out of range
*/
void setText(/* @Positive */ int index, InputStream stream) throws SQLException;
/**
* Binds given byte[] value to a parameter. The bytes must already be in correct format matching
* the OID.
*
* @param index the 1-based parameter index to bind.
* @param value the bytes to send.
* @param oid the type OID of the parameter.
* @throws SQLException on error or if index is out of range
*/
void setBinaryParameter(/* @Positive */ int index, byte[] value, int oid) throws SQLException;
/**
* Binds a SQL NULL value to a parameter. Associated with the parameter is a typename for the
* parameter that should correspond to an entry in pg_types.
*
* @param index the 1-based parameter index to bind.
* @param oid the type OID of the parameter, or 0 to infer the type.
* @throws SQLException on error or if index is out of range
*/
void setNull(/* @Positive */ int index, int oid) throws SQLException;
/**
* Perform a shallow copy of this ParameterList, returning a new instance (still suitable for
* passing to the owning Query). If this ParameterList is immutable, copy() may return the same
* immutable object.
*
* @return a new ParameterList instance
*/
ParameterList copy();
/**
* Unbind all parameter values bound in this list.
*/
void clear();
/**
* Return a human-readable representation of a particular parameter in this ParameterList. If the
* parameter is not bound or is of type bytea sourced from an InputStream, returns "?".
* This method will NOT consume InputStreams, instead "?" will be returned.
*
* @param index the 1-based parameter index to bind.
* @param standardConformingStrings true if \ is not an escape character in strings literals
* @return a string representation of the parameter.
*/
String toString(/* @Positive */ int index, boolean standardConformingStrings);
/**
* Return the string literal representation of a particular parameter in this ParameterList. If the
* parameter is not bound, returns "?".
* This method will consume all InputStreams to produce the result.
*
* @param index the 1-based parameter index to bind.
* @param context specifies configuration for converting the parameters to string
* @return a string representation of the parameter.
*/
String toString(/* @Positive */ int index, SqlSerializationContext context);
/**
* Use this operation to append more parameters to the current list.
* @param list of parameters to append with.
* @throws SQLException fault raised if driver or back end throw an exception
*/
void appendAll(ParameterList list) throws SQLException ;
/**
* Returns the bound parameter values.
* @return Object array containing the parameter values.
*/
/* @Nullable */ Object /* @Nullable */ [] getValues();
}
postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/Parser.java 0100664 0000000 0000000 00000156114 00000250600 024676 0 ustar 00 0000000 0000000 /*
* Copyright (c) 2006, PostgreSQL Global Development Group
* See the LICENSE file in the project root for more information.
*/
package org.postgresql.core;
import org.postgresql.jdbc.EscapeSyntaxCallMode;
import org.postgresql.jdbc.EscapedFunctions2;
import org.postgresql.util.GT;
import org.postgresql.util.IntList;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
// import org.checkerframework.checker.nullness.qual.Nullable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Basic query parser infrastructure.
* Note: This class should not be considered as pgjdbc public API.
*
* @author Michael Paesold (mpaesold@gmx.at)
* @author Christopher Deckers (chrriis@gmail.com)
*/
public class Parser {
/**
* Parses JDBC query into PostgreSQL's native format. Several queries might be given if separated
* by semicolon.
*
* @param query jdbc query to parse
* @param standardConformingStrings whether to allow backslashes to be used as escape characters
* in single quote literals
* @param withParameters whether to replace ?, ? with $1, $2, etc
* @param splitStatements whether to split statements by semicolon
* @param isBatchedReWriteConfigured whether re-write optimization is enabled
* @param quoteReturningIdentifiers whether to quote identifiers returned using returning clause
* @param returningColumnNames for simple insert, update, delete add returning with given column names
* @return list of native queries
* @throws SQLException if unable to add returning clause (invalid column names)
*/
public static ListNote: for {@code 'single '' quote in string'}, this method currently returns the offset of * first {@code '} character after the initial one. The caller must call the method a second time * for the second part of the quoted string.
* * @param query query * @param offset start offset * @param standardConformingStrings standard conforming strings * @return position of the end of the single-quoted string */ public static int parseSingleQuotes(final char[] query, int offset, boolean standardConformingStrings) { // check for escape string syntax (E'') if (standardConformingStrings && offset >= 2 && (query[offset - 1] == 'e' || query[offset - 1] == 'E') && charTerminatesIdentifier(query[offset - 2])) { standardConformingStrings = false; } if (standardConformingStrings) { // do NOT treat backslashes as escape characters while (++offset < query.length) { if (query[offset] == '\'') { return offset; } } } else { // treat backslashes as escape characters while (++offset < query.length) { switch (query[offset]) { case '\\': ++offset; break; case '\'': return offset; default: break; } } } return query.length; } /** * Find the end of the double-quoted string starting at the given offset. * *Note: for {@code "double "" quote in string"}, this method currently * returns the offset of first {@code "} character after the initial one. The caller must * call the method a second time for the second part of the quoted string.
* * @param query query * @param offset start offset * @return position of the end of the double-quoted string */ public static int parseDoubleQuotes(final char[] query, int offset) { while (++offset < query.length && query[offset] != '"') { // do nothing } return offset; } /** * Test if the dollar character ({@code $}) at the given offset starts a dollar-quoted string and * return the offset of the ending dollar character. * * @param query query * @param offset start offset * @return offset of the ending dollar character */ public static int parseDollarQuotes(final char[] query, int offset) { if (offset + 1 < query.length && (offset == 0 || !isIdentifierContChar(query[offset - 1]))) { int endIdx = -1; if (query[offset + 1] == '$') { endIdx = offset + 1; } else if (isDollarQuoteStartChar(query[offset + 1])) { for (int d = offset + 2; d < query.length; d++) { if (query[d] == '$') { endIdx = d; break; } else if (!isDollarQuoteContChar(query[d])) { break; } } } if (endIdx > 0) { // found; note: tag includes start and end $ character int tagIdx = offset; int tagLen = endIdx - offset + 1; offset = endIdx; // loop continues at endIdx + 1 for (++offset; offset < query.length; offset++) { if (query[offset] == '$' && subArraysEqual(query, tagIdx, offset, tagLen)) { offset += tagLen - 1; break; } } } } return offset; } /** * Test if the {@code -} character at {@code offset} starts a {@code --} style line comment, * and return the position of the first {@code \r} or {@code \n} character. * * @param query query * @param offset start offset * @return position of the first {@code \r} or {@code \n} character */ public static int parseLineComment(final char[] query, int offset) { if (offset + 1 < query.length && query[offset + 1] == '-') { while (offset + 1 < query.length) { offset++; if (query[offset] == '\r' || query[offset] == '\n') { break; } } } return offset; } /** * Test if the {@code /} character at {@code offset} starts a block comment, and return the * position of the last {@code /} character. * * @param query query * @param offset start offset * @return position of the last {@code /} character */ public static int parseBlockComment(final char[] query, int offset) { if (offset + 1 < query.length && query[offset + 1] == '*') { // /* /* */ */ nest, according to SQL spec int level = 1; for (offset += 2; offset < query.length; offset++) { switch (query[offset - 1]) { case '*': if (query[offset] == '/') { --level; ++offset; // don't parse / in */* twice } break; case '/': if (query[offset] == '*') { ++level; ++offset; // don't parse * in /*/ twice } break; default: break; } if (level == 0) { --offset; // reset position to last '/' char break; } } } return offset; } /** * Parse string to check presence of DELETE keyword regardless of case. The initial character is * assumed to have been matched. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseDeleteKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 'd' && (query[offset + 1] | 32) == 'e' && (query[offset + 2] | 32) == 'l' && (query[offset + 3] | 32) == 'e' && (query[offset + 4] | 32) == 't' && (query[offset + 5] | 32) == 'e'; } /** * Parse string to check presence of INSERT keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseInsertKeyword(final char[] query, int offset) { if (query.length < (offset + 7)) { return false; } return (query[offset] | 32) == 'i' && (query[offset + 1] | 32) == 'n' && (query[offset + 2] | 32) == 's' && (query[offset + 3] | 32) == 'e' && (query[offset + 4] | 32) == 'r' && (query[offset + 5] | 32) == 't'; } /** Parse string to check presence of BEGIN keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseBeginKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 'b' && (query[offset + 1] | 32) == 'e' && (query[offset + 2] | 32) == 'g' && (query[offset + 3] | 32) == 'i' && (query[offset + 4] | 32) == 'n'; } /** Parse string to check presence of ATOMIC keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseAtomicKeyword(final char[] query, int offset) { if (query.length < (offset + 7)) { return false; } return (query[offset] | 32) == 'a' && (query[offset + 1] | 32) == 't' && (query[offset + 2] | 32) == 'o' && (query[offset + 3] | 32) == 'm' && (query[offset + 4] | 32) == 'i' && (query[offset + 5] | 32) == 'c'; } /** * Parse string to check presence of MOVE keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseMoveKeyword(final char[] query, int offset) { if (query.length < (offset + 4)) { return false; } return (query[offset] | 32) == 'm' && (query[offset + 1] | 32) == 'o' && (query[offset + 2] | 32) == 'v' && (query[offset + 3] | 32) == 'e'; } /** * Parse string to check presence of RETURNING keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseReturningKeyword(final char[] query, int offset) { if (query.length < (offset + 9)) { return false; } return (query[offset] | 32) == 'r' && (query[offset + 1] | 32) == 'e' && (query[offset + 2] | 32) == 't' && (query[offset + 3] | 32) == 'u' && (query[offset + 4] | 32) == 'r' && (query[offset + 5] | 32) == 'n' && (query[offset + 6] | 32) == 'i' && (query[offset + 7] | 32) == 'n' && (query[offset + 8] | 32) == 'g'; } /** * Parse string to check presence of SELECT keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseSelectKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 's' && (query[offset + 1] | 32) == 'e' && (query[offset + 2] | 32) == 'l' && (query[offset + 3] | 32) == 'e' && (query[offset + 4] | 32) == 'c' && (query[offset + 5] | 32) == 't'; } /** * Parse string to check presence of CREATE keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseAlterKeyword(final char[] query, int offset) { if (query.length < (offset + 5)) { return false; } return (query[offset] | 32) == 'a' && (query[offset + 1] | 32) == 'l' && (query[offset + 2] | 32) == 't' && (query[offset + 3] | 32) == 'e' && (query[offset + 4] | 32) == 'r'; } /** * Parse string to check presence of CREATE keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseCreateKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 'c' && (query[offset + 1] | 32) == 'r' && (query[offset + 2] | 32) == 'e' && (query[offset + 3] | 32) == 'a' && (query[offset + 4] | 32) == 't' && (query[offset + 5] | 32) == 'e'; } /** * Parse string to check presence of UPDATE keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseUpdateKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 'u' && (query[offset + 1] | 32) == 'p' && (query[offset + 2] | 32) == 'd' && (query[offset + 3] | 32) == 'a' && (query[offset + 4] | 32) == 't' && (query[offset + 5] | 32) == 'e'; } /** * Parse string to check presence of VALUES keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseValuesKeyword(final char[] query, int offset) { if (query.length < (offset + 6)) { return false; } return (query[offset] | 32) == 'v' && (query[offset + 1] | 32) == 'a' && (query[offset + 2] | 32) == 'l' && (query[offset + 3] | 32) == 'u' && (query[offset + 4] | 32) == 'e' && (query[offset + 5] | 32) == 's'; } /** * Faster version of {@link Long#parseLong(String)} when parsing a substring is required * * @param s string to parse * @param beginIndex begin index * @param endIndex end index * @return long value */ public static long parseLong(String s, int beginIndex, int endIndex) { // Fallback to default implementation in case the string is long if (endIndex - beginIndex > 16) { return Long.parseLong(s.substring(beginIndex, endIndex)); } long res = digitAt(s, beginIndex); for (beginIndex++; beginIndex < endIndex; beginIndex++) { res = res * 10 + digitAt(s, beginIndex); } return res; } /** * Parse string to check presence of WITH keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseWithKeyword(final char[] query, int offset) { if (query.length < (offset + 4)) { return false; } return (query[offset] | 32) == 'w' && (query[offset + 1] | 32) == 'i' && (query[offset + 2] | 32) == 't' && (query[offset + 3] | 32) == 'h'; } /** * Parse string to check presence of AS keyword regardless of case. * * @param query char[] of the query statement * @param offset position of query to start checking * @return boolean indicates presence of word */ public static boolean parseAsKeyword(final char[] query, int offset) { if (query.length < (offset + 2)) { return false; } return (query[offset] | 32) == 'a' && (query[offset + 1] | 32) == 's'; } /** * Returns true if a given string {@code s} has digit at position {@code pos}. * @param s input string * @param pos position (0-based) * @return true if input string s has digit at position pos */ public static boolean isDigitAt(String s, int pos) { return pos > 0 && pos < s.length() && Character.isDigit(s.charAt(pos)); } /** * Converts digit at position {@code pos} in string {@code s} to integer or throws. * @param s input string * @param pos position (0-based) * @return integer value of a digit at position pos * @throws NumberFormatException if character at position pos is not an integer */ public static int digitAt(String s, int pos) { int c = s.charAt(pos) - '0'; if (c < 0 || c > 9) { throw new NumberFormatException("Input string: \"" + s + "\", position: " + pos); } return c; } /** * Identifies characters which the backend scanner considers to be whitespace. * ** https://github.com/postgres/postgres/blob/17bb62501787c56e0518e61db13a523d47afd724/src/backend/parser/scan.l#L194-L198 *
* * @param c character * @return true if the character is a whitespace character as defined in the backend's parser */ public static boolean isSpace(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f'; } /** * Identifies white space characters which the backend uses to determine if a * {@code String} value needs to be quoted in array representation. * ** https://github.com/postgres/postgres/blob/f2c587067a8eb9cf1c8f009262381a6576ba3dd0/src/backend/utils/adt/arrayfuncs.c#L421-L438 *
* * @param c * Character to examine. * @return Indication if the character is a whitespace which back end will * escape. */ public static boolean isArrayWhiteSpace(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0x0B; } /** * Returns if the given character is a valid character for an operator in the backend's * parser. * @param c character * @return true if the given character is a valid character for an operator in the backend's * parser */ public static boolean isOperatorChar(char c) { /* * Extracted from operators defined by {self} and {op_chars} * in pgsql/src/backend/parser/scan.l. */ return ",()[].;:+-*/%^<>=~!@#&|`?".indexOf(c) != -1; } /** * Checks if a character is valid as the start of an identifier. * PostgreSQL 9.4 allows column names like _, ‿, ⁀, ⁔, ︳, ︴, ﹍, ﹎, ﹏, ＿, so * it is assumed isJavaIdentifierPart is good enough for PostgreSQL. * * @param c the character to check * @return true if valid as first character of an identifier; false if not * @see Identifiers and Key Words */ public static boolean isIdentifierStartChar(char c) { /* * PostgreSQL's implementation is located in * pgsql/src/backend/parser/scan.l: * ident_start [A-Za-z\200-\377_] * ident_cont [A-Za-z\200-\377_0-9\$] * however it is not clear how that interacts with unicode, so we just use Java's implementation. */ return Character.isJavaIdentifierStart(c); } /** * Checks if a character is valid as the second or later character of an identifier. * * @param c the character to check * @return true if valid as second or later character of an identifier; false if not */ public static boolean isIdentifierContChar(char c) { return Character.isJavaIdentifierPart(c); } /** * Returns true if the character terminates an identifier. * @param c character * @return true if the character terminates an identifier */ public static boolean charTerminatesIdentifier(char c) { return c == '"' || isSpace(c) || isOperatorChar(c); } /** * Checks if a character is valid as the start of a dollar quoting tag. * * @param c the character to check * @return true if valid as first character of a dollar quoting tag; false if not */ public static boolean isDollarQuoteStartChar(char c) { /* * The allowed dollar quote start and continuation characters * must stay in sync with what the backend defines in * pgsql/src/backend/parser/scan.l * * The quoted string starts with $foo$ where "foo" is an optional string * in the form of an identifier, except that it may not contain "$", * and extends to the first occurrence of an identical string. * There is *no* processing of the quoted text. */ return c != '$' && isIdentifierStartChar(c); } /** * Checks if a character is valid as the second or later character of a dollar quoting tag. * * @param c the character to check * @return true if valid as second or later character of a dollar quoting tag; false if not */ public static boolean isDollarQuoteContChar(char c) { return c != '$' && isIdentifierContChar(c); } /** * Compares two sub-arrays of the given character array for equalness. If the length is zero, the * result is true if and only if the offsets are within the bounds of the array. * * @param arr a char array * @param offA first sub-array start offset * @param offB second sub-array start offset * @param len length of the sub arrays to compare * @return true if the sub-arrays are equal; false if not */ private static boolean subArraysEqual(final char[] arr, final int offA, final int offB, final int len) { if (offA < 0 || offB < 0 || offA >= arr.length || offB >= arr.length || offA + len > arr.length || offB + len > arr.length) { return false; } for (int i = 0; i < len; i++) { if (arr[offA + i] != arr[offB + i]) { return false; } } return true; } /** * Converts JDBC-specific callable statement escapes {@code { [? =] callCurrently implemented Escape clauses are those mentioned in 11.3 in the specification. * Basically we look through the sql string for {d xxx}, {t xxx}, {ts xxx}, {oj xxx} or {fn xxx} * in non-string sql code. When we find them, we just strip the escape part leaving only the xxx * part. So, something like "select * from x where d={d '2001-10-09'}" would return "select * from * x where d= '2001-10-09'".
* * @param sql the original query text * @param replaceProcessingEnabled whether replace_processing_enabled is on * @param standardConformingStrings whether standard_conforming_strings is on * @return PostgreSQL-compatible SQL * @throws SQLException if given SQL is wrong */ public static String replaceProcessing(String sql, boolean replaceProcessingEnabled, boolean standardConformingStrings) throws SQLException { if (replaceProcessingEnabled) { // Since escape codes can only appear in SQL CODE, we keep track // of if we enter a string or not. int len = sql.length(); char[] chars = sql.toCharArray(); StringBuilder newsql = new StringBuilder(len); int i = 0; while (i < len) { i = parseSql(chars, i, newsql, false, standardConformingStrings); // We need to loop here in case we encounter invalid // SQL, consider: SELECT a FROM t WHERE (1 > 0)) ORDER BY a // We can't ending replacing after the extra closing paren // because that changes a syntax error to a valid query // that isn't what the user specified. if (i < len) { newsql.append(chars[i]); i++; } } return newsql.toString(); } else { return sql; } } /** * parse the given sql from index i, appending it to the given buffer until we hit an unmatched * right parentheses or end of string. When the stopOnComma flag is set we also stop processing * when a comma is found in sql text that isn't inside nested parenthesis. * * @param sql the original query text * @param i starting position for replacing * @param newsql where to write the replaced output * @param stopOnComma should we stop after hitting the first comma in sql text? * @param stdStrings whether standard_conforming_strings is on * @return the position we stopped processing at * @throws SQLException if given SQL is wrong */ @SuppressWarnings("LabelledBreakTarget") private static int parseSql(char[] sql, int i, StringBuilder newsql, boolean stopOnComma, boolean stdStrings) throws SQLException { SqlParseState state = SqlParseState.IN_SQLCODE; int len = sql.length; int nestedParenthesis = 0; boolean endOfNested = false; // because of the ++i loop i--; while (!endOfNested && ++i < len) { char c = sql[i]; state_switch: switch (state) { case IN_SQLCODE: if (c == '$') { int i0 = i; i = parseDollarQuotes(sql, i); checkParsePosition(i, len, i0, sql, "Unterminated dollar quote started at position {0} in SQL {1}. Expected terminating $$"); newsql.append(sql, i0, i - i0 + 1); break; } else if (c == '\'') { // start of a string? int i0 = i; i = parseSingleQuotes(sql, i, stdStrings); checkParsePosition(i, len, i0, sql, "Unterminated string literal started at position {0} in SQL {1}. Expected ' char"); newsql.append(sql, i0, i - i0 + 1); break; } else if (c == '"') { // start of a identifier? int i0 = i; i = parseDoubleQuotes(sql, i); checkParsePosition(i, len, i0, sql, "Unterminated identifier started at position {0} in SQL {1}. Expected \" char"); newsql.append(sql, i0, i - i0 + 1); break; } else if (c == '/') { int i0 = i; i = parseBlockComment(sql, i); checkParsePosition(i, len, i0, sql, "Unterminated block comment started at position {0} in SQL {1}. Expected */ sequence"); newsql.append(sql, i0, i - i0 + 1); break; } else if (c == '-') { int i0 = i; i = parseLineComment(sql, i); newsql.append(sql, i0, i - i0 + 1); break; } else if (c == '(') { // begin nested sql nestedParenthesis++; } else if (c == ')') { // end of nested sql nestedParenthesis--; if (nestedParenthesis < 0) { endOfNested = true; break; } } else if (stopOnComma && c == ',' && nestedParenthesis == 0) { endOfNested = true; break; } else if (c == '{') { // start of an escape code? if (i + 1 < len) { SqlParseState[] availableStates = SqlParseState.VALUES; // skip first state, it's not a escape code state for (int j = 1; j < availableStates.length; j++) { SqlParseState availableState = availableStates[j]; int matchedPosition = availableState.getMatchedPosition(sql, i + 1); if (matchedPosition == 0) { continue; } i += matchedPosition; if (availableState.replacementKeyword != null) { newsql.append(availableState.replacementKeyword); } state = availableState; break state_switch; } } } newsql.append(c); break; case ESC_FUNCTION: // extract function name i = escapeFunction(sql, i, newsql, stdStrings); state = SqlParseState.IN_SQLCODE; // end of escaped function (or query) break; case ESC_DATE: case ESC_TIME: case ESC_TIMESTAMP: case ESC_OUTERJOIN: case ESC_ESCAPECHAR: if (c == '}') { state = SqlParseState.IN_SQLCODE; // end of escape code. } else { newsql.append(c); } break; } // end switch } return i; } private static int findOpenParenthesis(char[] sql, int i) { int posArgs = i; while (posArgs < sql.length && sql[posArgs] != '(') { posArgs++; } return posArgs; } private static void checkParsePosition(int i, int len, int i0, char[] sql, String message) throws PSQLException { if (i < len) { return; } throw new PSQLException( GT.tr(message, i0, new String(sql)), PSQLState.SYNTAX_ERROR); } private static int escapeFunction(char[] sql, int i, StringBuilder newsql, boolean stdStrings) throws SQLException { String functionName; int argPos = findOpenParenthesis(sql, i); if (argPos < sql.length) { functionName = new String(sql, i, argPos - i).trim(); // extract arguments i = argPos + 1;// we start the scan after the first ( i = escapeFunctionArguments(newsql, functionName, sql, i, stdStrings); } // go to the end of the function copying anything found i++; while (i < sql.length && sql[i] != '}') { newsql.append(sql[i++]); } return i; } /** * Generate sql for escaped functions. * * @param newsql destination StringBuilder * @param functionName the escaped function name * @param sql input SQL text (containing arguments of a function call with possible JDBC escapes) * @param i position in the input SQL * @param stdStrings whether standard_conforming_strings is on * @return the right PostgreSQL sql * @throws SQLException if something goes wrong */ private static int escapeFunctionArguments(StringBuilder newsql, String functionName, char[] sql, int i, boolean stdStrings) throws SQLException { // Maximum arity of functions in EscapedFunctions is 3 ListQuery objects should be explicitly closed when no longer needed; if resources are allocated on * the server for this query, their cleanup is triggered by closing the Query.
* * @author Oliver Jowett (oliver@opencloud.com) */ public interface Query { /** * Create a ParameterList suitable for storing parameters associated with this Query. * *If this query has no parameters, a ParameterList will be returned, but it may be a shared * immutable object. If this query does have parameters, the returned ParameterList is a new list, * unshared by other callers.
* * @return a suitable ParameterList instance for this query */ ParameterList createParameterList(); /** * Returns string representation of the query, substituting particular parameter values for * parameter placeholders. * *Note: the method replaces the values on a best-effort basis as it might omit the replacements * for parameters that can't be processed several times. For instance, {@link java.io.InputStream} * can be processed only once. * * @param parameters a ParameterList returned by this Query's {@link #createParameterList} method, * or {@code null} to leave the parameter placeholders unsubstituted. * @return string representation of this query */ String toString(/* @Nullable */ ParameterList parameters); /** * Returns string representation of the query, substituting particular parameter values for * parameter placeholders. * * @param parameters a ParameterList returned by this Query's {@link #createParameterList} method, * or {@code null} to leave the parameter placeholders unsubstituted. * @param context specifies configuration for converting the parameters to string * @return string representation of this query */ String toString(/* @Nullable */ ParameterList parameters, SqlSerializationContext context); /** * Returns SQL in native for database format. * @return SQL in native for database format */ String getNativeSql(); /** * Returns properties of the query (sql keyword, and some other parsing info). * @return returns properties of the query (sql keyword, and some other parsing info) or null if not applicable */ /* @Nullable */ SqlCommand getSqlCommand(); /** * Close this query and free any server-side resources associated with it. The resources may not * be immediately deallocated, but closing a Query may make the deallocation more prompt. * *
A closed Query should not be executed.
*/ void close(); boolean isStatementDescribed(); boolean isEmpty(); /** * Get the number of times this Query has been batched. * @return number of timesaddBatch() has been called.
*/
int getBatchSize();
/**
* Get a map that a result set can use to find the index associated to a name.
*
* @return null if the query implementation does not support this method.
*/
/* @Nullable */ Mapnull if this object is already a
* single-statement query.
*/
Query /* @Nullable */ [] getSubqueries();
}
postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/QueryExecutor.java 0100664 0000000 0000000 00000057313 00000250600 026267 0 ustar 00 0000000 0000000 /*
* Copyright (c) 2003, PostgreSQL Global Development Group
* See the LICENSE file in the project root for more information.
*/
// Copyright (c) 2004, Open Cloud Limited.
package org.postgresql.core;
import org.postgresql.PGNotification;
import org.postgresql.copy.CopyOperation;
import org.postgresql.core.v3.TypeTransferModeRegistry;
import org.postgresql.jdbc.AutoSave;
import org.postgresql.jdbc.BatchResultHandler;
import org.postgresql.jdbc.EscapeSyntaxCallMode;
import org.postgresql.jdbc.PreferQueryMode;
import org.postgresql.util.HostSpec;
// import org.checkerframework.checker.nullness.qual.Nullable;
import java.io.Closeable;
import java.io.IOException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
/**
* Abstracts the protocol-specific details of executing a query.
*
* Every connection has a single QueryExecutor implementation associated with it. This object * provides:
* *Query objects may represent a query that has parameter placeholders. To provide actual values for * these parameters, a {@link ParameterList} object is created via a factory method ( * {@link Query#createParameterList}). The parameters are filled in by the caller and passed along * with the query to the query execution methods. Several ParameterLists for a given query might * exist at one time (or over time); this allows the underlying Query to be reused for several * executions, or for batch execution of the same Query.
* *In general, a Query created by a particular QueryExecutor may only be executed by that * QueryExecutor, and a ParameterList created by a particular Query may only be used as parameters * to that Query. Unpredictable things will happen if this isn't done.
* * @author Oliver Jowett (oliver@opencloud.com) */ public interface QueryExecutor extends TypeTransferModeRegistry { /** * Flag for query execution that indicates the given Query object is unlikely to be reused. */ int QUERY_ONESHOT = 1; /** * Flag for query execution that indicates that resultset metadata isn't needed and can be safely * omitted. */ int QUERY_NO_METADATA = 2; /** * Flag for query execution that indicates that a resultset isn't expected and the query executor * can safely discard any rows (although the resultset should still appear to be from a * resultset-returning query). */ int QUERY_NO_RESULTS = 4; /** * Flag for query execution that indicates a forward-fetch-capable cursor should be used if * possible. */ int QUERY_FORWARD_CURSOR = 8; /** * Flag for query execution that indicates the automatic BEGIN on the first statement when outside * a transaction should not be done. */ int QUERY_SUPPRESS_BEGIN = 16; /** * Flag for query execution when we don't really want to execute, we just want to get the * parameter metadata for the statement. */ int QUERY_DESCRIBE_ONLY = 32; /** * Flag for query execution used by generated keys where we want to receive both the ResultSet and * associated update count from the command status. */ int QUERY_BOTH_ROWS_AND_STATUS = 64; /** * Force this query to be described at each execution. This is done in pipelined batches where we * might need to detect mismatched result types. */ int QUERY_FORCE_DESCRIBE_PORTAL = 512; /** * Flag to disable batch execution when we expect results (generated keys) from a statement. * * @deprecated in PgJDBC 9.4 as we now auto-size batches. */ @Deprecated int QUERY_DISALLOW_BATCHING = 128; /** * Flag for query execution to avoid using binary transfer. */ int QUERY_NO_BINARY_TRANSFER = 256; /** * Execute the query via simple 'Q' command (not parse, bind, exec, but simple execute). * This sends query text on each execution, however it supports sending multiple queries * separated with ';' as a single command. */ int QUERY_EXECUTE_AS_SIMPLE = 1024; int MAX_SAVE_POINTS = 1000; /** * Flag indicating that when beginning a transaction, it should be read only. */ int QUERY_READ_ONLY_HINT = 2048; /** * Execute a Query, passing results to a provided ResultHandler. * * @param query the query to execute; must be a query returned from calling * {@link #wrap(List)} on this QueryExecutor object. * @param parameters the parameters for the query. Must be non-null if the query
* takes parameters. Must be a parameter object returned by
* {@link org.postgresql.core.Query#createParameterList()}.
* @param handler a ResultHandler responsible for handling results generated by this query
* @param maxRows the maximum number of rows to retrieve
* @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve
* before suspending
* @param flags a combination of QUERY_* flags indicating how to handle the query.
* @throws SQLException if query execution fails
*/
void execute(Query query, /* @Nullable */ ParameterList parameters, ResultHandler handler, int maxRows,
int fetchSize, int flags) throws SQLException;
/**
* Execute a Query with adaptive fetch, passing results to a provided ResultHandler.
*
* @param query the query to execute; must be a query returned from calling
* {@link #wrap(List)} on this QueryExecutor object.
* @param parameters the parameters for the query. Must be non-null if the query
* takes parameters. Must be a parameter object returned by
* {@link org.postgresql.core.Query#createParameterList()}.
* @param handler a ResultHandler responsible for handling results generated by this query
* @param maxRows the maximum number of rows to retrieve
* @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve
* before suspending
* @param flags a combination of QUERY_* flags indicating how to handle the query.
* @param adaptiveFetch state of adaptiveFetch to use during execution
* @throws SQLException if query execution fails
*/
void execute(Query query, /* @Nullable */ ParameterList parameters, ResultHandler handler, int maxRows,
int fetchSize, int flags, boolean adaptiveFetch) throws SQLException;
/**
* Execute several Query, passing results to a provided ResultHandler.
*
* @param queries the queries to execute; each must be a query returned from calling
* {@link #wrap(List)} on this QueryExecutor object.
* @param 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 {@link Query#createParameterList()} created by
* the corresponding query.
* @param handler a ResultHandler responsible for handling results generated by this query
* @param maxRows the maximum number of rows to retrieve
* @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve
* before suspending
* @param flags a combination of QUERY_* flags indicating how to handle the query.
* @throws SQLException if query execution fails
*/
void execute(Query[] queries, /* @Nullable */ ParameterList[] parameterLists,
BatchResultHandler handler, int maxRows,
int fetchSize, int flags) throws SQLException;
/**
* Execute several Query with adaptive fetch, passing results to a provided ResultHandler.
*
* @param queries the queries to execute; each must be a query returned from calling
* {@link #wrap(List)} on this QueryExecutor object.
* @param 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 {@link Query#createParameterList()} created by
* the corresponding query.
* @param handler a ResultHandler responsible for handling results generated by this query
* @param maxRows the maximum number of rows to retrieve
* @param fetchSize if QUERY_FORWARD_CURSOR is set, the preferred number of rows to retrieve
* before suspending
* @param flags a combination of QUERY_* flags indicating how to handle the query.
* @param adaptiveFetch state of adaptiveFetch to use during execution
* @throws SQLException if query execution fails
*/
void execute(Query[] queries, /* @Nullable */ ParameterList[] parameterLists,
BatchResultHandler handler, int maxRows,
int fetchSize, int flags, boolean adaptiveFetch) throws SQLException;
/**
* Fetch additional rows from a cursor.
*
* @param cursor the cursor to fetch from
* @param handler the handler to feed results to
* @param fetchSize the preferred number of rows to retrieve before suspending
* @param adaptiveFetch state of adaptiveFetch to use during fetching
* @throws SQLException if query execution fails
*/
void fetch(ResultCursor cursor, ResultHandler handler, int fetchSize, boolean adaptiveFetch) throws SQLException;
/**
* Create an unparameterized Query object suitable for execution by this QueryExecutor. The
* provided query string is not parsed for parameter placeholders ('?' characters), and the
* {@link Query#createParameterList} of the returned object will always return an empty
* ParameterList.
*
* @param sql the SQL for the query to create
* @return a new Query object
* @throws SQLException if something goes wrong
*/
Query createSimpleQuery(String sql) throws SQLException;
boolean isReWriteBatchedInsertsEnabled();
CachedQuery createQuery(String sql, boolean escapeProcessing, boolean isParameterized,
String /* @Nullable */ ... columnNames)
throws SQLException;
Object createQueryKey(String sql, boolean escapeProcessing, boolean isParameterized,
String /* @Nullable */ ... columnNames);
CachedQuery createQueryByKey(Object key) throws SQLException;
CachedQuery borrowQueryByKey(Object key) throws SQLException;
CachedQuery borrowQuery(String sql) throws SQLException;
CachedQuery borrowCallableQuery(String sql) throws SQLException;
CachedQuery borrowReturningQuery(String sql, String /* @Nullable */ [] columnNames) throws SQLException;
void releaseQuery(CachedQuery cachedQuery);
/**
* Wrap given native query into a ready for execution format.
* @param queries list of queries in native to database syntax
* @return query object ready for execution by this query executor
*/
Query wrap(Listnull if a void result
* was returned
* @throws SQLException if an error occurs while executing the fastpath call
* @deprecated This API is somewhat obsolete, as one may achieve similar performance
* and greater functionality by setting up a prepared statement to define
* the function call. Then, executing the statement with binary transmission of parameters
* and results substitutes for a fast-path function call.
*/
@Deprecated
byte /* @Nullable */ [] fastpathCall(int fnid, ParameterList params, boolean suppressBegin)
throws SQLException;
/**
* Issues a COPY FROM STDIN / COPY TO STDOUT statement and returns handler for associated
* operation. Until the copy operation completes, no other database operation may be performed.
* Implemented for protocol version 3 only.
*
* @param sql input sql
* @param suppressBegin if begin should be suppressed
* @return handler for associated operation
* @throws SQLException when initializing the given query fails
*/
CopyOperation startCopy(String sql, boolean suppressBegin) throws SQLException;
/**
* @return the version of the implementation
*/
ProtocolVersion getProtocolVersion();
/**
* Adds a single oid that should be received using binary encoding.
*
* @param oid The oid to request with binary encoding.
*/
void addBinaryReceiveOid(int oid);
/**
* Remove given oid from the list of oids for binary receive encoding.
*
* Note: the binary receive for the oid can be re-activated later.
* * @param oid The oid to request with binary encoding. */ void removeBinaryReceiveOid(int oid); /** * 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.
* * @return The oids to request with binary encoding. * @deprecated the method returns a copy of the set, so it is not efficient. Use {@link #useBinaryForReceive(int)} */ @Deprecated Set getBinaryReceiveOids(); /** * Sets the oids that should be received using binary encoding. * * @param useBinaryForOids The oids to request with binary encoding. */ void setBinaryReceiveOids(SetNote: the binary send for the oid can be re-activated later.
* * @param oid The oid to send with binary encoding. */ void removeBinarySendOid(int oid); /** * 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.
* * @return useBinaryForOids The oids to send with binary encoding. * @deprecated the method returns a copy of the set, so it is not efficient. Use {@link #useBinaryForSend(int)} */ @Deprecated Set getBinarySendOids(); /** * Sets the oids that should be sent using binary encoding. * * @param useBinaryForOids The oids to send with binary encoding. */ void setBinarySendOids(SetNote that there's no requirement for this to be numeric or of the form x.y.z. PostgreSQL * development releases usually have the format x.ydevel e.g. 9.4devel; betas usually x.ybetan * e.g. 9.4beta1. The --with-extra-version configure option may add an arbitrary string to this.
* *Don't use this string for logic, only use it when displaying the server version to the user. * Prefer getServerVersionNum() for all logic purposes.
* * @return the server version string from the server_version GUC */ String getServerVersion(); /** * Retrieve and clear the set of asynchronous notifications pending on this connection. * * @return an array of notifications; if there are no notifications, an empty array is returned. * @throws SQLException if and error occurs while fetching notifications */ PGNotification[] getNotifications() throws SQLException; /** * Retrieve and clear the chain of warnings accumulated on this connection. * * @return the first SQLWarning in the chain; subsequent warnings can be found via * SQLWarning.getNextWarning(). */ /* @Nullable */ SQLWarning getWarnings(); /** * Get a machine-readable server version. * *This returns the value of the server_version_num GUC. If no such GUC exists, it falls back on * attempting to parse the text server version for the major version. If there's no minor version * (e.g. a devel or beta release) then the minor version is set to zero. If the version could not * be parsed, zero is returned.
* * @return the server version in numeric XXYYZZ form, eg 090401, from server_version_num */ int getServerVersionNum(); /** * Get the current transaction state of this connection. * * @return a ProtocolConnection.TRANSACTION_* constant. */ TransactionState getTransactionState(); /** * Returns whether the server treats string-literals according to the SQL standard or if it uses * traditional PostgreSQL escaping rules. Versions up to 8.1 always treated backslashes as escape * characters in string-literals. Since 8.2, this depends on the value of the * {@code standard_conforming_strings} server variable. * * @return true if the server treats string literals according to the SQL standard */ boolean getStandardConformingStrings(); /** * * @return true if we are going to quote identifier provided in the returning array default is true */ boolean getQuoteReturningIdentifiers(); /** * Returns backend timezone in java format. * @return backend timezone in java format. */ /* @Nullable */ TimeZone getTimeZone(); /** * @return the current encoding in use by this connection */ Encoding getEncoding(); /** * Returns application_name connection property. * @return application_name connection property */ String getApplicationName(); boolean isColumnSanitiserDisabled(); EscapeSyntaxCallMode getEscapeSyntaxCallMode(); PreferQueryMode getPreferQueryMode(); void setPreferQueryMode(PreferQueryMode mode); AutoSave getAutoSave(); void setAutoSave(AutoSave autoSave); boolean willHealOnRetry(SQLException e); /** * By default, the connection resets statement cache in case deallocate all/discard all * message is observed. * This API allows to disable that feature for testing purposes. * * @param flushCacheOnDeallocate true if statement cache should be reset when "deallocate/discard" message observed */ void setFlushCacheOnDeallocate(boolean flushCacheOnDeallocate); /** * @return the ReplicationProtocol instance for this connection. */ ReplicationProtocol getReplicationProtocol(); void setNetworkTimeout(int milliseconds) throws IOException; int getNetworkTimeout() throws IOException; // Expose parameter status to PGConnection MapThe server sends ParameterStatus messages when GUC_REPORT settings are * initially assigned and whenever they change.
* *A future version may invoke a client-defined listener class at this point, * so this should be the only access path.
* *Keys are case-insensitive and case-preserving.
* *The server doesn't provide a way to report deletion of a reportable * parameter so we don't expose one here.
* * @param parameterName case-insensitive case-preserving name of parameter to create or update * @param parameterStatus new value of parameter * @see org.postgresql.PGConnection#getParameterStatuses * @see org.postgresql.PGConnection#getParameterStatus */ protected void onParameterStatus(String parameterName, String parameterStatus) { if (parameterName == null || "".equals(parameterName)) { throw new IllegalStateException("attempt to set GUC_REPORT parameter with null or empty-string name"); } parameterStatuses.put(parameterName, parameterStatus); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/QueryExecutorCloseAction.java 0100664 0000000 0000000 00000006421 00000250600 030405 0 ustar 00 0000000 0000000 /* * Copyright (c) 2023, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Closeable; import java.io.IOException; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; import java.util.logging.Level; import java.util.logging.Logger; /** * The action performs connection cleanup, so it is properly terminated from the backend * point of view. * Implementation note: it should keep only the minimum number of object references * to reduce heap usage in case the user abandons connection without closing it first. */ public class QueryExecutorCloseAction implements Closeable { private static final Logger LOGGER = Logger.getLogger(QueryExecutorBase.class.getName()); @SuppressWarnings("RedundantCast") // Cast is needed for checkerframework to accept the code private static final AtomicReferenceFieldUpdaterThere's a special case of {@code columnNames == new String[]{"*"}} that means all columns * should be returned. {@link Parser} is aware of that and does not quote {@code *}
*/ class QueryWithReturningColumnsKey extends BaseQueryKey { public final String[] columnNames; private int size; // query length cannot exceed MAX_INT QueryWithReturningColumnsKey(String sql, boolean isParameterized, boolean escapeProcessing, String /* @Nullable */ [] columnNames) { super(sql, isParameterized, escapeProcessing); if (columnNames == null) { // TODO: teach parser to fetch key columns somehow when no column names were given columnNames = new String[]{"*"}; } this.columnNames = columnNames; } @Override public long getSize() { int size = this.size; if (size != 0) { return size; } size = (int) super.getSize(); if (columnNames != null) { size += 16; // array itself for (String columnName: columnNames) { size += columnName.length() * 2; // 2 bytes per char, revise with Java 9's compact strings } } this.size = size; return size; } @Override public String toString() { return "QueryWithReturningColumnsKey{" + "sql='" + sql + '\'' + ", isParameterized=" + isParameterized + ", escapeProcessing=" + escapeProcessing + ", columnNames=" + Arrays.toString(columnNames) + '}'; } @Override public boolean equals(/* @Nullable */ Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } if (!super.equals(o)) { return false; } QueryWithReturningColumnsKey that = (QueryWithReturningColumnsKey) o; // Probably incorrect - comparing Object[] arrays with Arrays.equals return Arrays.equals(columnNames, that.columnNames); } @Override public int hashCode() { int result = super.hashCode(); result = 31 * result + Arrays.hashCode(columnNames); return result; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/ReplicationProtocol.java 0100664 0000000 0000000 00000002436 00000250600 027432 0 ustar 00 0000000 0000000 /* * Copyright (c) 2016, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; import org.postgresql.replication.PGReplicationStream; import org.postgresql.replication.fluent.logical.LogicalReplicationOptions; import org.postgresql.replication.fluent.physical.PhysicalReplicationOptions; import java.sql.SQLException; /** * Abstracts the protocol-specific details of physic and logic replication. * *With each connection open with replication options associate own instance ReplicationProtocol.
*/ public interface ReplicationProtocol { /** * Starts logical replication. * @param options not null options for logical replication stream * @return not null stream instance from which available fetch wal logs that was decode by output * plugin * @throws SQLException on error */ PGReplicationStream startLogical(LogicalReplicationOptions options) throws SQLException; /** * Starts physical replication. * @param options not null options for physical replication stream * @return not null stream instance from which available fetch wal logs * @throws SQLException on error */ PGReplicationStream startPhysical(PhysicalReplicationOptions options) throws SQLException; } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/ResultCursor.java 0100664 0000000 0000000 00000001323 00000250600 026105 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core; /** * Abstraction of a cursor over a returned resultset. This is an opaque interface that only provides * a way to close the cursor; all other operations are done by passing a ResultCursor to * QueryExecutor methods. * * @author Oliver Jowett (oliver@opencloud.com) */ public interface ResultCursor { /** * Close this cursor. This may not immediately free underlying resources but may make it happen * more promptly. Closed cursors should not be passed to QueryExecutor methods. */ void close(); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/ResultHandler.java 0100664 0000000 0000000 00000007334 00000250600 026215 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; import java.sql.SQLWarning; import java.util.List; /** * Callback interface for passing query results from the protocol-specific layer to the * protocol-independent JDBC implementation code. * *In general, a single query execution will consist of a number of calls to handleResultRows, * handleCommandStatus, handleWarning, and handleError, followed by a single call to * handleCompletion when query execution is complete. If the caller wants to throw SQLException, * this can be done in handleCompletion.
* *Each executed query ends with a call to handleResultRows, handleCommandStatus, or handleError. If * an error occurs, subsequent queries won't generate callbacks.
* * @author Oliver Jowett (oliver@opencloud.com) */ public interface ResultHandler { /** * Called when result rows are received from a query. * * @param fromQuery the underlying query that generated these results; this may not be very * specific (e.g. it may be a query that includes multiple statements). * @param fields column metadata for the resultset; might benull if
* Query.QUERY_NO_METADATA was specified.
* @param tuples the actual data
* @param cursor a cursor to use to fetch additional data; null if no further results
* are present.
*/
void handleResultRows(Query fromQuery, Field[] fields, ListThe class simplifies creation of ResultHandler delegates: it provides default implementation * for the interface methods
*/ public class ResultHandlerDelegate implements ResultHandler { private final /* @Nullable */ ResultHandler delegate; public ResultHandlerDelegate(/* @Nullable */ ResultHandler delegate) { this.delegate = delegate; } @Override public void handleResultRows(Query fromQuery, Field[] fields, ListIf the specified version cannot be parsed, the {@link Version#getVersionNum()} will return 0.
* * @param version version in numeric XXYYZZ form, e.g. "090401" for 9.4.1 * @return a {@link Version} representing the specified version string. */ public static Version from(/* @Nullable */ String version) { final int versionNum = parseServerVersionStr(version); return new Version() { @Override public int getVersionNum() { return versionNum; } @Override public int getMajorVersionNumber() { return versionNum / 10000; } @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof Version) { return this.getVersionNum() == ((Version) obj).getVersionNum(); } return false; } @Override public int hashCode() { return getVersionNum(); } @Override public String toString() { return Integer.toString(versionNum); } }; } /** * Attempt to parse the server version string into an XXYYZZ form version number. * *Returns 0 if the version could not be parsed.
* *Returns minor version 0 if the minor version could not be determined, e.g. devel or beta * releases.
* *If a single major part like 90400 is passed, it's assumed to be a pre-parsed version and * returned verbatim. (Anything equal to or greater than 10000 is presumed to be this form).
* *The yy or zz version parts may be larger than 99. A NumberFormatException is thrown if a * version part is out of range.
* * @param serverVersion server version in a XXYYZZ form * @return server version in number form */ static int parseServerVersionStr(/* @Nullable */ String serverVersion) throws NumberFormatException { if (serverVersion == null) { return 0; } NumberFormat numformat = NumberFormat.getIntegerInstance(); numformat.setGroupingUsed(false); ParsePosition parsepos = new ParsePosition(0); int[] parts = new int[3]; int versionParts; for (versionParts = 0; versionParts < 3; versionParts++) { Number part = (Number) numformat.parseObject(serverVersion, parsepos); if (part == null) { break; } parts[versionParts] = part.intValue(); if (parsepos.getIndex() == serverVersion.length() || serverVersion.charAt(parsepos.getIndex()) != '.') { break; } // Skip . parsepos.setIndex(parsepos.getIndex() + 1); } versionParts++; if (parts[0] >= 10000) { /* * PostgreSQL version 1000? I don't think so. We're seeing a version like 90401; return it * verbatim, but only if there's nothing else in the version. If there is, treat it as a parse * error. */ if (parsepos.getIndex() == serverVersion.length() && versionParts == 1) { return parts[0]; } else { throw new NumberFormatException( "First major-version part equal to or greater than 10000 in invalid version string: " + serverVersion); } } /* #667 - Allow for versions with greater than 3 parts. For versions with more than 3 parts, still return 3 parts (4th part ignored for now as no functionality is dependent on the 4th part . Allows for future versions of the server to utilize more than 3 part version numbers without upgrading the jdbc driver */ if (versionParts >= 3) { if (parts[1] > 99) { throw new NumberFormatException( "Unsupported second part of major version > 99 in invalid version string: " + serverVersion); } if (parts[2] > 99) { throw new NumberFormatException( "Unsupported second part of minor version > 99 in invalid version string: " + serverVersion); } return (parts[0] * 100 + parts[1]) * 100 + parts[2]; } if (versionParts == 2) { if (parts[0] >= 10) { return parts[0] * 100 * 100 + parts[1]; } if (parts[1] > 99) { throw new NumberFormatException( "Unsupported second part of major version > 99 in invalid version string: " + serverVersion); } return (parts[0] * 100 + parts[1]) * 100; } if (versionParts == 1) { if (parts[0] >= 10) { return parts[0] * 100 * 100; } } return 0; /* unknown */ } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/SetupQueryRunner.java 0100664 0000000 0000000 00000004063 00000250600 026755 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; import java.sql.SQLWarning; import java.util.List; /** * Poor man's Statement & ResultSet, used for initial queries while we're still initializing the * system. */ public class SetupQueryRunner { private static class SimpleResultHandler extends ResultHandlerBase { private /* @Nullable */ ListThis function handles the mapping of uint32-values in the long to java integers, and * throws for values that are out of range.
* * @param oid the oid as a long. * @return the (internal) signed integer representation of the (unsigned) oid. * @throws SQLException if the long has a value outside of the range representable by uint32 */ int longOidToInt(long oid) throws SQLException; /** * Java Integers are signed 32-bit integers, but oids are unsigned 32-bit integers. * We must therefore first map the (internal) integer representation to a positive long * value before sending it to postgresql, or we would be unable to correctly handle the * upper half of the oid space because these negative values are disallowed as OID values. * * @param oid the (signed) integer oid to convert into a long. * @return the non-negative value of this oid, stored as a java long. */ long intOidToLong(int oid); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/Utils.java 0100664 0000000 0000000 00000014772 00000250600 024545 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core; import org.postgresql.util.GT; import org.postgresql.util.PGbytea; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.sql.SQLException; /** * Collection of utilities used by the protocol-level code. */ public class Utils { /** * Turn a bytearray into a printable form, representing each byte in hex. * * @param data the bytearray to stringize * @return a hex-encoded printable representation of {@code data} */ public static String toHexString(byte[] data) { StringBuilder sb = new StringBuilder(data.length * 2); PGbytea.appendHexString(sb, data, 0, data.length); return sb.toString(); } /** * Escape the given literal {@code value} and append it to the string builder {@code sbuf}. If * {@code sbuf} is {@code null}, a new StringBuilder will be returned. The argument * {@code standardConformingStrings} defines whether the backend expects standard-conforming * string literals or allows backslash escape sequences. * * @param sbuf the string builder to append to; or {@code null} * @param value the string value * @param standardConformingStrings if standard conforming strings should be used * @return the sbuf argument; or a new string builder for sbuf == null * @throws SQLException if the string contains a {@code \0} character */ public static StringBuilder escapeLiteral(/* @Nullable */ StringBuilder sbuf, String value, boolean standardConformingStrings) throws SQLException { if (sbuf == null) { sbuf = new StringBuilder((value.length() + 10) / 10 * 11); // Add 10% for escaping. } doAppendEscapedLiteral(sbuf, value, standardConformingStrings); return sbuf; } /** * Common part for {@link #escapeLiteral(StringBuilder, String, boolean)}. * * @param sbuf Either StringBuffer or StringBuilder as we do not expect any IOException to be * thrown * @param value value to append * @param standardConformingStrings if standard conforming strings should be used */ private static void doAppendEscapedLiteral(Appendable sbuf, String value, boolean standardConformingStrings) throws SQLException { try { if (standardConformingStrings) { // With standard_conforming_strings on, escape only single-quotes. for (int i = 0; i < value.length(); i++) { char ch = value.charAt(i); if (ch == '\0') { throw new PSQLException(GT.tr("Zero bytes may not occur in string parameters."), PSQLState.INVALID_PARAMETER_VALUE); } if (ch == '\'') { sbuf.append('\''); } sbuf.append(ch); } } else { // With standard_conforming_string off, escape backslashes and // single-quotes, but still escape single-quotes by doubling, to // avoid a security hazard if the reported value of // standard_conforming_strings is incorrect, or an error if // backslash_quote is off. for (int i = 0; i < value.length(); i++) { char ch = value.charAt(i); if (ch == '\0') { throw new PSQLException(GT.tr("Zero bytes may not occur in string parameters."), PSQLState.INVALID_PARAMETER_VALUE); } if (ch == '\\' || ch == '\'') { sbuf.append(ch); } sbuf.append(ch); } } } catch (IOException e) { throw new PSQLException(GT.tr("No IOException expected from StringBuffer or StringBuilder"), PSQLState.UNEXPECTED_ERROR, e); } } /** * Escape the given identifier {@code value} and append it to the string builder {@code sbuf}. * If {@code sbuf} is {@code null}, a new StringBuilder will be returned. This method is * different from appendEscapedLiteral in that it includes the quoting required for the identifier * while {@link #escapeLiteral(StringBuilder, String, boolean)} does not. * * @param sbuf the string builder to append to; or {@code null} * @param value the string value * @return the sbuf argument; or a new string builder for sbuf == null * @throws SQLException if the string contains a {@code \0} character */ public static StringBuilder escapeIdentifier(/* @Nullable */ StringBuilder sbuf, String value) throws SQLException { if (sbuf == null) { sbuf = new StringBuilder(2 + (value.length() + 10) / 10 * 11); // Add 10% for escaping. } doAppendEscapedIdentifier(sbuf, value); return sbuf; } /** * Common part for appendEscapedIdentifier. * * @param sbuf Either StringBuffer or StringBuilder as we do not expect any IOException to be * thrown. * @param value value to append */ private static void doAppendEscapedIdentifier(Appendable sbuf, String value) throws SQLException { try { sbuf.append('"'); for (int i = 0; i < value.length(); i++) { char ch = value.charAt(i); if (ch == '\0') { throw new PSQLException(GT.tr("Zero bytes may not occur in identifiers."), PSQLState.INVALID_PARAMETER_VALUE); } if (ch == '"') { sbuf.append(ch); } sbuf.append(ch); } sbuf.append('"'); } catch (IOException e) { throw new PSQLException(GT.tr("No IOException expected from StringBuffer or StringBuilder"), PSQLState.UNEXPECTED_ERROR, e); } } /** * Attempt to parse the server version string into an XXYYZZ form version number. * *Returns 0 if the version could not be parsed.
* *Returns minor version 0 if the minor version could not be determined, e.g. devel or beta * releases.
* *If a single major part like 90400 is passed, it's assumed to be a pre-parsed version and * returned verbatim. (Anything equal to or greater than 10000 is presumed to be this form).
* *The yy or zz version parts may be larger than 99. A NumberFormatException is thrown if a * version part is out of range.
* * @param serverVersion server version in a XXYYZZ form * @return server version in number form */ public static int parseServerVersionStr(/* @Nullable */ String serverVersion) throws NumberFormatException { return ServerVersion.parseServerVersionStr(serverVersion); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/Version.java 0100664 0000000 0000000 00000000573 00000250600 025064 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; public interface Version { /** * Get a machine-readable version number. * * @return the version in numeric XXYYZZ form, e.g. 90401 for 9.4.1 */ int getVersionNum(); int getMajorVersionNumber(); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/VisibleBufferedInputStream.java 0100664 0000000 0000000 00000023162 00000250600 030672 0 ustar 00 0000000 0000000 /* * Copyright (c) 2006, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core; import org.postgresql.util.ByteConverter; import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.net.SocketTimeoutException; /** * A faster version of BufferedInputStream. Does no synchronisation and allows direct access to the * used byte[] buffer. * * @author Mikko Tiihonen */ public class VisibleBufferedInputStream extends InputStream { /** * If a direct read to byte array is called that would require a smaller read from the wrapped * stream that MINIMUM_READ then first fill the buffer and serve the bytes from there. Larger * reads are directly done to the provided byte array. */ private static final int MINIMUM_READ = 1024; /** * In how large spans is the C string zero-byte scanned. */ private static final int STRING_SCAN_SPAN = 1024; /** * The wrapped input stream. */ private final InputStream wrapped; /** * The buffer. */ private byte[] buffer; /** * Current read position in the buffer. */ private int index; /** * How far is the buffer filled with valid data. */ private int endIndex; /** * socket timeout has been requested */ private boolean timeoutRequested; /** * Creates a new buffer around the given stream. * * @param in The stream to buffer. * @param bufferSize The initial size of the buffer. */ public VisibleBufferedInputStream(InputStream in, int bufferSize) { wrapped = in; buffer = new byte[bufferSize < MINIMUM_READ ? MINIMUM_READ : bufferSize]; } /** * {@inheritDoc} */ @Override public int read() throws IOException { if (ensureBytes(1)) { return buffer[index++] & 0xFF; } return -1; } /** * Reads an int2 value from the underlying stream as an unsigned integer (0..65535). * @return int2 in the range of 0..65535 * @throws IOException if an I/ O error occurs. */ public int readInt2() throws IOException { if (ensureBytes(2)) { int res = ByteConverter.int2(buffer, index) & 0xffff; index += 2; return res; } throw new EOFException("End of stream reached while trying to read integer2"); } /** * Reads an int4 value from the underlying stream. * @return int4 value from the underlying stream * @throws IOException if an I/ O error occurs. */ public int readInt4() throws IOException { if (ensureBytes(4)) { int res = ByteConverter.int4(buffer, index); index += 4; return res; } throw new EOFException("End of stream reached while trying to read integer4"); } /** * Reads a byte from the buffer without advancing the index pointer. * * @return byte from the buffer without advancing the index pointer * @throws IOException if something wrong happens */ public int peek() throws IOException { if (ensureBytes(1)) { return buffer[index] & 0xFF; } return -1; } /** * Reads byte from the buffer without any checks. This method never reads from the underlying * stream. Before calling this method the {@link #ensureBytes} method must have been called. * * @return The next byte from the buffer. * @throws ArrayIndexOutOfBoundsException If ensureBytes was not called to make sure the buffer * contains the byte. */ public byte readRaw() { return buffer[index++]; } /** * Ensures that the buffer contains at least n bytes. This method invalidates the buffer and index * fields. * * @param n The amount of bytes to ensure exists in buffer * @return true if required bytes are available and false if EOF * @throws IOException If reading of the wrapped stream failed. */ public boolean ensureBytes(int n) throws IOException { return ensureBytes(n, true); } /** * Ensures that the buffer contains at least n bytes. This method invalidates the buffer and index * fields. * * @param n The amount of bytes to ensure exists in buffer * @param block whether or not to block the IO * @return true if required bytes are available and false if EOF or the parameter block was false and socket timeout occurred. * @throws IOException If reading of the wrapped stream failed. */ public boolean ensureBytes(int n, boolean block) throws IOException { int required = n - endIndex + index; while (required > 0) { if (!readMore(required, block)) { return false; } required = n - endIndex + index; } return true; } /** * Reads more bytes into the buffer. * * @param wanted How much should be at least read. * @return True if at least some bytes were read. * @throws IOException If reading of the wrapped stream failed. */ private boolean readMore(int wanted, boolean block) throws IOException { if (endIndex == index) { index = 0; endIndex = 0; } int canFit = buffer.length - endIndex; if (canFit < wanted) { // would the wanted bytes fit if we compacted the buffer // and still leave some slack if (index + canFit > wanted + MINIMUM_READ) { compact(); } else { doubleBuffer(); } canFit = buffer.length - endIndex; } int read = 0; try { read = wrapped.read(buffer, endIndex, canFit); if (!block && read == 0) { return false; } } catch (SocketTimeoutException e) { if (!block) { return false; } if (timeoutRequested) { throw e; } } if (read < 0) { return false; } endIndex += read; return true; } /** * Doubles the size of the buffer. */ private void doubleBuffer() { byte[] buf = new byte[buffer.length * 2]; moveBufferTo(buf); buffer = buf; } /** * Compacts the unread bytes of the buffer to the beginning of the buffer. */ private void compact() { moveBufferTo(buffer); } /** * Moves bytes from the buffer to the beginning of the destination buffer. Also sets the index and * endIndex variables. * * @param dest The destination buffer. */ private void moveBufferTo(byte[] dest) { int size = endIndex - index; System.arraycopy(buffer, index, dest, 0, size); index = 0; endIndex = size; } /** * {@inheritDoc} */ @Override public int read(byte[] to, int off, int len) throws IOException { if ((off | len | (off + len) | (to.length - (off + len))) < 0) { throw new IndexOutOfBoundsException(); } else if (len == 0) { return 0; } // if the read would go to wrapped stream, but would result // in a small read then try read to the buffer instead int avail = endIndex - index; if (len - avail < MINIMUM_READ) { ensureBytes(len); avail = endIndex - index; } // first copy from buffer if (avail > 0) { if (len <= avail) { System.arraycopy(buffer, index, to, off, len); index += len; return len; } System.arraycopy(buffer, index, to, off, avail); len -= avail; off += avail; } int read = avail; // good place to reset index because the buffer is fully drained index = 0; endIndex = 0; // then directly from wrapped stream do { int r; try { r = wrapped.read(to, off, len); } catch (SocketTimeoutException e) { if (read == 0 && timeoutRequested) { throw e; } return read; } if (r <= 0) { return read == 0 ? r : read; } read += r; off += r; len -= r; } while (len > 0); return read; } /** * {@inheritDoc} */ @Override public long skip(long n) throws IOException { int avail = endIndex - index; if (avail >= n) { // Cast to int is safe here since the number of available bytes within the buffer // always fits within int index += (int) n; return n; } n -= avail; index = 0; endIndex = 0; return avail + wrapped.skip(n); } /** * {@inheritDoc} */ @Override public int available() throws IOException { int avail = endIndex - index; return avail > 0 ? avail : wrapped.available(); } /** * {@inheritDoc} */ @Override public void close() throws IOException { wrapped.close(); } /** * Returns direct handle to the used buffer. Use the {@link #ensureBytes} to prefill required * bytes the buffer and {@link #getIndex} to fetch the current position of the buffer. * * @return The underlying buffer. */ public byte[] getBuffer() { return buffer; } /** * Returns the current read position in the buffer. * * @return the current read position in the buffer. */ public int getIndex() { return index; } /** * Scans the length of the next null terminated string (C-style string) from the stream. * * @return The length of the next null terminated string. * @throws IOException If reading of stream fails. * @throws EOFException If the stream did not contain any null terminators. */ public int scanCStringLength() throws IOException { int pos = index; while (true) { while (pos < endIndex) { if (buffer[pos++] == '\0') { return pos - index; } } if (!readMore(STRING_SCAN_SPAN, true)) { throw new EOFException(); } pos = index; } } public void setTimeoutRequested(boolean timeoutRequested) { this.timeoutRequested = timeoutRequested; } /** * Returns the underlying stream. * @return the underlying stream */ public InputStream getWrapped() { return wrapped; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/ 0040775 0000000 0000000 00000000000 00000250600 023122 5 ustar 00 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/AuthenticationPluginManager.java 0100664 0000000 0000000 00000012433 00000250600 031416 0 ustar 00 0000000 0000000 /* * Copyright (c) 2021, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; import org.postgresql.PGProperty; import org.postgresql.plugin.AuthenticationPlugin; import org.postgresql.plugin.AuthenticationRequestType; import org.postgresql.util.GT; import org.postgresql.util.ObjectFactory; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Properties; import java.util.logging.Level; import java.util.logging.Logger; class AuthenticationPluginManager { private static final Logger LOGGER = Logger.getLogger(AuthenticationPluginManager.class.getName()); @FunctionalInterface public interface PasswordActionThe caller provides a action method that will be invoked with the {@code char[]} * password. After completion, for security reasons the {@code char[]} array will be * wiped by filling it with zeroes. Callers must not rely on being able to read * the password {@code char[]} after the action has completed.
* * @param type The authentication type that is being requested * @param info The connection properties for the connection * @param action The action to invoke with the password * @throws PSQLException Throws a PSQLException if the plugin class cannot be instantiated * @throws IOException Bubbles up any thrown IOException from the provided action */ public staticThe caller provides a callback method that will be invoked with the {@code byte[]} * encoded password. After completion, for security reasons the {@code byte[]} array will be * wiped by filling it with zeroes. Callers must not rely on being able to read * the password {@code byte[]} after the callback has completed.
* @param type The authentication type that is being requested * @param info The connection properties for the connection * @param action The action to invoke with the encoded password * @throws PSQLException Throws a PSQLException if the plugin class cannot be instantiated or if the retrieved password is null. * @throws IOException Bubbles up any thrown IOException from the provided callback */ public staticThis method checks whether {@code in_hot_standby} GUC was reported by the server * during initial connection:
* *Do not confuse {@code hot_standby} and {@code in_hot_standby} ParamStatuses
* * @see GUC_REPORT documentation * @see Hot standby documentation * @see in_hot_standby patch thread v10 * @see in_hot_standby patch thread v14 * */ private static boolean isPrimary(QueryExecutor queryExecutor) throws SQLException, IOException { String inHotStandby = queryExecutor.getParameterStatus(IN_HOT_STANDBY); if ("on".equalsIgnoreCase(inHotStandby)) { return false; } Tuple results = SetupQueryRunner.run(queryExecutor, "show transaction_read_only", true); Tuple nonNullResults = castNonNull(results); String queriedTransactionReadonly = queryExecutor.getEncoding().decode(castNonNull(nonNullResults.get(0))); return "off".equalsIgnoreCase(queriedTransactionReadonly); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/CopyDualImpl.java 0100664 0000000 0000000 00000003067 00000250600 026332 0 ustar 00 0000000 0000000 /* * Copyright (c) 2016, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; import org.postgresql.copy.CopyDual; import org.postgresql.util.ByteStreamWriter; import org.postgresql.util.PSQLException; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; import java.util.ArrayDeque; import java.util.Queue; public class CopyDualImpl extends CopyOperationImpl implements CopyDual { private final QueueAnticipated flow: * * CopyManager.copyIn() ->QueryExecutor.startCopy() - sends given query to server * ->processCopyResults(): - receives CopyInResponse from Server - creates new CopyInImpl * ->initCopy(): - receives copy metadata from server ->CopyInImpl.init() ->lock() * connection for this operation - if query fails an exception is thrown - if query returns wrong * CopyOperation, copyIn() cancels it before throwing exception <-return: new CopyInImpl holding * lock on connection repeat CopyIn.writeToCopy() for all data ->CopyInImpl.writeToCopy() * ->QueryExecutorImpl.writeToCopy() - sends given data ->processCopyResults() - parameterized * not to block, just peek for new messages from server - on ErrorResponse, waits until protocol is * restored and unlocks connection CopyIn.endCopy() ->CopyInImpl.endCopy() * ->QueryExecutorImpl.endCopy() - sends CopyDone - processCopyResults() - on CommandComplete * ->CopyOperationImpl.handleCommandComplete() - sets updatedRowCount when applicable - on * ReadyForQuery unlock() connection for use by other operations <-return: * CopyInImpl.getUpdatedRowCount()
*/ public class CopyInImpl extends CopyOperationImpl implements CopyIn { @Override public void writeToCopy(byte[] data, int off, int siz) throws SQLException { getQueryExecutor().writeToCopy(this, data, off, siz); } @Override public void writeToCopy(ByteStreamWriter from) throws SQLException { getQueryExecutor().writeToCopy(this, from); } @Override public void flushCopy() throws SQLException { getQueryExecutor().flushCopy(this); } @Override public long endCopy() throws SQLException { return getQueryExecutor().endCopy(this); } @Override protected void handleCopydata(byte[] data) throws PSQLException { throw new PSQLException(GT.tr("CopyIn copy direction can't receive data"), PSQLState.PROTOCOL_VIOLATION); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/CopyOperationImpl.java 0100664 0000000 0000000 00000004057 00000250600 027405 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.copy.CopyOperation; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; public abstract class CopyOperationImpl implements CopyOperation { /* @Nullable */ QueryExecutorImpl queryExecutor; int rowFormat; int /* @Nullable */ [] fieldFormats; long handledRowCount = -1; void init(QueryExecutorImpl q, int fmt, int[] fmts) { queryExecutor = q; rowFormat = fmt; fieldFormats = fmts; } protected QueryExecutorImpl getQueryExecutor() { return castNonNull(queryExecutor); } @Override public void cancelCopy() throws SQLException { castNonNull(queryExecutor).cancelCopy(this); } @Override public int getFieldCount() { return castNonNull(fieldFormats).length; } @Override public int getFieldFormat(int field) { return castNonNull(fieldFormats)[field]; } @Override public int getFormat() { return rowFormat; } @Override public boolean isActive() { return castNonNull(queryExecutor).hasLockOn(this); } public void handleCommandStatus(String status) throws PSQLException { if (status.startsWith("COPY")) { int i = status.lastIndexOf(' '); handledRowCount = i > 3 ? Long.parseLong(status.substring(i + 1)) : -1; } else { throw new PSQLException(GT.tr("CommandComplete expected COPY but got: " + status), PSQLState.COMMUNICATION_ERROR); } } /** * Consume received copy data. * * @param data data that was receive by copy protocol * @throws PSQLException if some internal problem occurs */ protected abstract void handleCopydata(byte[] data) throws PSQLException; @Override public long getHandledRowCount() { return handledRowCount; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/CopyOutImpl.java 0100664 0000000 0000000 00000003430 00000250600 026206 0 ustar 00 0000000 0000000 /* * Copyright (c) 2009, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; import org.postgresql.copy.CopyOut; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.SQLException; /** * Anticipated flow of a COPY TO STDOUT operation: * *CopyManager.copyOut() ->QueryExecutor.startCopy() - sends given query to server * ->processCopyResults(): - receives CopyOutResponse from Server - creates new CopyOutImpl * ->initCopy(): - receives copy metadata from server ->CopyOutImpl.init() ->lock() * connection for this operation - if query fails an exception is thrown - if query returns wrong * CopyOperation, copyOut() cancels it before throwing exception <-returned: new CopyOutImpl * holding lock on connection repeat CopyOut.readFromCopy() until null * ->CopyOutImpl.readFromCopy() ->QueryExecutorImpl.readFromCopy() ->processCopyResults() - * on copydata row from server ->CopyOutImpl.handleCopydata() stores reference to byte array - on * CopyDone, CommandComplete, ReadyForQuery ->unlock() connection for use by other operations * <-returned: byte array of data received from server or null at end.
*/ public class CopyOutImpl extends CopyOperationImpl implements CopyOut { private byte /* @Nullable */ [] currentDataRow; @Override public byte /* @Nullable */ [] readFromCopy() throws SQLException { return readFromCopy(true); } @Override public byte /* @Nullable */ [] readFromCopy(boolean block) throws SQLException { currentDataRow = null; getQueryExecutor().readFromCopy(this, block); return currentDataRow; } @Override protected void handleCopydata(byte[] data) { currentDataRow = data; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/DefaultSqlSerializationContext.java 0100664 0000000 0000000 00000003774 00000250600 032144 0 ustar 00 0000000 0000000 /* * Copyright (c) 2025, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; /** * Provides a default implementation for {@link SqlSerializationContext}. */ enum DefaultSqlSerializationContext implements SqlSerializationContext { /** * Render SQL in a repeatable way (avoid consuming {@link java.io.InputStream} sources), * use standard_conforming_strings=yes string literals. * This option is useful for {@code toString()} implementations as it does induce side effects. */ STDSTR_IDEMPOTENT(true, true), /** * Render SQL with replacing all the parameters, including {@link java.io.InputStream} sources. * Use standard_conforming_strings=yes for string literals. * This option is useful for rendering an executable SQL. */ STDSTR_NONIDEMPOTENT(true, false), // Auxiliary options as standard_conforming_strings=on since PostgreSQL 9.1 /** * Render SQL in a repeatable way (avoid consuming {@link java.io.InputStream} sources), * use standard_conforming_strings=no string literals. * The entry is for completeness only as standard_conforming_strings=no should probably be avoided. */ NONSTDSTR_IDEMPOTENT(false, true), /** * Render SQL with replacing all the parameters, including {@link java.io.InputStream} sources. * Use standard_conforming_strings=no for string literals. * The entry is for completeness only as standard_conforming_strings=no should probably be avoided. */ NONSTDSTR_NONIDEMPOTENT(false, false), ; private final boolean standardConformingStrings; private final boolean idempotent; DefaultSqlSerializationContext(boolean standardConformingStrings, boolean idempotent) { this.standardConformingStrings = standardConformingStrings; this.idempotent = idempotent; } @Override public boolean getStandardConformingStrings() { return standardConformingStrings; } @Override public boolean getIdempotent() { return idempotent; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/DescribeRequest.java 0100664 0000000 0000000 00000001475 00000250600 027062 0 ustar 00 0000000 0000000 /* * Copyright (c) 2015, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; // import org.checkerframework.checker.nullness.qual.Nullable; /** * Information for "pending describe queue". * * @see QueryExecutorImpl#pendingDescribeStatementQueue */ class DescribeRequest { public final SimpleQuery query; public final SimpleParameterList parameterList; public final boolean describeOnly; public final /* @Nullable */ String statementName; DescribeRequest(SimpleQuery query, SimpleParameterList parameterList, boolean describeOnly, /* @Nullable */ String statementName) { this.query = query; this.parameterList = parameterList; this.describeOnly = describeOnly; this.statementName = statementName; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/ExecuteRequest.java 0100664 0000000 0000000 00000001201 00000250600 026727 0 ustar 00 0000000 0000000 /* * Copyright (c) 2015, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; // import org.checkerframework.checker.nullness.qual.Nullable; /** * Information for "pending execute queue". * * @see QueryExecutorImpl#pendingExecuteQueue */ class ExecuteRequest { public final SimpleQuery query; public final /* @Nullable */ Portal portal; public final boolean asSimple; ExecuteRequest(SimpleQuery query, /* @Nullable */ Portal portal, boolean asSimple) { this.query = query; this.portal = portal; this.asSimple = asSimple; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/Portal.java 0100664 0000000 0000000 00000003574 00000250600 025234 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core.v3; import org.postgresql.core.ResultCursor; // import org.checkerframework.checker.nullness.qual.Nullable; import java.lang.ref.PhantomReference; import java.nio.charset.StandardCharsets; /** * V3 ResultCursor implementation in terms of backend Portals. This holds the state of a single * Portal. We use a PhantomReference managed by our caller to handle resource cleanup. * * @author Oliver Jowett (oliver@opencloud.com) */ class Portal implements ResultCursor { Portal(/* @Nullable */ SimpleQuery query, String portalName) { this.query = query; this.portalName = portalName; this.encodedName = portalName.getBytes(StandardCharsets.UTF_8); } @Override public void close() { PhantomReference cleanupRef = this.cleanupRef; if (cleanupRef != null) { cleanupRef.clear(); cleanupRef.enqueue(); this.cleanupRef = null; } } String getPortalName() { return portalName; } byte[] getEncodedPortalName() { return encodedName; } /* @Nullable */ SimpleQuery getQuery() { return query; } void setCleanupRef(PhantomReference cleanupRef) { this.cleanupRef = cleanupRef; } @Override public String toString() { return portalName; } // Holding on to a reference to the generating query has // the nice side-effect that while this Portal is referenced, // so is the SimpleQuery, so the underlying statement won't // be closed while the portal is open (the backend closes // all open portals when the statement is closed) private final /* @Nullable */ SimpleQuery query; private final String portalName; private final byte[] encodedName; private /* @Nullable */ PhantomReference cleanupRef; } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/QueryExecutorImpl.java 0100664 0000000 0000000 00000336724 00000250600 027447 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ // Copyright (c) 2004, Open Cloud Limited. package org.postgresql.core.v3; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.PGProperty; import org.postgresql.copy.CopyIn; import org.postgresql.copy.CopyOperation; import org.postgresql.copy.CopyOut; import org.postgresql.core.CommandCompleteParser; import org.postgresql.core.Encoding; import org.postgresql.core.EncodingPredictor; import org.postgresql.core.Field; import org.postgresql.core.NativeQuery; import org.postgresql.core.Notification; import org.postgresql.core.Oid; import org.postgresql.core.PGBindException; import org.postgresql.core.PGStream; import org.postgresql.core.ParameterList; import org.postgresql.core.Parser; import org.postgresql.core.PgMessageType; import org.postgresql.core.ProtocolVersion; import org.postgresql.core.Query; import org.postgresql.core.QueryExecutor; import org.postgresql.core.QueryExecutorBase; import org.postgresql.core.ReplicationProtocol; import org.postgresql.core.ResultCursor; import org.postgresql.core.ResultHandler; import org.postgresql.core.ResultHandlerBase; import org.postgresql.core.ResultHandlerDelegate; import org.postgresql.core.SqlCommand; import org.postgresql.core.SqlCommandType; import org.postgresql.core.TransactionState; import org.postgresql.core.Tuple; import org.postgresql.core.v3.adaptivefetch.AdaptiveFetchCache; import org.postgresql.core.v3.replication.V3ReplicationProtocol; import org.postgresql.jdbc.AutoSave; import org.postgresql.jdbc.BatchResultHandler; import org.postgresql.jdbc.ResourceLock; import org.postgresql.jdbc.TimestampUtils; import org.postgresql.util.ByteStreamWriter; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import org.postgresql.util.PSQLWarning; import org.postgresql.util.ServerErrorMessage; import org.postgresql.util.internal.IntSet; import org.postgresql.util.internal.SourceStreamIOException; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import java.lang.ref.PhantomReference; import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.net.Socket; import java.net.SocketException; import java.net.SocketTimeoutException; import java.nio.charset.StandardCharsets; import java.sql.SQLException; import java.sql.SQLWarning; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collections; import java.util.Deque; import java.util.HashMap; import java.util.List; import java.util.Locale; import java.util.Objects; import java.util.Properties; import java.util.Set; import java.util.TimeZone; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.logging.Level; import java.util.logging.Logger; /** * QueryExecutor implementation for the V3 protocol. */ public class QueryExecutorImpl extends QueryExecutorBase { private static final Logger LOGGER = Logger.getLogger(QueryExecutorImpl.class.getName()); private static final Field[] NO_FIELDS = new Field[0]; static { //canonicalize commonly seen strings to reduce memory and speed comparisons Encoding.canonicalize("application_name"); Encoding.canonicalize("client_encoding"); Encoding.canonicalize("DateStyle"); Encoding.canonicalize("integer_datetimes"); Encoding.canonicalize("off"); Encoding.canonicalize("on"); Encoding.canonicalize("server_encoding"); Encoding.canonicalize("server_version"); Encoding.canonicalize("server_version_num"); Encoding.canonicalize("standard_conforming_strings"); Encoding.canonicalize("TimeZone"); Encoding.canonicalize("UTF8"); Encoding.canonicalize("UTF-8"); Encoding.canonicalize("in_hot_standby"); } /** * TimeZone of the current connection (TimeZone backend parameter). */ private /* @Nullable */ TimeZone timeZone; /** * application_name connection property. */ private /* @Nullable */ String applicationName; /** * True if server uses integers for date and time fields. False if server uses double. */ private boolean integerDateTimes; /** * Bit set that has a bit set for each oid which should be received using binary format. */ private final IntSet useBinaryReceiveForOids = new IntSet(); /** * Bit set that has a bit set for each oid which should be sent using binary format. */ private final IntSet useBinarySendForOids = new IntSet(); /** * This is a fake query object so processResults can distinguish "ReadyForQuery" messages * from Sync messages vs from simple execute (aka 'Q'). */ @SuppressWarnings("method.invocation") private final SimpleQuery sync = (SimpleQuery) createQuery("SYNC", false, true).query; private short deallocateEpoch; /** * This caches the latest observed {@code set search_path} query so the reset of prepared * statement cache can be skipped if using repeated calls for the same {@code set search_path} * value. */ private /* @Nullable */ String lastSetSearchPathQuery; /** * The exception that caused the last transaction to fail. */ private /* @Nullable */ SQLException transactionFailCause; private final ReplicationProtocol replicationProtocol; /** * {@code CommandComplete(B)} messages are quite common, so we reuse instance to parse those */ private final CommandCompleteParser commandCompleteParser = new CommandCompleteParser(); private final AdaptiveFetchCache adaptiveFetchCache; @SuppressWarnings({"assignment", "argument", "method.invocation"}) public QueryExecutorImpl(PGStream pgStream, int cancelSignalTimeout, Properties info) throws SQLException, IOException { super(pgStream, cancelSignalTimeout, info); long maxResultBuffer = pgStream.getMaxResultBuffer(); this.adaptiveFetchCache = new AdaptiveFetchCache(maxResultBuffer, info); this.allowEncodingChanges = PGProperty.ALLOW_ENCODING_CHANGES.getBoolean(info); this.cleanupSavePoints = PGProperty.CLEANUP_SAVEPOINTS.getBoolean(info); // assignment, argument this.replicationProtocol = new V3ReplicationProtocol(this, pgStream); readStartupMessages(); } @Override public ProtocolVersion getProtocolVersion() { return protocolVersion; } /** * 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.
*/ private /* @Nullable */ Object lockedFor; /** * Obtain lock over this connection for given object, blocking to wait if necessary. * * @param obtainer object that gets the lock. Normally current thread. * @throws PSQLException when already holding the lock or getting interrupted. */ private void lock(Object obtainer) throws PSQLException { if (lockedFor == obtainer) { throw new PSQLException(GT.tr("Tried to obtain lock while already holding it"), PSQLState.OBJECT_NOT_IN_STATE); } waitOnLock(); lockedFor = obtainer; } /** * Release lock on this connection presumably held by given object. * * @param holder object that holds the lock. Normally current thread. * @throws PSQLException when this thread does not hold the lock */ private void unlock(Object holder) throws PSQLException { if (lockedFor != holder) { throw new PSQLException(GT.tr("Tried to break lock on database connection"), PSQLState.OBJECT_NOT_IN_STATE); } lockedFor = null; lockCondition.signal(); } /** * 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. */ private void waitOnLock() throws PSQLException { while (lockedFor != null) { try { lockCondition.await(); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); throw new PSQLException( GT.tr("Interrupted while waiting to obtain lock on database connection"), PSQLState.OBJECT_NOT_IN_STATE, ie); } } } /** * @param holder object assumed to hold the lock * @return whether given object actually holds the lock */ boolean hasLockOn(/* @Nullable */ Object holder) { try (ResourceLock ignore = lock.obtain()) { return lockedFor == holder; } } /** * @param holder object assumed to hold the lock * @return whether given object actually holds the lock */ private boolean hasLock(/* @Nullable */ Object holder) { return lockedFor == holder; } // // Query parsing // @Override public Query createSimpleQuery(String sql) throws SQLException { ListStarts at zero, reset by every Sync message. Mainly used for batches.
* *Used to avoid deadlocks, see MAX_BUFFERED_RECV_BYTES.
*/ private int estimatedReceiveBufferBytes; private final SimpleQuery beginTransactionQuery = new SimpleQuery( new NativeQuery("BEGIN", null, false, SqlCommand.BLANK), null, false); private final SimpleQuery beginReadOnlyTransactionQuery = new SimpleQuery( new NativeQuery("BEGIN READ ONLY", null, false, SqlCommand.BLANK), null, false); private final SimpleQuery emptyQuery = new SimpleQuery( new NativeQuery("", null, false, SqlCommand.createStatementTypeInfo(SqlCommandType.BLANK) ), null, false); private final SimpleQuery autoSaveQuery = new SimpleQuery( new NativeQuery("SAVEPOINT PGJDBC_AUTOSAVE", null, false, SqlCommand.BLANK), null, false); private final SimpleQuery releaseAutoSave = new SimpleQuery( new NativeQuery("RELEASE SAVEPOINT PGJDBC_AUTOSAVE", null, false, SqlCommand.BLANK), null, false); /* In autosave mode we use this query to roll back errored transactions */ private final SimpleQuery restoreToAutoSave = new SimpleQuery( new NativeQuery("ROLLBACK TO SAVEPOINT PGJDBC_AUTOSAVE", null, false, SqlCommand.BLANK), null, false); } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/ScramAuthenticator.java 0100664 0000000 0000000 00000017574 00000250600 027600 0 ustar 00 0000000 0000000 /* * Copyright (c) 2024, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.core.v3; import org.postgresql.core.PGStream; import org.postgresql.core.PgMessageType; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import com.ongres.scram.client.ScramClient; import com.ongres.scram.common.ClientFinalMessage; import com.ongres.scram.common.ClientFirstMessage; import com.ongres.scram.common.StringPreparation; import com.ongres.scram.common.exception.ScramException; import com.ongres.scram.common.util.TlsServerEndpoint; import java.io.IOException; import java.net.Socket; import java.nio.charset.StandardCharsets; import java.security.cert.Certificate; import java.security.cert.CertificateEncodingException; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.util.logging.Level; import java.util.logging.Logger; import javax.net.ssl.SSLPeerUnverifiedException; import javax.net.ssl.SSLSession; import javax.net.ssl.SSLSocket; final class ScramAuthenticator { private static final Logger LOGGER = Logger.getLogger(ScramAuthenticator.class.getName()); private final PGStream pgStream; private final ScramClient scramClient; ScramAuthenticator(char[] password, PGStream pgStream, Properties info) throws PSQLException { this.pgStream = pgStream; this.scramClient = initializeScramClient(password, pgStream, info); } private static ScramClient initializeScramClient(char[] password, PGStream stream, Properties info) throws PSQLException { try { final ChannelBindingOption channelBinding = ChannelBindingOption.of(info); LOGGER.log(Level.FINEST, "channelBinding( {0} )", channelBinding); final byte[] cbindData = getChannelBindingData(stream, channelBinding); final ListFor example, "123" and "int4" becomes "('123'::int)"
* *The additional parentheses is added to ensure that the surrounding text of where the * parameter value is entered does modify the interpretation of the value.
* *For example if our input SQL is: SELECT ?b
Using a parameter value of '{}' and type of json we'd get:
* *
* test=# SELECT ('{}'::json)b;
* b
* ----
* {}
*
*
* But without the parentheses the result changes:
* *
* test=# SELECT '{}'::jsonb;
* jsonb
* -------
* {}
*
**/
private static String quoteAndCast(String text, /* @Nullable */ String type, boolean standardConformingStrings) {
StringBuilder sb = new StringBuilder((text.length() + 10) / 10 * 11); // Add 10% for escaping.
sb.append("('");
try {
Utils.escapeLiteral(sb, text, standardConformingStrings);
} catch (SQLException e) {
// This should only happen if we have an embedded null
// and there's not much we can do if we do hit one.
//
// To force a server side failure, we deliberately include
// a zero byte character in the literal to force the server
// to reject the command.
sb.append('\u0000');
}
sb.append("'");
if (type != null) {
sb.append("::");
sb.append(type);
}
sb.append(")");
return sb.toString();
}
private static Results are cached until/unless the query is re-described.
* * @return Max size of result data in bytes according to returned fields, 0 if no results, -1 if * result is unbounded. * @throws IllegalStateException if the query is not described */ public int getMaxResultRowSize() { if (cachedMaxResultRowSize != null) { return cachedMaxResultRowSize; } if (!this.statementDescribed) { throw new IllegalStateException( "Cannot estimate result row size on a statement that is not described"); } int maxResultRowSize = 0; if (fields != null) { for (Field f : fields) { final int fieldLength = f.getLength(); if (fieldLength < 1 || fieldLength >= 65535) { /* * Field length unknown or large; we can't make any safe estimates about the result size, * so we have to fall back to sending queries individually. */ maxResultRowSize = -1; break; } maxResultRowSize += fieldLength; } } cachedMaxResultRowSize = maxResultRowSize; return maxResultRowSize; } // // Implementation guts // @Override public String getNativeSql() { return nativeQuery.nativeSql; } void setStatementName(String statementName, short deallocateEpoch) { assert statementName != null : "statement name should not be null"; this.statementName = statementName; this.encodedStatementName = statementName.getBytes(StandardCharsets.UTF_8); this.deallocateEpoch = deallocateEpoch; } void setPrepareTypes(int[] paramTypes) { // Remember which parameters were unspecified since the parameters will be overridden later by // ParameterDescription message for (int i = 0; i < paramTypes.length; i++) { int paramType = paramTypes[i]; if (paramType == Oid.UNSPECIFIED) { if (this.unspecifiedParams == null) { this.unspecifiedParams = new BitSet(); } this.unspecifiedParams.set(i); } } // paramTypes is changed by "describe statement" response, so we clone the array // However, we can reuse array if there is one if (this.preparedTypes == null) { this.preparedTypes = paramTypes.clone(); return; } System.arraycopy(paramTypes, 0, this.preparedTypes, 0, paramTypes.length); } int /* @Nullable */ [] getPrepareTypes() { return preparedTypes; } /* @Nullable */ String getStatementName() { return statementName; } boolean isPreparedFor(int[] paramTypes, short deallocateEpoch) { if (statementName == null || preparedTypes == null) { return false; // Not prepared. } if (this.deallocateEpoch != deallocateEpoch) { return false; } assert paramTypes.length == preparedTypes.length : String.format("paramTypes:%1$d preparedTypes:%2$d", paramTypes.length, preparedTypes.length); // Check for compatible types. BitSet unspecified = this.unspecifiedParams; for (int i = 0; i < paramTypes.length; i++) { int paramType = paramTypes[i]; // Either paramType should match prepared type // Or paramType==UNSPECIFIED and the prepare type was UNSPECIFIED // Note: preparedTypes can be updated by "statement describe" // 1) parse(name="S_01", sql="select ?::timestamp", types={UNSPECIFIED}) // 2) statement describe: bind 1 type is TIMESTAMP // 3) SimpleQuery.preparedTypes is updated to TIMESTAMP // ... // 4.1) bind(name="S_01", ..., types={TIMESTAMP}) -> OK (since preparedTypes is equal to TIMESTAMP) // 4.2) bind(name="S_01", ..., types={UNSPECIFIED}) -> OK (since the query was initially parsed with UNSPECIFIED) // 4.3) bind(name="S_01", ..., types={DATE}) -> KO, unprepare and parse required int preparedType = preparedTypes[i]; if (paramType != preparedType && (paramType != Oid.UNSPECIFIED || unspecified == null || !unspecified.get(i))) { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.log(Level.FINER, "Statement {0} does not match new parameter types. Will have to un-prepare it and parse once again." + " To avoid performance issues, use the same data type for the same bind position. Bind index (1-based) is {1}," + " preparedType was {2} (after describe {3}), current bind type is {4}", new Object[]{statementName, i + 1, Oid.toString(unspecified != null && unspecified.get(i) ? 0 : preparedType), Oid.toString(preparedType), Oid.toString(paramType)}); } return false; } } return true; } boolean hasUnresolvedTypes() { if (preparedTypes == null) { return true; } return this.unspecifiedParams != null && !this.unspecifiedParams.isEmpty(); } byte /* @Nullable */ [] getEncodedStatementName() { return encodedStatementName; } /** * Sets the fields that this query will return. * * @param fields The fields that this query will return. */ void setFields(Field /* @Nullable */ [] fields) { this.fields = fields; this.resultSetColumnNameIndexMap = null; this.cachedMaxResultRowSize = null; this.needUpdateFieldFormats = fields != null; this.hasBinaryFields = false; // just in case } /** * Returns the fields that this query will return. If the result set fields are not known returns * null. * * @return the fields that this query will return. */ Field /* @Nullable */ [] getFields() { return fields; } /** * Returns true if current query needs field formats be adjusted as per connection configuration. * Subsequent invocations would return {@code false}. The idea is to perform adjustments only * once, not for each * {@link QueryExecutorImpl#sendBind(SimpleQuery, SimpleParameterList, Portal, boolean)}. * * @return true if current query needs field formats be adjusted as per connection configuration */ boolean needUpdateFieldFormats() { if (needUpdateFieldFormats) { needUpdateFieldFormats = false; return true; } return false; } public void resetNeedUpdateFieldFormats() { needUpdateFieldFormats = fields != null; } public boolean hasBinaryFields() { return hasBinaryFields; } public void setHasBinaryFields(boolean hasBinaryFields) { this.hasBinaryFields = hasBinaryFields; } // Have we sent a Describe Portal message for this query yet? boolean isPortalDescribed() { return portalDescribed; } void setPortalDescribed(boolean portalDescribed) { this.portalDescribed = portalDescribed; this.cachedMaxResultRowSize = null; } // Have we sent a Describe Statement message for this query yet? // Note that we might not have need to, so this may always be false. @Override public boolean isStatementDescribed() { return statementDescribed; } void setStatementDescribed(boolean statementDescribed) { this.statementDescribed = statementDescribed; this.cachedMaxResultRowSize = null; } @Override public boolean isEmpty() { return getNativeSql().isEmpty(); } void setCleanupRef(PhantomReference cleanupRef) { PhantomReference oldCleanupRef = this.cleanupRef; if (oldCleanupRef != null) { oldCleanupRef.clear(); oldCleanupRef.enqueue(); } this.cleanupRef = cleanupRef; } void unprepare() { PhantomReference cleanupRef = this.cleanupRef; if (cleanupRef != null) { cleanupRef.clear(); cleanupRef.enqueue(); this.cleanupRef = null; } if (this.unspecifiedParams != null) { this.unspecifiedParams.clear(); } statementName = null; encodedStatementName = null; fields = null; this.resultSetColumnNameIndexMap = null; portalDescribed = false; statementDescribed = false; cachedMaxResultRowSize = null; } @Override public int getBatchSize() { return 1; } NativeQuery getNativeQuery() { return nativeQuery; } public final int getBindCount() { return nativeQuery.bindPositions.length * getBatchSize(); } private /* @Nullable */ Mapnull if this object is
* already a single-statement parameter list.
*/
SimpleParameterList /* @Nullable */ [] getSubparams();
/**
* Return the parameter type information.
* @return an array of {@link org.postgresql.core.Oid} type information
*/
int /* @Nullable */ [] getParamTypes();
/**
* Return the flags for each parameter.
* @return an array of bytes used to store flags.
*/
byte /* @Nullable */ [] getFlags();
/**
* Return the encoding for each parameter.
* @return nested byte array of bytes with encoding information.
*/
byte /* @Nullable */ [] /* @Nullable */ [] getEncoding();
}
postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/adaptivefetch/ 0040775 0000000 0000000 00000000000 00000250600 025731 5 ustar 00 0000000 0000000 ././@LongLink 0100644 0000000 0000000 00000000146 00000250600 011612 L ustar 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/adaptivefetch/AdaptiveFetchCache.java postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/core/v3/adaptivefetch/AdaptiveFetchCache.jav0100664 0000000 0000000 00000015706 00000250600 032074 0 ustar 00 0000000 0000000 /*
* Copyright (c) 2020, PostgreSQL Global Development Group
* See the LICENSE file in the project root for more information.
*/
package org.postgresql.core.v3.adaptivefetch;
import org.postgresql.PGProperty;
import org.postgresql.core.Query;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* The main purpose of this class is to handle adaptive fetching process. Adaptive fetching is used
* to compute fetch size to fully use size defined by maxResultBuffer. Computing is made by dividing
* maxResultBuffer size by max row result size noticed so far. Each query have separate adaptive
* fetch size computed, but same queries have it shared. If adaptive fetch is turned on, first fetch
* is going to be made with defaultRowFetchSize, next fetching of resultSet will be made with
* computed adaptive fetch size. If adaptive fetch is turned on during fetching, then first fetching
* made by ResultSet will be made with defaultRowFetchSize, next will use computed adaptive fetch
* size. Property adaptiveFetch need properties defaultRowFetchSize and maxResultBuffer to work.
*/
public class AdaptiveFetchCache {
private final Map* In any case, in order to use this ConnectionPoolDataSource, you must set the property * databaseName. The settings for serverName, portNumber, user, and password are optional. Note: * these properties are declared in the superclass. *
* ** This implementation supports JDK 1.3 and higher. *
* * @author Aaron Mulder (ammulder@chariotsolutions.com) */ public class PGConnectionPoolDataSource extends BaseDataSource implements ConnectionPoolDataSource, Serializable { private boolean defaultAutoCommit = true; /** * Gets a description of this DataSource. */ @Override public String getDescription() { return "ConnectionPoolDataSource from " + DriverInfo.DRIVER_FULL_NAME; } /** * Gets a connection which may be pooled by the app server or middleware implementation of * DataSource. * * @throws java.sql.SQLException Occurs when the physical database connection cannot be * established. */ @Override public PooledConnection getPooledConnection() throws SQLException { return new PGPooledConnection(getConnection(), defaultAutoCommit); } /** * Gets a connection which may be pooled by the app server or middleware implementation of * DataSource. * * @throws java.sql.SQLException Occurs when the physical database connection cannot be * established. */ @Override public PooledConnection getPooledConnection(String user, String password) throws SQLException { return new PGPooledConnection(getConnection(user, password), defaultAutoCommit); } /** * Gets whether connections supplied by this pool will have autoCommit turned on by default. The * default value is {@code true}, so that autoCommit will be turned on by default. * * @return true if connections supplied by this pool will have autoCommit */ public boolean isDefaultAutoCommit() { return defaultAutoCommit; } /** * Sets whether connections supplied by this pool will have autoCommit turned on by default. The * default value is {@code true}, so that autoCommit will be turned on by default. * * @param defaultAutoCommit whether connections supplied by this pool will have autoCommit */ public void setDefaultAutoCommit(boolean defaultAutoCommit) { this.defaultAutoCommit = defaultAutoCommit; } private void writeObject(ObjectOutputStream out) throws IOException { writeBaseObject(out); out.writeBoolean(defaultAutoCommit); } private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { readBaseObject(in); defaultAutoCommit = in.readBoolean(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/ds/PGPooledConnection.java 0100664 0000000 0000000 00000036262 00000250600 026612 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group. * See the LICENSE file in the project root for more information. */ package org.postgresql.ds; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.PGConnection; import org.postgresql.PGStatement; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; import java.sql.Statement; import java.util.ArrayList; import java.util.List; import javax.sql.ConnectionEvent; import javax.sql.ConnectionEventListener; import javax.sql.PooledConnection; import javax.sql.StatementEventListener; /** * PostgreSQL implementation of the PooledConnection interface. This shouldn't be used directly, as * the pooling client should just interact with the ConnectionPool instead. * * @author Aaron Mulder (ammulder@chariotsolutions.com) * @author Csaba Nagy (ncsaba@yahoo.com) * @see org.postgresql.ds.PGConnectionPoolDataSource */ public class PGPooledConnection implements PooledConnection { private final List* According to the JDBC 2.0 Optional Package spec (6.2.3), only one client may have an active * handle to the connection at a time, so if there is a previous handle active when this is * called, the previous one is forcibly closed and its work rolled back. *
*/ @Override public Connection getConnection() throws SQLException { Connection con = this.con; if (con == null) { // Before throwing the exception, let's notify the registered listeners about the error PSQLException sqlException = new PSQLException(GT.tr("This PooledConnection has already been closed."), PSQLState.CONNECTION_DOES_NOT_EXIST); fireConnectionFatalError(sqlException); throw sqlException; } // If any error occurs while opening a new connection, the listeners // have to be notified. This gives a chance to connection pools to // eliminate bad pooled connections. try { // Only one connection can be open at a time from this PooledConnection. See JDBC 2.0 Optional // Package spec section 6.2.3 ConnectionHandler last = this.last; if (last != null) { last.close(); if (con != null) { if (!con.getAutoCommit()) { try { con.rollback(); } catch (SQLException ignored) { // TODO: should we rethrow it? } } con.clearWarnings(); } } /* * In XA-mode, autocommit is handled in PGXAConnection, because it depends on whether an * XA-transaction is open or not */ if (!isXA && con != null) { con.setAutoCommit(autoCommit); } } catch (SQLException sqlException) { fireConnectionFatalError(sqlException); throw (SQLException) sqlException.fillInStackTrace(); } ConnectionHandler handler = new ConnectionHandler(castNonNull(con)); last = handler; Connection proxyCon = (Connection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Connection.class, PGConnection.class}, handler); handler.setProxy(proxyCon); return proxyCon; } /** * Used to fire a connection closed event to all listeners. */ void fireConnectionClosed() { ConnectionEvent evt = null; // Copy the listener list so the listener can remove itself during this method call ConnectionEventListener[] local = listeners.toArray(new ConnectionEventListener[0]); for (ConnectionEventListener listener : local) { if (evt == null) { evt = createConnectionEvent(null); } listener.connectionClosed(evt); } } /** * Used to fire a connection error event to all listeners. */ void fireConnectionFatalError(SQLException e) { ConnectionEvent evt = null; // Copy the listener list so the listener can remove itself during this method call ConnectionEventListener[] local = listeners.toArray(new ConnectionEventListener[0]); for (ConnectionEventListener listener : local) { if (evt == null) { evt = createConnectionEvent(e); } listener.connectionErrorOccurred(evt); } } protected ConnectionEvent createConnectionEvent(/* @Nullable */ SQLException e) { return e == null ? new ConnectionEvent(this) : new ConnectionEvent(this, e); } // Classes we consider fatal. private static final String[] fatalClasses = { "08", // connection error "53", // insufficient resources // nb: not just "57" as that includes query cancel which is nonfatal "57P01", // admin shutdown "57P02", // crash shutdown "57P03", // cannot connect now "58", // system error (backend) "60", // system error (driver) "99", // unexpected error "F0", // configuration file error (backend) "XX", // internal error (backend) }; private static boolean isFatalState(/* @Nullable */ String state) { if (state == null) { // no info, assume fatal return true; } if (state.length() < 2) { // no class info, assume fatal return true; } for (String fatalClass : fatalClasses) { if (state.startsWith(fatalClass)) { return true; // fatal } } return false; } /** * Fires a connection error event, but only if we think the exception is fatal. * * @param e the SQLException to consider */ private void fireConnectionError(SQLException e) { if (!isFatalState(e.getSQLState())) { return; } fireConnectionFatalError(e); } /** * Instead of declaring a class implementing Connection, which would have to be updated for every * JDK rev, use a dynamic proxy to handle all calls through the Connection interface. This is the * part that requires JDK 1.3 or higher, though JDK 1.2 could be supported with a 3rd-party proxy * package. */ private class ConnectionHandler implements InvocationHandler { private /* @Nullable */ Connection con; private /* @Nullable */ Connection proxy; // the Connection the client is currently using, which is a proxy private boolean automatic; ConnectionHandler(Connection con) { this.con = con; } @Override @SuppressWarnings("throwing.nullable") public /* @Nullable */ Object invoke(Object proxy, Method method, /* @Nullable */ Object[] args) throws Throwable { final String methodName = method.getName(); // From Object if (method.getDeclaringClass() == Object.class) { if ("toString".equals(methodName)) { return "Pooled connection wrapping physical connection " + con; } if ("equals".equals(methodName)) { return proxy == args[0]; } if ("hashCode".equals(methodName)) { return System.identityHashCode(proxy); } try { return method.invoke(con, args); } catch (InvocationTargetException e) { // throwing.nullable throw e.getTargetException(); } } // All the rest is from the Connection or PGConnection interface Connection con = this.con; if ("isClosed".equals(methodName)) { return con == null || con.isClosed(); } if ("close".equals(methodName)) { // we are already closed and a double close // is not an error. if (con == null) { return null; } SQLException ex = null; if (!con.isClosed()) { if (!isXA && !con.getAutoCommit()) { try { con.rollback(); } catch (SQLException e) { ex = e; } } con.clearWarnings(); } this.con = null; this.proxy = null; last = null; fireConnectionClosed(); if (ex != null) { throw ex; } return null; } if (con == null || con.isClosed()) { throw new PSQLException(automatic ? GT.tr( "Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed.") : GT.tr("Connection has been closed."), PSQLState.CONNECTION_DOES_NOT_EXIST); } // From here on in, we invoke via reflection, catch exceptions, // and check if they're fatal before rethrowing. try { if ("createStatement".equals(methodName)) { Statement st = castNonNull((Statement) method.invoke(con, args)); return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Statement.class, PGStatement.class}, new StatementHandler(this, st)); } else if ("prepareCall".equals(methodName)) { Statement st = castNonNull((Statement) method.invoke(con, args)); return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{CallableStatement.class, PGStatement.class}, new StatementHandler(this, st)); } else if ("prepareStatement".equals(methodName)) { Statement st = castNonNull((Statement) method.invoke(con, args)); return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{PreparedStatement.class, PGStatement.class}, new StatementHandler(this, st)); } else { return method.invoke(con, args); } } catch (final InvocationTargetException ite) { final Throwable te = ite.getTargetException(); if (te instanceof SQLException) { fireConnectionError((SQLException) te); // Tell listeners about exception if it's fatal } throw te; } } Connection getProxy() { return castNonNull(proxy); } void setProxy(Connection proxy) { this.proxy = proxy; } public void close() { if (con != null) { automatic = true; } con = null; proxy = null; // No close event fired here: see JDBC 2.0 Optional Package spec section 6.3 } @SuppressWarnings("UnusedMethod") public boolean isClosed() { return con == null; } } /** * Instead of declaring classes implementing Statement, PreparedStatement, and CallableStatement, * which would have to be updated for every JDK rev, use a dynamic proxy to handle all calls * through the Statement interfaces. This is the part that requires JDK 1.3 or higher, though JDK * 1.2 could be supported with a 3rd-party proxy package. * *The StatementHandler is required in order to return the proper Connection proxy for the * getConnection method.
*/ private class StatementHandler implements InvocationHandler { private /* @Nullable */ ConnectionHandler con; private /* @Nullable */ Statement st; StatementHandler(ConnectionHandler con, Statement st) { this.con = con; this.st = st; } @Override @SuppressWarnings("throwing.nullable") public /* @Nullable */ Object invoke(Object proxy, Method method, /* @Nullable */ Object[] args) throws Throwable { final String methodName = method.getName(); // From Object if (method.getDeclaringClass() == Object.class) { if ("toString".equals(methodName)) { return "Pooled statement wrapping physical statement " + st; } if ("hashCode".equals(methodName)) { return System.identityHashCode(proxy); } if ("equals".equals(methodName)) { return proxy == args[0]; } return method.invoke(st, args); } Statement st = this.st; // All the rest is from the Statement interface if ("isClosed".equals(methodName)) { return st == null || st.isClosed(); } if ("close".equals(methodName)) { if (st == null || st.isClosed()) { return null; } con = null; this.st = null; st.close(); return null; } if (st == null || st.isClosed()) { throw new PSQLException(GT.tr("Statement has been closed."), PSQLState.OBJECT_NOT_IN_STATE); } if ("getConnection".equals(methodName)) { return castNonNull(con).getProxy(); // the proxied connection, not a physical connection } // Delegate the call to the proxied Statement. try { return method.invoke(st, args); } catch (final InvocationTargetException ite) { final Throwable te = ite.getTargetException(); if (te instanceof SQLException) { fireConnectionError((SQLException) te); // Tell listeners about exception if it's fatal } throw te; } } } @Override public void removeStatementEventListener(StatementEventListener listener) { } @Override public void addStatementEventListener(StatementEventListener listener) { } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/ds/PGPoolingDataSource.java 0100664 0000000 0000000 00000042002 00000250600 026717 0 ustar 00 0000000 0000000 /* * Copyright (c) 2004, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.ds; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.ds.common.BaseDataSource; import org.postgresql.jdbc.ResourceLock; import org.postgresql.util.DriverInfo; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayDeque; import java.util.Deque; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import javax.naming.NamingException; import javax.naming.Reference; import javax.naming.StringRefAddr; import javax.sql.ConnectionEvent; import javax.sql.ConnectionEventListener; import javax.sql.DataSource; import javax.sql.PooledConnection; /** * DataSource which uses connection pooling. Don't use this if your * server/middleware vendor provides a connection pooling implementation which interfaces with the * PostgreSQL ConnectionPoolDataSource implementation! This class is provided as a * convenience, but the JDBC Driver is really not supposed to handle the connection pooling * algorithm. Instead, the server or middleware product is supposed to handle the mechanics of * connection pooling, and use the PostgreSQL implementation of ConnectionPoolDataSource to provide * the connections to pool. * ** If you're sure you want to use this, then you must set the properties dataSourceName, * databaseName, user, and password (if required for the user). The settings for serverName, * portNumber, initialConnections, and maxConnections are optional. Note that only connections * for the default user will be pooled! Connections for other users will be normal non-pooled * connections, and will not count against the maximum pool size limit. *
* ** If you put this DataSource in JNDI, and access it from different JVMs (or otherwise load this * class from different ClassLoaders), you'll end up with one pool per ClassLoader or VM. This is * another area where a server-specific implementation may provide advanced features, such as using * a single pool across all VMs in a cluster. *
* ** This implementation supports JDK 1.5 and higher. *
* * @author Aaron Mulder (ammulder@chariotsolutions.com) * * @deprecated Since 42.0.0, instead of this class you should use a fully featured connection pool * like HikariCP, vibur-dbcp, commons-dbcp, c3p0, etc. */ @Deprecated public class PGPoolingDataSource extends BaseDataSource implements DataSource { protected static ConcurrentMapThis is a means of executing functions embedded in the backend from within a java application.
* *It is based around the file src/interfaces/libpq/fe-exec.c
*/ public class Fastpath { // Java passes oids around as longs, but in the backend // it's an unsigned int, so we use this to make the conversion // of long -> signed int which the backend interprets as unsigned. private static final long NUM_OIDS = 4294967296L; // 2^32 // This maps the functions names to their id's (possible unique just // to a connection). private final MapNote: the mapping for the procedure name to function id needs to exist, usually to an earlier * call to addfunction().
* *This is the preferred method to call, as function id's can/may change between versions of the * backend.
* *For an example of how this works, refer to org.postgresql.largeobject.LargeObject
* * @param name Function name * @param args FastpathArguments to pass to fastpath * @return null if no data, byte[] otherwise * @throws SQLException if name is unknown or if a database-access error occurs. * @see org.postgresql.largeobject.LargeObject */ public byte /* @Nullable */ [] fastpath(String name, FastpathArg[] args) throws SQLException { connection.getLogger().log(Level.FINEST, "Fastpath: calling {0}", name); return fastpath(getID(name), args); } /** * This convenience method assumes that the return value is an integer. * * @param name Function name * @param args Function arguments * @return integer result * @throws SQLException if a database-access error occurs or no result */ public int getInteger(String name, FastpathArg[] args) throws SQLException { byte[] returnValue = fastpath(name, args); if (returnValue == null) { throw new PSQLException( GT.tr("Fastpath call {0} - No result was returned and we expected an integer.", name), PSQLState.NO_DATA); } if (returnValue.length == 4) { return ByteConverter.int4(returnValue, 0); } else { throw new PSQLException(GT.tr( "Fastpath call {0} - No result was returned or wrong size while expecting an integer.", name), PSQLState.NO_DATA); } } /** * This convenience method assumes that the return value is a long (bigint). * * @param name Function name * @param args Function arguments * @return long result * @throws SQLException if a database-access error occurs or no result */ public long getLong(String name, FastpathArg[] args) throws SQLException { byte[] returnValue = fastpath(name, args); if (returnValue == null) { throw new PSQLException( GT.tr("Fastpath call {0} - No result was returned and we expected a long.", name), PSQLState.NO_DATA); } if (returnValue.length == 8) { return ByteConverter.int8(returnValue, 0); } else { throw new PSQLException( GT.tr("Fastpath call {0} - No result was returned or wrong size while expecting a long.", name), PSQLState.NO_DATA); } } /** * This convenience method assumes that the return value is an oid. * * @param name Function name * @param args Function arguments * @return oid of the given call * @throws SQLException if a database-access error occurs or no result */ public long getOID(String name, FastpathArg[] args) throws SQLException { long oid = getInteger(name, args); if (oid < 0) { oid += NUM_OIDS; } return oid; } /** * This convenience method assumes that the return value is not an Integer. * * @param name Function name * @param args Function arguments * @return byte[] array containing result * @throws SQLException if a database-access error occurs or no result */ public byte /* @Nullable */ [] getData(String name, FastpathArg[] args) throws SQLException { return fastpath(name, args); } /** * This adds a function to our lookup table. * *User code should use the addFunctions method, which is based upon a query, rather than hard * coding the oid. The oid for a function is not guaranteed to remain static, even on different * servers of the same version.
* * @param name Function name * @param fnid Function id */ public void addFunction(String name, int fnid) { func.put(name, fnid); } /** * This takes a ResultSet containing two columns. Column 1 contains the function name, Column 2 * the oid. * *It reads the entire ResultSet, loading the values into the function table.
* *REMEMBER to close() the resultset after calling this!!
* *Implementation note about function name lookups:
* *PostgreSQL stores the function id's and their corresponding names in the pg_proc table. To * speed things up locally, instead of querying each function from that table when required, a * HashMap is used. Also, only the function's required are entered into this table, keeping * connection times as fast as possible.
* *The org.postgresql.largeobject.LargeObject class performs a query upon it's startup, and passes * the returned ResultSet to the addFunctions() method here.
* *Once this has been done, the LargeObject api refers to the functions by name.
* *Don't think that manually converting them to the oid's will work. Ok, they will for now, but * they can change during development (there was some discussion about this for V7.0), so this is * implemented to prevent any unwarranted headaches in the future.
* * @param rs ResultSet * @throws SQLException if a database-access error occurs. * @see org.postgresql.largeobject.LargeObjectManager */ public void addFunctions(ResultSet rs) throws SQLException { while (rs.next()) { func.put(castNonNull(rs.getString(1)), rs.getInt(2)); } } /** * This returns the function id associated by its name. * *If addFunction() or addFunctions() have not been called for this name, then an SQLException is * thrown.
* * @param name Function name to lookup * @return Function ID for fastpath call * @throws SQLException is function is unknown. */ public int getID(String name) throws SQLException { Integer id = func.get(name); // may be we could add a lookup to the database here, and store the result // in our lookup table, throwing the exception if that fails. // We must, however, ensure that if we do, any existing ResultSet is // unaffected, otherwise we could break user code. // // so, until we know we can do this (needs testing, on the TODO list) // for now, we throw the exception and do no lookups. if (id == null) { throw new PSQLException(GT.tr("The fastpath function {0} is unknown.", name), PSQLState.UNEXPECTED_ERROR); } return id; } /** * Creates a FastpathArg with an oid parameter. This is here instead of a constructor of * FastpathArg because the constructor can't tell the difference between an long that's really * int8 and a long thats an oid. * * @param oid input oid * @return FastpathArg with an oid parameter */ public static FastpathArg createOIDArg(long oid) { if (oid > Integer.MAX_VALUE) { oid -= NUM_OIDS; } return new FastpathArg((int) oid); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/fastpath/FastpathArg.java 0100664 0000000 0000000 00000006421 00000250600 026523 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.fastpath; import org.postgresql.core.ParameterList; import org.postgresql.util.ByteStreamWriter; // import org.checkerframework.checker.nullness.qual.Nullable; import java.nio.charset.Charset; import java.sql.SQLException; // Not a very clean mapping to the new QueryExecutor/ParameterList // stuff, but it seems hard to support both v2 and v3 cleanly with // the same model while retaining API compatibility. So I've just // done it the ugly way.. /** * Each fastpath call requires an array of arguments, the number and type dependent on the function * being called. */ public class FastpathArg { /** * Encoded byte value of argument. */ private final byte /* @Nullable */ [] bytes; private final int bytesStart; private final int bytesLength; static class ByteStreamWriterFastpathArg extends FastpathArg { private final ByteStreamWriter writer; ByteStreamWriterFastpathArg(ByteStreamWriter writer) { super(null, 0, 0); this.writer = writer; } @Override void populateParameter(ParameterList params, int index) throws SQLException { params.setBytea(index, writer); } } /** * Constructs an argument that consists of an integer value. * * @param value int value to set */ public FastpathArg(int value) { bytes = new byte[4]; bytes[3] = (byte) (value); bytes[2] = (byte) (value >> 8); bytes[1] = (byte) (value >> 16); bytes[0] = (byte) (value >> 24); bytesStart = 0; bytesLength = 4; } /** * Constructs an argument that consists of an integer value. * * @param value int value to set */ public FastpathArg(long value) { bytes = new byte[8]; bytes[7] = (byte) (value); bytes[6] = (byte) (value >> 8); bytes[5] = (byte) (value >> 16); bytes[4] = (byte) (value >> 24); bytes[3] = (byte) (value >> 32); bytes[2] = (byte) (value >> 40); bytes[1] = (byte) (value >> 48); bytes[0] = (byte) (value >> 56); bytesStart = 0; bytesLength = 8; } /** * Constructs an argument that consists of an array of bytes. * * @param bytes array to store */ public FastpathArg(byte[] bytes) { this(bytes, 0, bytes.length); } /** * Constructs an argument that consists of part of a byte array. * * @param buf source array * @param off offset within array * @param len length of data to include */ public FastpathArg(byte /* @Nullable */ [] buf, int off, int len) { this.bytes = buf; this.bytesStart = off; this.bytesLength = len; } /** * Constructs an argument that consists of a String. * * @param s String to store */ public FastpathArg(String s) { // Default charset is for backward compatibility // It looks like we should use database connection encoding this(s.getBytes(Charset.defaultCharset())); } public static FastpathArg of(ByteStreamWriter writer) { return new ByteStreamWriterFastpathArg(writer); } void populateParameter(ParameterList params, int index) throws SQLException { if (bytes == null) { params.setNull(index, 0); } else { params.setBytea(index, bytes, bytesStart, bytesLength); } } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/ 0040775 0000000 0000000 00000000000 00000250600 023620 5 ustar 00 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGbox.java 0100664 0000000 0000000 00000012754 00000250600 025510 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.util.GT; import org.postgresql.util.PGBinaryObject; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This represents the box datatype within org.postgresql. */ public class PGbox extends PGobject implements PGBinaryObject, Serializable, Cloneable { /** * These are the two points. */ public PGpoint /* @Nullable */ [] point; /** * @param x1 first x coordinate * @param y1 first y coordinate * @param x2 second x coordinate * @param y2 second y coordinate */ public PGbox(double x1, double y1, double x2, double y2) { this(new PGpoint(x1, y1), new PGpoint(x2, y2)); } /** * @param p1 first point * @param p2 second point */ public PGbox(PGpoint p1, PGpoint p2) { this(); this.point = new PGpoint[]{p1, p2}; } /** * @param s Box definition in PostgreSQL syntax * @throws SQLException if definition is invalid */ @SuppressWarnings("method.invocation") public PGbox(String s) throws SQLException { this(); setValue(s); } /** * Required constructor. */ public PGbox() { type = "box"; } /** * This method sets the value of this object. It should be overridden, but still called by * subclasses. * * @param value a string representation of the value of the object * @throws SQLException thrown if value is invalid for this type */ @Override public void setValue(/* @Nullable */ String value) throws SQLException { if (value == null) { this.point = null; return; } PGtokenizer t = new PGtokenizer(value, ','); if (t.getSize() != 2) { throw new PSQLException( GT.tr("Conversion to type {0} failed: {1}.", type, value), PSQLState.DATA_TYPE_MISMATCH); } PGpoint[] point = this.point; if (point == null) { this.point = point = new PGpoint[2]; } point[0] = new PGpoint(t.getToken(0)); point[1] = new PGpoint(t.getToken(1)); } /** * @param b Definition of this point in PostgreSQL's binary syntax */ @Override public void setByteValue(byte[] b, int offset) { PGpoint[] point = this.point; if (point == null) { this.point = point = new PGpoint[2]; } point[0] = new PGpoint(); point[0].setByteValue(b, offset); point[1] = new PGpoint(); point[1].setByteValue(b, offset + point[0].lengthInBytes()); this.point = point; } /** * @param obj Object to compare with * @return true if the two boxes are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGbox) { PGbox p = (PGbox) obj; // Same points. PGpoint[] point = this.point; PGpoint[] pPoint = p.point; if (point == null) { return pPoint == null; } else if (pPoint == null) { return false; } if (pPoint[0].equals(point[0]) && pPoint[1].equals(point[1])) { return true; } // Points swapped. if (pPoint[0].equals(point[1]) && pPoint[1].equals(point[0])) { return true; } // Using the opposite two points of the box: // (x1,y1),(x2,y2) -> (x1,y2),(x2,y1) if (pPoint[0].x == point[0].x && pPoint[0].y == point[1].y && pPoint[1].x == point[1].x && pPoint[1].y == point[0].y) { return true; } // Using the opposite two points of the box, and the points are swapped // (x1,y1),(x2,y2) -> (x2,y1),(x1,y2) if (pPoint[0].x == point[1].x && pPoint[0].y == point[0].y && pPoint[1].x == point[0].x && pPoint[1].y == point[1].y) { return true; } } return false; } @Override public int hashCode() { // This relies on the behaviour of point's hashcode being an exclusive-OR of // its X and Y components; we end up with an exclusive-OR of the two X and // two Y components, which is equal whenever equals() would return true // since xor is commutative. PGpoint[] point = this.point; return point == null ? 0 : point[0].hashCode() ^ point[1].hashCode(); } @Override public Object clone() throws CloneNotSupportedException { PGbox newPGbox = (PGbox) super.clone(); if (newPGbox.point != null) { newPGbox.point = newPGbox.point.clone(); for (int i = 0; i < newPGbox.point.length; i++) { if (newPGbox.point[i] != null) { newPGbox.point[i] = (PGpoint) newPGbox.point[i].clone(); } } } return newPGbox; } /** * @return the PGbox in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { PGpoint[] point = this.point; return point == null ? null : point[0].toString() + "," + point[1].toString(); } @Override public int lengthInBytes() { PGpoint[] point = this.point; if (point == null) { return 0; } return point[0].lengthInBytes() + point[1].lengthInBytes(); } @Override public void toBytes(byte[] bytes, int offset) { PGpoint[] point = castNonNull(this.point); point[0].toBytes(bytes, offset); point[1].toBytes(bytes, offset + point[0].lengthInBytes()); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGcircle.java 0100664 0000000 0000000 00000006753 00000250600 026163 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.GT; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This represents org.postgresql's circle datatype, consisting of a point and a radius. */ public class PGcircle extends PGobject implements Serializable, Cloneable { /** * This is the center point. */ public /* @Nullable */ PGpoint center; /** * This is the radius. */ public double radius; /** * @param x coordinate of center * @param y coordinate of center * @param r radius of circle */ public PGcircle(double x, double y, double r) { this(new PGpoint(x, y), r); } /** * @param c PGpoint describing the circle's center * @param r radius of circle */ public PGcircle(PGpoint c, double r) { this(); this.center = c; this.radius = r; } /** * @param s definition of the circle in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @SuppressWarnings("method.invocation") public PGcircle(String s) throws SQLException { this(); setValue(s); } /** * This constructor is used by the driver. */ public PGcircle() { type = "circle"; } /** * @param s definition of the circle in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { if (s == null) { center = null; return; } PGtokenizer t = new PGtokenizer(PGtokenizer.removeAngle(s), ','); if (t.getSize() != 2) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH); } try { center = new PGpoint(t.getToken(0)); radius = Double.parseDouble(t.getToken(1)); } catch (NumberFormatException e) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH, e); } } /** * @param obj Object to compare with * @return true if the two circles are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGcircle) { PGcircle p = (PGcircle) obj; PGpoint center = this.center; PGpoint pCenter = p.center; if (center == null) { return pCenter == null; } else if (pCenter == null) { return false; } return p.radius == radius && equals(pCenter, center); } return false; } @Override public int hashCode() { if (center == null) { return 0; } long bits = Double.doubleToLongBits(radius); int v = (int) (bits ^ (bits >>> 32)); v = v * 31 + center.hashCode(); return v; } @Override public Object clone() throws CloneNotSupportedException { PGcircle newPGcircle = (PGcircle) super.clone(); if (newPGcircle.center != null) { newPGcircle.center = (PGpoint) newPGcircle.center.clone(); } return newPGcircle; } /** * @return the PGcircle in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { return center == null ? null : "<" + center + "," + radius + ">"; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGline.java 0100664 0000000 0000000 00000012365 00000250600 025645 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.GT; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This implements a line represented by the linear equation Ax + By + C = 0. **/ public class PGline extends PGobject implements Serializable, Cloneable { /** * Coefficient of x. */ public double a; /** * Coefficient of y. */ public double b; /** * Constant. */ public double c; private boolean isNull; /** * @param a coefficient of x * @param b coefficient of y * @param c constant */ public PGline(double a, double b, double c) { this(); this.a = a; this.b = b; this.c = c; } /** * @param x1 coordinate for first point on the line * @param y1 coordinate for first point on the line * @param x2 coordinate for second point on the line * @param y2 coordinate for second point on the line */ @SuppressWarnings("method.invocation") public PGline(double x1, double y1, double x2, double y2) { this(); setValue(x1, y1, x2, y2); } /** * @param p1 first point on the line * @param p2 second point on the line */ @SuppressWarnings("method.invocation") public PGline(/* @Nullable */ PGpoint p1, /* @Nullable */ PGpoint p2) { this(); setValue(p1, p2); } /** * @param lseg Line segment which calls on this line. */ @SuppressWarnings("method.invocation") public PGline(/* @Nullable */ PGlseg lseg) { this(); if (lseg == null) { isNull = true; return; } PGpoint[] point = lseg.point; if (point == null) { isNull = true; return; } setValue(point[0], point[1]); } private void setValue(/* @Nullable */ PGpoint p1, /* @Nullable */ PGpoint p2) { if (p1 == null || p2 == null) { isNull = true; } else { setValue(p1.x, p1.y, p2.x, p2.y); } } private void setValue(double x1, double y1, double x2, double y2) { if (x1 == x2) { a = -1; b = 0; } else { a = (y2 - y1) / (x2 - x1); b = -1; } c = y1 - a * x1; } /** * @param s definition of the line in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @SuppressWarnings("method.invocation") public PGline(String s) throws SQLException { this(); setValue(s); } /** * required by the driver. */ public PGline() { type = "line"; } /** * @param s Definition of the line in PostgreSQL's syntax * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { isNull = s == null; if (s == null) { return; } if (s.trim().startsWith("{")) { PGtokenizer t = new PGtokenizer(PGtokenizer.removeCurlyBrace(s), ','); if (t.getSize() != 3) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH); } a = Double.parseDouble(t.getToken(0)); b = Double.parseDouble(t.getToken(1)); c = Double.parseDouble(t.getToken(2)); } else if (s.trim().startsWith("[")) { PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s), ','); if (t.getSize() != 2) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH); } PGpoint point1 = new PGpoint(t.getToken(0)); PGpoint point2 = new PGpoint(t.getToken(1)); a = point2.x - point1.x; b = point2.y - point1.y; c = point1.y; } } /** * @param obj Object to compare with * @return true if the two lines are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } if (!super.equals(obj)) { return false; } PGline pGline = (PGline) obj; if (isNull) { return pGline.isNull; } else if (pGline.isNull) { return false; } return Double.compare(pGline.a, a) == 0 && Double.compare(pGline.b, b) == 0 && Double.compare(pGline.c, c) == 0; } @Override public int hashCode() { if (isNull) { return 0; } int result = super.hashCode(); long temp; temp = Double.doubleToLongBits(a); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(b); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c); result = 31 * result + (int) (temp ^ (temp >>> 32)); return result; } /** * @return the PGline in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { return isNull ? null : "{" + a + "," + b + "," + c + "}"; } @Override public Object clone() throws CloneNotSupportedException { // squid:S2157 "Cloneables" should implement "clone return super.clone(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGlseg.java 0100664 0000000 0000000 00000007173 00000250600 025651 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.GT; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This implements a lseg (line segment) consisting of two points. */ public class PGlseg extends PGobject implements Serializable, Cloneable { /** * These are the two points. */ public PGpoint /* @Nullable */ [] point; /** * @param x1 coordinate for first point * @param y1 coordinate for first point * @param x2 coordinate for second point * @param y2 coordinate for second point */ public PGlseg(double x1, double y1, double x2, double y2) { this(new PGpoint(x1, y1), new PGpoint(x2, y2)); } /** * @param p1 first point * @param p2 second point */ public PGlseg(PGpoint p1, PGpoint p2) { this(); point = new PGpoint[]{p1, p2}; } /** * @param s definition of the line segment in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @SuppressWarnings("method.invocation") public PGlseg(String s) throws SQLException { this(); setValue(s); } /** * required by the driver. */ public PGlseg() { type = "lseg"; } /** * @param s Definition of the line segment in PostgreSQL's syntax * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { if (s == null) { point = null; return; } PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s), ','); if (t.getSize() != 2) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH); } PGpoint[] point = this.point; if (point == null) { this.point = point = new PGpoint[2]; } point[0] = new PGpoint(t.getToken(0)); point[1] = new PGpoint(t.getToken(1)); } /** * @param obj Object to compare with * @return true if the two line segments are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGlseg) { PGlseg p = (PGlseg) obj; PGpoint[] point = this.point; PGpoint[] pPoint = p.point; if (point == null) { return pPoint == null; } else if (pPoint == null) { return false; } return (pPoint[0].equals(point[0]) && pPoint[1].equals(point[1])) || (pPoint[0].equals(point[1]) && pPoint[1].equals(point[0])); } return false; } @Override public int hashCode() { PGpoint[] point = this.point; if (point == null) { return 0; } return point[0].hashCode() ^ point[1].hashCode(); } @Override public Object clone() throws CloneNotSupportedException { PGlseg newPGlseg = (PGlseg) super.clone(); if (newPGlseg.point != null) { newPGlseg.point = (PGpoint[]) newPGlseg.point.clone(); for (int i = 0; i < newPGlseg.point.length; i++) { if (newPGlseg.point[i] != null) { newPGlseg.point[i] = (PGpoint) newPGlseg.point[i].clone(); } } } return newPGlseg; } /** * @return the PGlseg in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { PGpoint[] point = this.point; if (point == null) { return null; } return "[" + point[0] + "," + point[1] + "]"; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGpath.java 0100664 0000000 0000000 00000010704 00000250600 025645 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.GT; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This implements a path (a multiple segmented line, which may be closed). */ public class PGpath extends PGobject implements Serializable, Cloneable { /** * True if the path is open, false if closed. */ public boolean open; /** * The points defining this path. */ public PGpoint /* @Nullable */ [] points; /** * @param points the PGpoints that define the path * @param open True if the path is open, false if closed */ public PGpath(PGpoint /* @Nullable */ [] points, boolean open) { this(); this.points = points; this.open = open; } /** * Required by the driver. */ public PGpath() { type = "path"; } /** * @param s definition of the path in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @SuppressWarnings("method.invocation") public PGpath(String s) throws SQLException { this(); setValue(s); } /** * @param s Definition of the path in PostgreSQL's syntax * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { if (s == null) { points = null; return; } // First test to see if were open if (s.startsWith("[") && s.endsWith("]")) { open = true; s = PGtokenizer.removeBox(s); } else if (s.startsWith("(") && s.endsWith(")")) { open = false; s = PGtokenizer.removePara(s); } else { throw new PSQLException(GT.tr("Cannot tell if path is open or closed: {0}.", s), PSQLState.DATA_TYPE_MISMATCH); } PGtokenizer t = new PGtokenizer(s, ','); int npoints = t.getSize(); PGpoint[] points = new PGpoint[npoints]; this.points = points; for (int p = 0; p < npoints; p++) { points[p] = new PGpoint(t.getToken(p)); } } /** * @param obj Object to compare with * @return true if the two paths are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGpath) { PGpath p = (PGpath) obj; PGpoint[] points = this.points; PGpoint[] pPoints = p.points; if (points == null) { return pPoints == null; } else if (pPoints == null) { return false; } if (p.open != open) { return false; } if (pPoints.length != points.length) { return false; } for (int i = 0; i < points.length; i++) { if (!points[i].equals(pPoints[i])) { return false; } } return true; } return false; } @Override public int hashCode() { PGpoint[] points = this.points; if (points == null) { return 0; } // XXX not very good.. int hash = open ? 1231 : 1237; for (int i = 0; i < points.length && i < 5; i++) { hash = hash * 31 + points[i].hashCode(); } return hash; } @Override public Object clone() throws CloneNotSupportedException { PGpath newPGpath = (PGpath) super.clone(); if (newPGpath.points != null) { PGpoint[] newPoints = newPGpath.points.clone(); newPGpath.points = newPoints; for (int i = 0; i < newPGpath.points.length; i++) { newPoints[i] = (PGpoint) newPGpath.points[i].clone(); } } return newPGpath; } /** * This returns the path in the syntax expected by org.postgresql. * @return the value of this object */ @Override public /* @Nullable */ String getValue() { PGpoint[] points = this.points; if (points == null) { return null; } StringBuilder b = new StringBuilder(open ? "[" : "("); for (int p = 0; p < points.length; p++) { if (p > 0) { b.append(","); } b.append(points[p].toString()); } b.append(open ? "]" : ")"); return b.toString(); } public boolean isOpen() { return open && points != null; } public boolean isClosed() { return !open && points != null; } public void closePath() { open = false; } public void openPath() { open = true; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGpoint.java 0100664 0000000 0000000 00000012612 00000250600 026042 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.ByteConverter; import org.postgresql.util.GT; import org.postgresql.util.PGBinaryObject; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; // import org.checkerframework.checker.nullness.qual.Nullable; import java.awt.Point; import java.io.Serializable; import java.sql.SQLException; /** * It maps to the point datatype in org.postgresql. * *This implements a version of java.awt.Point, except it uses double to represent the coordinates.
*/ public class PGpoint extends PGobject implements PGBinaryObject, Serializable, Cloneable { /** * The X coordinate of the point. */ public double x; /** * The Y coordinate of the point. */ public double y; /** * True if the point represents {@code null::point}. */ public boolean isNull; /** * @param x coordinate * @param y coordinate */ public PGpoint(double x, double y) { this(); this.x = x; this.y = y; } /** * This is called mainly from the other geometric types, when a point is embedded within their * definition. * * @param value Definition of this point in PostgreSQL's syntax * @throws SQLException if something goes wrong */ @SuppressWarnings("method.invocation") public PGpoint(String value) throws SQLException { this(); setValue(value); } /** * Required by the driver. */ public PGpoint() { type = "point"; } /** * @param s Definition of this point in PostgreSQL's syntax * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { isNull = s == null; if (s == null) { return; } PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s), ','); try { x = Double.parseDouble(t.getToken(0)); y = Double.parseDouble(t.getToken(1)); } catch (NumberFormatException e) { throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", type, s), PSQLState.DATA_TYPE_MISMATCH, e); } } /** * @param b Definition of this point in PostgreSQL's binary syntax */ @Override public void setByteValue(byte[] b, int offset) { this.isNull = false; x = ByteConverter.float8(b, offset); y = ByteConverter.float8(b, offset + 8); } /** * @param obj Object to compare with * @return true if the two points are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGpoint) { PGpoint p = (PGpoint) obj; if (isNull) { return p.isNull; } else if (p.isNull) { return false; } return x == p.x && y == p.y; } return false; } @Override public int hashCode() { if (isNull) { return 0; } long v1 = Double.doubleToLongBits(x); long v2 = Double.doubleToLongBits(y); return (int) (v1 ^ v2 ^ (v1 >>> 32) ^ (v2 >>> 32)); } /** * @return the PGpoint in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { return isNull ? null : "(" + x + "," + y + ")"; } @Override public int lengthInBytes() { return isNull ? 0 : 16; } /** * Populate the byte array with PGpoint in the binary syntax expected by org.postgresql. */ @Override public void toBytes(byte[] b, int offset) { if (isNull) { return; } ByteConverter.float8(b, offset, x); ByteConverter.float8(b, offset + 8, y); } /** * Translate the point by the supplied amount. * * @param x integer amount to add on the x axis * @param y integer amount to add on the y axis */ public void translate(int x, int y) { translate((double) x, (double) y); } /** * Translate the point by the supplied amount. * * @param x double amount to add on the x axis * @param y double amount to add on the y axis */ public void translate(double x, double y) { this.isNull = false; this.x += x; this.y += y; } /** * Moves the point to the supplied coordinates. * * @param x integer coordinate * @param y integer coordinate */ public void move(int x, int y) { setLocation(x, y); } /** * Moves the point to the supplied coordinates. * * @param x double coordinate * @param y double coordinate */ public void move(double x, double y) { this.isNull = false; this.x = x; this.y = y; } /** * Moves the point to the supplied coordinates. refer to java.awt.Point for description of this. * * @param x integer coordinate * @param y integer coordinate * @see java.awt.Point */ public void setLocation(int x, int y) { move((double) x, (double) y); } /** * Moves the point to the supplied java.awt.Point refer to java.awt.Point for description of this. * * @param p Point to move to * @see java.awt.Point * * @deprecated Will be removed for avoiding a dependency to the {@code java.desktop} module. */ @Deprecated public void setLocation(Point p) { setLocation(p.x, p.y); } @Override public Object clone() throws CloneNotSupportedException { // squid:S2157 "Cloneables" should implement "clone return super.clone(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/geometric/PGpolygon.java 0100664 0000000 0000000 00000007173 00000250600 026406 0 ustar 00 0000000 0000000 /* * Copyright (c) 2003, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.geometric; import org.postgresql.util.PGobject; import org.postgresql.util.PGtokenizer; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.Serializable; import java.sql.SQLException; /** * This implements the polygon datatype within PostgreSQL. */ public class PGpolygon extends PGobject implements Serializable, Cloneable { /** * The points defining the polygon. */ public PGpoint /* @Nullable */ [] points; /** * Creates a polygon using an array of PGpoints. * * @param points the points defining the polygon */ public PGpolygon(PGpoint[] points) { this(); this.points = points; } /** * @param s definition of the polygon in PostgreSQL's syntax. * @throws SQLException on conversion failure */ @SuppressWarnings("method.invocation") public PGpolygon(String s) throws SQLException { this(); setValue(s); } /** * Required by the driver. */ public PGpolygon() { type = "polygon"; } /** * @param s Definition of the polygon in PostgreSQL's syntax * @throws SQLException on conversion failure */ @Override public void setValue(/* @Nullable */ String s) throws SQLException { if (s == null) { points = null; return; } PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s), ','); int npoints = t.getSize(); PGpoint[] points = this.points; if (points == null || points.length != npoints) { this.points = points = new PGpoint[npoints]; } for (int p = 0; p < npoints; p++) { points[p] = new PGpoint(t.getToken(p)); } } /** * @param obj Object to compare with * @return true if the two polygons are identical */ @Override public boolean equals(/* @Nullable */ Object obj) { if (obj instanceof PGpolygon) { PGpolygon p = (PGpolygon) obj; PGpoint[] points = this.points; PGpoint[] pPoints = p.points; if (points == null) { return pPoints == null; } else if (pPoints == null) { return false; } if (pPoints.length != points.length) { return false; } for (int i = 0; i < points.length; i++) { if (!points[i].equals(pPoints[i])) { return false; } } return true; } return false; } @Override public int hashCode() { int hash = 0; PGpoint[] points = this.points; if (points == null) { return hash; } for (int i = 0; i < points.length && i < 5; i++) { hash = hash * 31 + points[i].hashCode(); } return hash; } @Override public Object clone() throws CloneNotSupportedException { PGpolygon newPGpolygon = (PGpolygon) super.clone(); if (newPGpolygon.points != null) { PGpoint[] newPoints = newPGpolygon.points.clone(); newPGpolygon.points = newPoints; for (int i = 0; i < newPGpolygon.points.length; i++) { if (newPGpolygon.points[i] != null) { newPoints[i] = (PGpoint) newPGpolygon.points[i].clone(); } } } return newPGpolygon; } /** * @return the PGpolygon in the syntax expected by org.postgresql */ @Override public /* @Nullable */ String getValue() { PGpoint[] points = this.points; if (points == null) { return null; } StringBuilder b = new StringBuilder(); b.append("("); for (int p = 0; p < points.length; p++) { if (p > 0) { b.append(","); } b.append(points[p].toString()); } b.append(")"); return b.toString(); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/gss/ 0040775 0000000 0000000 00000000000 00000250600 022436 5 ustar 00 0000000 0000000 postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/gss/GSSCallbackHandler.java 0100664 0000000 0000000 00000004270 00000250600 026650 0 ustar 00 0000000 0000000 /* * Copyright (c) 2008, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.gss; // import org.checkerframework.checker.nullness.qual.Nullable; import java.io.IOException; import javax.security.auth.callback.Callback; import javax.security.auth.callback.CallbackHandler; import javax.security.auth.callback.NameCallback; import javax.security.auth.callback.PasswordCallback; import javax.security.auth.callback.TextOutputCallback; import javax.security.auth.callback.UnsupportedCallbackException; /* provide a more or less redundant callback handler */ class GSSCallbackHandler implements CallbackHandler { private final String user; private final char /* @Nullable */ [] password; GSSCallbackHandler(String user, char /* @Nullable */ [] password) { this.user = user; this.password = password; } @Override public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException { for (Callback callback : callbacks) { if (callback instanceof TextOutputCallback) { TextOutputCallback toc = (TextOutputCallback) callback; switch (toc.getMessageType()) { case TextOutputCallback.INFORMATION: System.out.println("INFO: " + toc.getMessage()); break; case TextOutputCallback.ERROR: System.out.println("ERROR: " + toc.getMessage()); break; case TextOutputCallback.WARNING: System.out.println("WARNING: " + toc.getMessage()); break; default: throw new IOException("Unsupported message type: " + toc.getMessageType()); } } else if (callback instanceof NameCallback) { NameCallback nc = (NameCallback) callback; nc.setName(user); } else if (callback instanceof PasswordCallback) { PasswordCallback pc = (PasswordCallback) callback; if (password == null) { throw new IOException("No cached kerberos ticket found and no password supplied."); } pc.setPassword(password); } else { throw new UnsupportedCallbackException(callback, "Unrecognized Callback"); } } } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/gss/GSSInputStream.java 0100664 0000000 0000000 00000011445 00000250600 026133 0 ustar 00 0000000 0000000 /* * Copyright (c) 2008, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.gss; import static org.postgresql.util.internal.Nullness.castNonNull; import org.postgresql.util.ByteConverter; // import org.checkerframework.checker.nullness.qual.Nullable; import org.ietf.jgss.GSSContext; import org.ietf.jgss.GSSException; import org.ietf.jgss.MessageProp; import java.io.IOException; import java.io.InputStream; public class GSSInputStream extends InputStream { private final GSSContext gssContext; private final MessageProp messageProp; private final InputStream wrapped; // See https://www.postgresql.org/docs/current/protocol-flow.html#PROTOCOL-FLOW-GSSAPI // The server can be expected to not send encrypted packets of larger than 16kB to the client private byte[] encrypted = new byte[16 * 1024]; private int encryptedPos; private int encryptedLength; private byte /* @Nullable */ [] unencrypted; private int unencryptedPos; private final byte[] int4Buf = new byte[4]; private int lenPos; private final byte[] int1Buf = new byte[1]; public GSSInputStream(InputStream wrapped, GSSContext gssContext, MessageProp messageProp) { this.wrapped = wrapped; this.gssContext = gssContext; this.messageProp = messageProp; } @Override public int read() throws IOException { int res = 0; while (res == 0) { res = read(int1Buf); } return res == -1 ? -1 : int1Buf[0] & 0xFF; } @Override public int read(byte[] buffer, int pos, int len) throws IOException { int n = 0; // Server makes 16KiB frames, so we attempt several reads from the underlying stream // so we don't have to store the unencrypted buffer across GSSInputStream.read calls while (true) { // 1. Reading length from the wrapped stream if (lenPos < 4) { int res = readLength(); if (res <= 0) { // Did not read "message length" fully, so we can't read encrypted message yet return n == 0 ? res : n; } } // 2. Reading encrypted message from the wrapped stream if (encryptedPos < encryptedLength) { int res = readEncryptedBytesAndUnwrap(); if (res <= 0) { // Did not read encrypted message fully, so we can't deliver decrypted data yet return n == 0 ? res : n; } } // 3. Reading unencrypted message into the user-provided buffer byte[] unencrypted = castNonNull(this.unencrypted); int copyLength = Math.min(len - n, unencrypted.length - unencryptedPos); System.arraycopy(unencrypted, unencryptedPos, buffer, pos + n, copyLength); unencryptedPos += copyLength; n += copyLength; if (unencryptedPos == unencrypted.length) { // Start reading the new message on the next read lenPos = 0; encryptedPos = 0; this.unencrypted = null; } if (n >= len || wrapped.available() <= 0) { return n; } } } /** * Reads the length of the wrapper message. * * @return -1 of end of stream reached, 0 if length is not fully read yet, and 1 if length is * fully read * @throws IOException if read fails */ private int readLength() throws IOException { while (true) { int res = wrapped.read(int4Buf, lenPos, 4 - lenPos); if (res == -1) { return -1; } lenPos += res; if (lenPos == 4) { break; } if (wrapped.available() <= 0) { // Did not read "message length" fully, and there's no more bytes available, so stop trying return 0; } } encryptedLength = ByteConverter.int4(int4Buf, 0); if (encrypted.length < encryptedLength) { // If the buffer is too small, reallocate encrypted = new byte[encryptedLength]; } return 1; } /** * Reads the encrypted message, and unwraps it. * * @return -1 of end of stream reached, 0 if the message is not fully read yet, and 1 if length is * fully read * @throws IOException if read fails */ private int readEncryptedBytesAndUnwrap() throws IOException { while (true) { int res = wrapped.read(encrypted, encryptedPos, encryptedLength - encryptedPos); if (res == -1) { // Should we raise something like "incomplete GSS message due to end of input stream"? return -1; } encryptedPos += res; if (encryptedPos == encryptedLength) { break; } if (wrapped.available() <= 0) { // The encrypted message is not yet ready, so we can't read user data yet return 0; } } try { this.unencrypted = gssContext.unwrap(encrypted, 0, encryptedLength, messageProp); } catch (GSSException e) { throw new IOException(e); } unencryptedPos = 0; return 1; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/gss/GSSOutputStream.java 0100664 0000000 0000000 00000005117 00000250600 026333 0 ustar 00 0000000 0000000 /* * Copyright (c) 2020, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.gss; import org.postgresql.util.internal.PgBufferedOutputStream; import org.ietf.jgss.GSSContext; import org.ietf.jgss.GSSException; import org.ietf.jgss.MessageProp; import java.io.IOException; /** * Output stream that wraps each packed with GSS encryption. */ public class GSSOutputStream extends PgBufferedOutputStream { private final PgBufferedOutputStream pgOut; private final GSSContext gssContext; private final MessageProp messageProp; /** * Creates GSS output stream. * @param out output stream for the encrypted data * @param gssContext gss context * @param messageProp message properties * @param maxTokenSize maximum length of the encrypted messages */ public GSSOutputStream(PgBufferedOutputStream out, GSSContext gssContext, MessageProp messageProp, int maxTokenSize) throws GSSException { super(out, getBufferSize(gssContext, messageProp, maxTokenSize)); this.pgOut = out; this.gssContext = gssContext; this.messageProp = messageProp; } private static int getBufferSize(GSSContext gssContext, MessageProp messageProp, int maxTokenSize) throws GSSException { return gssContext.getWrapSizeLimit(messageProp.getQOP(), messageProp.getPrivacy(), maxTokenSize); } @Override protected void flushBuffer() throws IOException { if (count > 0) { writeWrapped(buf, 0, count); count = 0; } } private void writeWrapped(byte[] b, int off, int len) throws IOException { try { byte[] token = gssContext.wrap(b, off, len, messageProp); pgOut.writeInt4(token.length); pgOut.write(token, 0, token.length); } catch (GSSException ex) { throw new IOException(ex); } } @Override public void write(byte[] b, int off, int len) throws IOException { if (count > 0) { // If there's some data in the buffer, combine both int avail = buf.length - count; int prefixLength = Math.min(len, avail); System.arraycopy(b, off, buf, count, prefixLength); count += prefixLength; off += prefixLength; len -= prefixLength; if (count == buf.length) { flushBuffer(); } } // Write out the rest, chunk the writes, so we do not exceed the maximum encrypted message size while (len >= buf.length) { writeWrapped(b, off, buf.length); off += buf.length; len -= buf.length; } if (len == 0) { return; } System.arraycopy(b, off, buf, 0, len); count += len; } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/gss/GssAction.java 0100664 0000000 0000000 00000014364 00000250600 025200 0 ustar 00 0000000 0000000 /* * Copyright (c) 2008, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.gss; import org.postgresql.core.PGStream; import org.postgresql.core.PgMessageType; import org.postgresql.util.GT; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import org.postgresql.util.ServerErrorMessage; // import org.checkerframework.checker.nullness.qual.Nullable; import org.ietf.jgss.GSSContext; import org.ietf.jgss.GSSCredential; import org.ietf.jgss.GSSException; import org.ietf.jgss.GSSManager; import org.ietf.jgss.GSSName; import org.ietf.jgss.Oid; import java.io.IOException; import java.security.Principal; import java.security.PrivilegedAction; import java.util.Iterator; import java.util.Set; import java.util.concurrent.Callable; import java.util.logging.Level; import java.util.logging.Logger; import javax.security.auth.Subject; class GssAction implements PrivilegedAction, Callable { private static final Logger LOGGER = Logger.getLogger(GssAction.class.getName()); private final PGStream pgStream; private final String host; private final String kerberosServerName; private final String user; private final boolean useSpnego; private final boolean gssUseDefaultCreds; private final /* @Nullable */ Subject subject; private final boolean logServerErrorDetail; GssAction(PGStream pgStream, /* @Nullable */ Subject subject, String host, String user, String kerberosServerName, boolean useSpnego, boolean gssUseDefaultCreds, boolean logServerErrorDetail) { this.pgStream = pgStream; this.subject = subject; this.host = host; this.user = user; this.kerberosServerName = kerberosServerName; this.useSpnego = useSpnego; this.gssUseDefaultCreds = gssUseDefaultCreds; this.logServerErrorDetail = logServerErrorDetail; } private static boolean hasSpnegoSupport(GSSManager manager) throws GSSException { Oid spnego = new Oid("1.3.6.1.5.5.2"); Oid[] mechs = manager.getMechs(); for (Oid mech : mechs) { if (mech.equals(spnego)) { return true; } } return false; } @Override public /* @Nullable */ Exception run() { try { GSSManager manager = GSSManager.getInstance(); GSSCredential clientCreds = null; Oid[] desiredMechs = new Oid[1]; //Try to get credential from subject first. GSSCredential gssCredential = null; if (subject != null) { SetThe current policy is to keep accepting this silently but not document slave, or slave preferSlave
* *As of Jul 2018 silently deprecate the use of the word master as well
* * @param targetServerType the value of {@code targetServerType} connection property * @return HostRequirement */ public static HostRequirement getTargetServerType(String targetServerType) { String allowSlave = targetServerType.replace("lave", "econdary").replace("master", "primary"); return valueOf(allowSlave); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/hostchooser/HostStatus.java 0100664 0000000 0000000 00000000434 00000250600 027164 0 ustar 00 0000000 0000000 /* * Copyright (c) 2014, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.hostchooser; /** * Known state of a server. */ public enum HostStatus { ConnectFail, ConnectOK, Primary, Secondary } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/hostchooser/MultiHostChooser.java 0100664 0000000 0000000 00000010451 00000250600 030316 0 ustar 00 0000000 0000000 /* * Copyright (c) 2014, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.hostchooser; import static java.util.Collections.shuffle; import org.postgresql.PGProperty; import org.postgresql.util.HostSpec; import org.postgresql.util.PSQLException; import java.util.AbstractList; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.Properties; /** * HostChooser that keeps track of known host statuses. */ class MultiHostChooser implements HostChooser { private final HostSpec[] hostSpecs; private final HostRequirement targetServerType; private int hostRecheckTime; private boolean loadBalance; MultiHostChooser(HostSpec[] hostSpecs, HostRequirement targetServerType, Properties info) { this.hostSpecs = hostSpecs; this.targetServerType = targetServerType; try { hostRecheckTime = PGProperty.HOST_RECHECK_SECONDS.getInt(info) * 1000; loadBalance = PGProperty.LOAD_BALANCE_HOSTS.getBoolean(info); } catch (PSQLException e) { throw new RuntimeException(e); } } @Override public Iterator* See {@code ArrayEncoding} for description of the binary format of arrays. *
* * @author Brett Okken */ final class ArrayDecoding { /** * Array list implementation specific for storing PG array elements. If * {@link PgArrayList#dimensionsCount} is {@code 1}, the contents will be * {@link String}. For all larger dimensionsCount, the values will be * {@link PgArrayList} instances. */ static final class PgArrayList extends ArrayList { private static final long serialVersionUID = 1L; /** * How many dimensions. */ int dimensionsCount = 1; } private interface ArrayDecoder { A createArray(/* @NonNegative */ int size); Object[] createMultiDimensionalArray(/* @NonNegative */ int[] sizes); boolean supportBinary(); void populateFromBinary(A array, /* @NonNegative */ int index, /* @NonNegative */ int count, ByteBuffer bytes, BaseConnection connection) throws SQLException; void populateFromString(A array, List strings, BaseConnection connection) throws SQLException; } private abstract static class AbstractObjectStringArrayDecoder implements ArrayDecoder { final Class baseClazz; AbstractObjectStringArrayDecoder(Class baseClazz) { this.baseClazz = baseClazz; } /** * {@inheritDoc} */ @Override public boolean supportBinary() { return false; } @SuppressWarnings("unchecked") @Override public A createArray(int size) { return (A) Array.newInstance(baseClazz, size); } /** * {@inheritDoc} */ @Override public Object[] createMultiDimensionalArray(int[] sizes) { return (Object[]) Array.newInstance(baseClazz, sizes); } @Override public void populateFromBinary(A arr, int index, int count, ByteBuffer bytes, BaseConnection connection) throws SQLException { throw new SQLFeatureNotSupportedException(); } /** * {@inheritDoc} */ @Override public void populateFromString(A arr, List strings, BaseConnection connection) throws SQLException { final /* @Nullable */ Object[] array = (Object[]) arr; for (int i = 0, j = strings.size(); i < j; i++) { final String stringVal = strings.get(i); array[i] = stringVal != null ? parseValue(stringVal, connection) : null; } } abstract Object parseValue(String stringVal, BaseConnection connection) throws SQLException; } private abstract static class AbstractObjectArrayDecoder extends AbstractObjectStringArrayDecoder { AbstractObjectArrayDecoder(Class baseClazz) { super(baseClazz); } /** * {@inheritDoc} */ @Override public boolean supportBinary() { return true; } @Override public void populateFromBinary(A arr, /* @NonNegative */ int index, /* @NonNegative */ int count, ByteBuffer bytes, BaseConnection connection) throws SQLException { final /* @Nullable */ Object[] array = (Object[]) arr; // skip through to the requested index for (int i = 0; i < index; i++) { final int length = bytes.getInt(); if (length > 0) { bytes.position(bytes.position() + length); } } for (int i = 0; i < count; i++) { final int length = bytes.getInt(); if (length != -1) { array[i] = parseValue(length, bytes, connection); } else { // explicitly set to null for reader's clarity array[i] = null; } } } abstract Object parseValue(int length, ByteBuffer bytes, BaseConnection connection) throws SQLException; } private static final ArrayDecoder* Binary format: *
* Always returns {@code 0}. *
*/ @Override final int countNulls(A array) { return 0; } /** * {@inheritDoc} */ @Override public final byte[] toBinaryRepresentation(BaseConnection connection, A array, int oid) throws SQLException, SQLFeatureNotSupportedException { assert oid == arrayOid; final int arrayLength = Array.getLength(array); final int length = 20 + ((fieldSize + 4) * arrayLength); final byte[] bytes = new byte[length]; // 1 dimension ByteConverter.int4(bytes, 0, 1); // no null ByteConverter.int4(bytes, 4, 0); // oid ByteConverter.int4(bytes, 8, getTypeOID(oid)); // length ByteConverter.int4(bytes, 12, arrayLength); // postgresql uses 1 base by default ByteConverter.int4(bytes, 16, 1); write(array, bytes, 20); return bytes; } /** * {@inheritDoc} */ @Override final byte[] toSingleDimensionBinaryRepresentation(BaseConnection connection, A array) throws SQLException, SQLFeatureNotSupportedException { final int length = (fieldSize + 4) * Array.getLength(array); final byte[] bytes = new byte[length]; write(array, bytes, 0); return bytes; } /** * Write the entire contents of array to bytes starting at * offset without metadata describing type or length. * * @param array * The array to write. * @param bytes * The {@code byte[]} to write to. * @param offset * The offset into bytes to start writing. */ protected abstract void write(A array, byte[] bytes, int offset); } private static final AbstractArrayEncoderBased on values accepted by the PostgreSQL server: * https://www.postgresql.org/docs/current/static/datatype-boolean.html
*/ class BooleanTypeUtil { private static final Logger LOGGER = Logger.getLogger(BooleanTypeUtil.class.getName()); private BooleanTypeUtil() { } /** * Cast an Object value to the corresponding boolean value. * * @param in Object to cast into boolean * @return boolean value corresponding to the cast of the object * @throws PSQLException PSQLState.CANNOT_COERCE */ static boolean castToBoolean(final Object in) throws PSQLException { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.log(Level.FINE, "Cast to boolean: \"{0}\"", String.valueOf(in)); } if (in instanceof Boolean) { return (Boolean) in; } if (in instanceof String) { return fromString((String) in); } if (in instanceof Character) { return fromCharacter((Character) in); } if (in instanceof Number) { return fromNumber((Number) in); } throw new PSQLException("Cannot cast to boolean", PSQLState.CANNOT_COERCE); } static boolean fromString(final String strval) throws PSQLException { // Leading or trailing whitespace is ignored, and case does not matter. final String val = strval.trim(); if ("1".equals(val) || "true".equalsIgnoreCase(val) || "t".equalsIgnoreCase(val) || "yes".equalsIgnoreCase(val) || "y".equalsIgnoreCase(val) || "on".equalsIgnoreCase(val)) { return true; } if ("0".equals(val) || "false".equalsIgnoreCase(val) || "f".equalsIgnoreCase(val) || "no".equalsIgnoreCase(val) || "n".equalsIgnoreCase(val) || "off".equalsIgnoreCase(val)) { return false; } throw cannotCoerceException(strval); } private static boolean fromCharacter(final Character charval) throws PSQLException { if ('1' == charval || 't' == charval || 'T' == charval || 'y' == charval || 'Y' == charval) { return true; } if ('0' == charval || 'f' == charval || 'F' == charval || 'n' == charval || 'N' == charval) { return false; } throw cannotCoerceException(charval); } private static boolean fromNumber(final Number numval) throws PSQLException { // Handles BigDecimal, Byte, Short, Integer, Long Float, Double // based on the widening primitive conversions. final double value = numval.doubleValue(); if (value == 1.0d) { return true; } if (value == 0.0d) { return false; } throw cannotCoerceException(numval); } private static PSQLException cannotCoerceException(final Object value) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.log(Level.FINE, "Cannot cast to boolean: \"{0}\"", String.valueOf(value)); } return new PSQLException(GT.tr("Cannot cast to boolean: \"{0}\"", String.valueOf(value)), PSQLState.CANNOT_COERCE); } } postgresql-42.7.6-jdbc-src/src/main/java/org/postgresql/jdbc/CallableBatchResultHandler.java 0100664 0000000 0000000 00000001517 00000250600 030546 0 ustar 00 0000000 0000000 /* * Copyright (c) 2016, PostgreSQL Global Development Group * See the LICENSE file in the project root for more information. */ package org.postgresql.jdbc; import org.postgresql.core.Field; import org.postgresql.core.ParameterList; import org.postgresql.core.Query; import org.postgresql.core.ResultCursor; import org.postgresql.core.Tuple; // import org.checkerframework.checker.nullness.qual.Nullable; import java.util.List; class CallableBatchResultHandler extends BatchResultHandler { CallableBatchResultHandler(PgStatement statement, Query[] queries, /* @Nullable */ ParameterList[] parameterLists) { super(statement, queries, parameterLists, false); } @Override public void handleResultRows(Query fromQuery, Field[] fields, ListRead a field of type Array into either a natively-typed Java array object or a ResultSet. * Accessor methods provide the ability to capture array slices.
* *Other than the constructor all methods are direct implementations of those specified for * java.sql.Array. Please refer to the javadoc for java.sql.Array for detailed descriptions of the * functionality and parameters of the methods of this class.
* * @see ResultSet#getArray */ public class PgArray implements Array { static { ArrayAssistantRegistry.register(Oid.UUID, new UUIDArrayAssistant()); ArrayAssistantRegistry.register(Oid.UUID_ARRAY, new UUIDArrayAssistant()); } /** * A database connection. */ protected /* @Nullable */ BaseConnection connection; /** * The OID of this field. */ private final int oid; /** * Field value as String. */ protected /* @Nullable */ String fieldString; /** * Value of field as {@link PgArrayList}. Will be initialized only once within * {@link #buildArrayList(String)}. */ protected ArrayDecoding./* @Nullable */ PgArrayList arrayList; protected byte /* @Nullable */ [] fieldBytes; private final ResourceLock lock = new ResourceLock(); private PgArray(BaseConnection connection, int oid) throws SQLException { this.connection = connection; this.oid = oid; } /** * Create a new Array. * * @param connection a database connection * @param oid the oid of the array datatype * @param fieldString the array data in string form * @throws SQLException if something wrong happens */ public PgArray(BaseConnection connection, int oid, /* @Nullable */ String fieldString) throws SQLException { this(connection, oid); this.fieldString = fieldString; } /** * Create a new Array. * * @param connection a database connection * @param oid the oid of the array datatype * @param fieldBytes the array data in byte form * @throws SQLException if something wrong happens */ public PgArray(BaseConnection connection, int oid, byte /* @Nullable */ [] fieldBytes) throws SQLException { this(connection, oid); this.fieldBytes = fieldBytes; } private BaseConnection getConnection() { return castNonNull(connection); } @Override @SuppressWarnings("return") public Object getArray() throws SQLException { return getArrayImpl(1, 0, null); } @Override @SuppressWarnings("return") public Object getArray(long index, int count) throws SQLException { return getArrayImpl(index, count, null); } @SuppressWarnings("return") public Object getArrayImpl(MapBefore executing a stored procedure call you must explicitly call registerOutParameter to * register the java.sql.Type of each out parameter.
* *Note: When reading the value of an out parameter, you must use the getXXX method whose Java * type XXX corresponds to the parameter's registered SQL type.
* *ONLY 1 RETURN PARAMETER if {?= call ..} syntax is used
* * @param parameterIndex the first parameter is 1, the second is 2,... * @param sqlType SQL type code defined by java.sql.Types; for parameters of type Numeric or * Decimal use the version of registerOutParameter that accepts a scale value * @throws SQLException if a database-access error occurs. */ @Override public void registerOutParameter(/* @Positive */ int parameterIndex, int sqlType) throws SQLException { checkClosed(); switch (sqlType) { case Types.TINYINT: // we don't have a TINYINT type use SMALLINT sqlType = Types.SMALLINT; break; case Types.LONGVARCHAR: sqlType = Types.VARCHAR; break; case Types.DECIMAL: sqlType = Types.NUMERIC; break; case Types.FLOAT: // float is the same as double sqlType = Types.DOUBLE; break; case Types.VARBINARY: case Types.LONGVARBINARY: sqlType = Types.BINARY; break; case Types.BOOLEAN: sqlType = Types.BIT; break; default: break; } int[] functionReturnType = this.functionReturnType; int[] testReturn = this.testReturn; if (!isFunction || functionReturnType == null || testReturn == null) { throw new PSQLException( GT.tr( "This statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one."), PSQLState.STATEMENT_NOT_ALLOWED_IN_FUNCTION_CALL); } preparedParameters.registerOutParameter(parameterIndex, sqlType); // functionReturnType contains the user supplied value to check // testReturn contains a modified version to make it easier to // check the getXXX methods.. functionReturnType[parameterIndex - 1] = sqlType; testReturn[parameterIndex - 1] = sqlType; if (functionReturnType[parameterIndex - 1] == Types.CHAR || functionReturnType[parameterIndex - 1] == Types.LONGVARCHAR) { testReturn[parameterIndex - 1] = Types.VARCHAR; } else if (functionReturnType[parameterIndex - 1] == Types.FLOAT) { testReturn[parameterIndex - 1] = Types.REAL; // changes to streamline later error checking } returnTypeSet = true; } @Override public boolean wasNull() throws SQLException { if (lastIndex == 0 || callResult == null) { throw new PSQLException(GT.tr("wasNull cannot be call before fetching a result."), PSQLState.OBJECT_NOT_IN_STATE); } // check to see if the last access threw an exception return callResult[lastIndex - 1] == null; } @Override public /* @Nullable */ String getString(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.VARCHAR, "String"); return (String) result; } @Override public boolean getBoolean(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.BIT, "Boolean"); if (result == null) { return false; } return BooleanTypeUtil.castToBoolean(result); } @Override public byte getByte(/* @Positive */ int parameterIndex) throws SQLException { // fake tiny int with smallint Object result = checkIndex(parameterIndex, Types.SMALLINT, "Byte"); if (result == null) { return 0; } return ((Integer) result).byteValue(); } @Override public short getShort(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.SMALLINT, "Short"); if (result == null) { return 0; } return ((Integer) result).shortValue(); } @Override public int getInt(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.INTEGER, "Int"); if (result == null) { return 0; } return (Integer) result; } @Override public long getLong(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.BIGINT, "Long"); if (result == null) { return 0; } return (Long) result; } @Override public float getFloat(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.REAL, "Float"); if (result == null) { return 0; } return (Float) result; } @Override public double getDouble(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.DOUBLE, "Double"); if (result == null) { return 0; } return (Double) result; } @Override @SuppressWarnings("deprecation") public /* @Nullable */ BigDecimal getBigDecimal(/* @Positive */ int parameterIndex, int scale) throws SQLException { Object result = checkIndex(parameterIndex, Types.NUMERIC, "BigDecimal"); return (/* @Nullable */ BigDecimal) result; } @Override public byte /* @Nullable */ [] getBytes(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.VARBINARY, Types.BINARY, "Bytes"); return (byte /* @Nullable */ []) result; } @Override public /* @Nullable */ Date getDate(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.DATE, "Date"); return (/* @Nullable */ Date) result; } @Override public /* @Nullable */ Time getTime(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.TIME, "Time"); return (/* @Nullable */ Time) result; } @Override public /* @Nullable */ Timestamp getTimestamp(/* @Positive */ int parameterIndex) throws SQLException { Object result = checkIndex(parameterIndex, Types.TIMESTAMP, "Timestamp"); return (/* @Nullable */ Timestamp) result; } @Override public /* @Nullable */ Object getObject(/* @Positive */ int parameterIndex) throws SQLException { return getCallResult(parameterIndex); } /** * helperfunction for the getXXX calls to check isFunction and index == 1 Compare BOTH type fields * against the return type. * * @param parameterIndex parameter index (1-based) * @param type1 type 1 * @param type2 type 2 * @param getName getter name * @throws SQLException if something goes wrong */ protected /* @Nullable */ Object checkIndex(/* @Positive */ int parameterIndex, int type1, int type2, String getName) throws SQLException { Object result = getCallResult(parameterIndex); int testReturn = this.testReturn != null ? this.testReturn[parameterIndex - 1] : -1; if (type1 != testReturn && type2 != testReturn) { throw new PSQLException( GT.tr("Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was made.", "java.sql.Types=" + testReturn, getName, "java.sql.Types=" + type1), PSQLState.MOST_SPECIFIC_TYPE_DOES_NOT_MATCH); } return result; } /** * Helper function for the getXXX calls to check isFunction and index == 1. * * @param parameterIndex parameter index (1-based) * @param type type * @param getName getter name * @throws SQLException if given index is not valid */ protected /* @Nullable */ Object checkIndex(/* @Positive */ int parameterIndex, int type, String getName) throws SQLException { Object result = getCallResult(parameterIndex); int testReturn = this.testReturn != null ? this.testReturn[parameterIndex - 1] : -1; if (type != testReturn) { throw new PSQLException( GT.tr("Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was made.", "java.sql.Types=" + testReturn, getName, "java.sql.Types=" + type), PSQLState.MOST_SPECIFIC_TYPE_DOES_NOT_MATCH); } return result; } private /* @Nullable */ Object getCallResult(/* @Positive */ int parameterIndex) throws SQLException { checkClosed(); if (!isFunction) { throw new PSQLException( GT.tr( "A CallableStatement was declared, but no call to registerOutParameter(1,